001// $ANTLR 2.7.7 (20060906): "java.g" -> "GeneratedJavaRecognizer.java"$ 002 003package com.puppycrawl.tools.checkstyle.grammar; 004 005import com.puppycrawl.tools.checkstyle.DetailAstImpl; 006import java.text.MessageFormat; 007import antlr.CommonHiddenStreamToken; 008import antlr.TokenStreamSelector; 009 010import antlr.TokenBuffer; 011import antlr.TokenStreamException; 012import antlr.TokenStreamIOException; 013import antlr.ANTLRException; 014import antlr.LLkParser; 015import antlr.Token; 016import antlr.TokenStream; 017import antlr.RecognitionException; 018import antlr.NoViableAltException; 019import antlr.MismatchedTokenException; 020import antlr.SemanticException; 021import antlr.ParserSharedInputState; 022import antlr.collections.impl.BitSet; 023import antlr.collections.AST; 024import java.util.Hashtable; 025import antlr.ASTFactory; 026import antlr.ASTPair; 027import antlr.collections.impl.ASTArray; 028 029/** Java 1.5 Recognizer 030 * 031 * This grammar is in the PUBLIC DOMAIN 032 */ 033public class GeneratedJavaRecognizer extends antlr.LLkParser implements GeneratedJavaTokenTypes 034 { 035 036 /** 037 * Counts the number of LT seen in the typeArguments production. 038 * It is used in semantic predicates to ensure we have seen 039 * enough closing '>' characters; which actually may have been 040 * either GT, SR or BSR tokens. 041 */ 042 private int ltCounter = 0; 043 044 /** 045 * Counts the number of '>' characters that have been seen but 046 * have not yet been associated with the end of a typeParameters or 047 * typeArguments production. This is necessary because SR and BSR 048 * tokens have significance (the extra '>' characters) not only for the production 049 * that sees them but also productions higher in the stack (possibly right up to an outer-most 050 * typeParameters production). As the stack of the typeArguments/typeParameters productions 051 * unwind, any '>' characters seen prematurely through SRs or BSRs are reconciled. 052 */ 053 private int gtToReconcile = 0; 054 055 /** 056 * The most recently seen gt sequence (GT, SR or BSR) 057 * encountered in any type argument or type parameter production. 058 * We retain this so we can keep manage the synthetic GT tokens/ 059 * AST nodes we emit to have '<' & '>' balanced trees when encountering 060 * SR and BSR tokens. 061 */ 062 private DetailAstImpl currentGtSequence = null; 063 064 /** 065 * Consume a sequence of '>' characters (GT, SR or BSR) 066 * and match these against the '<' characters seen. 067 */ 068 private void consumeCurrentGtSequence(DetailAstImpl gtSequence) 069 { 070 currentGtSequence = gtSequence; 071 gtToReconcile += currentGtSequence.getText().length(); 072 ltCounter -= currentGtSequence.getText().length(); 073 } 074 075 /** 076 * Emits a single GT AST node with the line and column correctly 077 * set to its position in the source file. This must only 078 * ever be called when a typeParameters or typeArguments production 079 * is ending and there is at least one GT character to be emitted. 080 * 081 * @see #areThereGtsToEmit 082 */ 083 private DetailAstImpl emitSingleGt() 084 { 085 gtToReconcile -= 1; 086 CommonHiddenStreamToken gtToken = new CommonHiddenStreamToken(GENERIC_END, ">"); 087 gtToken.setLine(currentGtSequence.getLineNo()); 088 gtToken.setColumn(currentGtSequence.getColumnNo() 089 + (currentGtSequence.getText().length() - gtToReconcile)); 090 return (DetailAstImpl)astFactory.create(gtToken); 091 } 092 093 /** 094 * @return true if there is at least one '>' seen but 095 * not reconciled with the end of a typeParameters or 096 * typeArguments production; returns false otherwise 097 */ 098 private boolean areThereGtsToEmit() 099 { 100 return (gtToReconcile > 0); 101 } 102 103 /** 104 * @return true if there is exactly one '>' seen but 105 * not reconciled with the end of a typeParameters 106 * production; returns false otherwise 107 */ 108 private boolean isThereASingleGtToEmit() 109 { 110 return (gtToReconcile == 1); 111 } 112 113 /** 114 * @return true if the '<' and '>' are evenly matched 115 * at the current typeParameters/typeArguments nested depth 116 */ 117 private boolean areLtsAndGtsBalanced(int currentLtLevel) 118 { 119 return ((currentLtLevel != 0) || ltCounter == currentLtLevel); 120 } 121 122 /** 123 * This int value tracks the depth of a switch expression. Along with the 124 * IDENT to id rule at the end of the parser, this value helps us 125 * to know if the "yield" we are parsing is an IDENT, method call, class, 126 * field, etc. or if it is a java 13+ yield statement. Positive values 127 * indicate that we are within a (possibly nested) switch expression. 128 */ 129 private int switchBlockDepth = 0; 130 131protected GeneratedJavaRecognizer(TokenBuffer tokenBuf, int k) { 132 super(tokenBuf,k); 133 tokenNames = _tokenNames; 134 buildTokenTypeASTClassMap(); 135 astFactory = new ASTFactory(getTokenTypeToASTClassMap()); 136} 137 138public GeneratedJavaRecognizer(TokenBuffer tokenBuf) { 139 this(tokenBuf,2); 140} 141 142protected GeneratedJavaRecognizer(TokenStream lexer, int k) { 143 super(lexer,k); 144 tokenNames = _tokenNames; 145 buildTokenTypeASTClassMap(); 146 astFactory = new ASTFactory(getTokenTypeToASTClassMap()); 147} 148 149public GeneratedJavaRecognizer(TokenStream lexer) { 150 this(lexer,2); 151} 152 153public GeneratedJavaRecognizer(ParserSharedInputState state) { 154 super(state,2); 155 tokenNames = _tokenNames; 156 buildTokenTypeASTClassMap(); 157 astFactory = new ASTFactory(getTokenTypeToASTClassMap()); 158} 159 160 public final void compilationUnit() throws RecognitionException, TokenStreamException { 161 162 returnAST = null; 163 ASTPair currentAST = new ASTPair(); 164 AST compilationUnit_AST = null; 165 166 { 167 boolean synPredMatched4 = false; 168 if (((LA(1)==LITERAL_package||LA(1)==AT) && (_tokenSet_0.member(LA(2))))) { 169 int _m4 = mark(); 170 synPredMatched4 = true; 171 inputState.guessing++; 172 try { 173 { 174 annotations(); 175 match(LITERAL_package); 176 } 177 } 178 catch (RecognitionException pe) { 179 synPredMatched4 = false; 180 } 181 rewind(_m4); 182inputState.guessing--; 183 } 184 if ( synPredMatched4 ) { 185 packageDefinition(); 186 astFactory.addASTChild(currentAST, returnAST); 187 } 188 else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2)))) { 189 } 190 else { 191 throw new NoViableAltException(LT(1), getFilename()); 192 } 193 194 } 195 { 196 _loop6: 197 do { 198 if ((LA(1)==SEMI||LA(1)==LITERAL_import) && (_tokenSet_3.member(LA(2)))) { 199 importDefinition(); 200 astFactory.addASTChild(currentAST, returnAST); 201 } 202 else { 203 break _loop6; 204 } 205 206 } while (true); 207 } 208 { 209 _loop8: 210 do { 211 if ((_tokenSet_4.member(LA(1)))) { 212 typeDefinition(); 213 astFactory.addASTChild(currentAST, returnAST); 214 } 215 else { 216 break _loop8; 217 } 218 219 } while (true); 220 } 221 match(Token.EOF_TYPE); 222 compilationUnit_AST = (AST)currentAST.root; 223 returnAST = compilationUnit_AST; 224 } 225 226 public final void annotations() throws RecognitionException, TokenStreamException { 227 228 returnAST = null; 229 ASTPair currentAST = new ASTPair(); 230 AST annotations_AST = null; 231 232 { 233 _loop83: 234 do { 235 if ((LA(1)==AT) && (_tokenSet_0.member(LA(2)))) { 236 annotation(); 237 astFactory.addASTChild(currentAST, returnAST); 238 } 239 else { 240 break _loop83; 241 } 242 243 } while (true); 244 } 245 if ( inputState.guessing==0 ) { 246 annotations_AST = (AST)currentAST.root; 247 annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST)); 248 currentAST.root = annotations_AST; 249 currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ? 250 annotations_AST.getFirstChild() : annotations_AST; 251 currentAST.advanceChildToEnd(); 252 } 253 annotations_AST = (AST)currentAST.root; 254 returnAST = annotations_AST; 255 } 256 257 public final void packageDefinition() throws RecognitionException, TokenStreamException { 258 259 returnAST = null; 260 ASTPair currentAST = new ASTPair(); 261 AST packageDefinition_AST = null; 262 Token p = null; 263 AST p_AST = null; 264 265 try { // for error handling 266 annotations(); 267 astFactory.addASTChild(currentAST, returnAST); 268 p = LT(1); 269 p_AST = astFactory.create(p); 270 astFactory.makeASTRoot(currentAST, p_AST); 271 match(LITERAL_package); 272 if ( inputState.guessing==0 ) { 273 p_AST.setType(PACKAGE_DEF); 274 } 275 identifier(); 276 astFactory.addASTChild(currentAST, returnAST); 277 AST tmp2_AST = null; 278 tmp2_AST = astFactory.create(LT(1)); 279 astFactory.addASTChild(currentAST, tmp2_AST); 280 match(SEMI); 281 packageDefinition_AST = (AST)currentAST.root; 282 } 283 catch (RecognitionException ex) { 284 if (inputState.guessing==0) { 285 reportError(ex); 286 recover(ex,_tokenSet_1); 287 } else { 288 throw ex; 289 } 290 } 291 returnAST = packageDefinition_AST; 292 } 293 294 public final void importDefinition() throws RecognitionException, TokenStreamException { 295 296 returnAST = null; 297 ASTPair currentAST = new ASTPair(); 298 AST importDefinition_AST = null; 299 Token i = null; 300 AST i_AST = null; 301 302 try { // for error handling 303 switch ( LA(1)) { 304 case LITERAL_import: 305 { 306 i = LT(1); 307 i_AST = astFactory.create(i); 308 astFactory.makeASTRoot(currentAST, i_AST); 309 match(LITERAL_import); 310 if ( inputState.guessing==0 ) { 311 i_AST.setType(IMPORT); 312 } 313 { 314 switch ( LA(1)) { 315 case LITERAL_static: 316 { 317 AST tmp3_AST = null; 318 tmp3_AST = astFactory.create(LT(1)); 319 astFactory.addASTChild(currentAST, tmp3_AST); 320 match(LITERAL_static); 321 if ( inputState.guessing==0 ) { 322 i_AST.setType(STATIC_IMPORT); 323 } 324 break; 325 } 326 case IDENT: 327 case LITERAL_record: 328 case LITERAL_yield: 329 case LITERAL_sealed: 330 case LITERAL_permits: 331 case LITERAL_non: 332 { 333 break; 334 } 335 default: 336 { 337 throw new NoViableAltException(LT(1), getFilename()); 338 } 339 } 340 } 341 identifierStar(); 342 astFactory.addASTChild(currentAST, returnAST); 343 AST tmp4_AST = null; 344 tmp4_AST = astFactory.create(LT(1)); 345 astFactory.addASTChild(currentAST, tmp4_AST); 346 match(SEMI); 347 importDefinition_AST = (AST)currentAST.root; 348 break; 349 } 350 case SEMI: 351 { 352 AST tmp5_AST = null; 353 tmp5_AST = astFactory.create(LT(1)); 354 astFactory.addASTChild(currentAST, tmp5_AST); 355 match(SEMI); 356 importDefinition_AST = (AST)currentAST.root; 357 break; 358 } 359 default: 360 { 361 throw new NoViableAltException(LT(1), getFilename()); 362 } 363 } 364 } 365 catch (RecognitionException ex) { 366 if (inputState.guessing==0) { 367 reportError(ex); 368 recover(ex,_tokenSet_1); 369 } else { 370 throw ex; 371 } 372 } 373 returnAST = importDefinition_AST; 374 } 375 376 public final void typeDefinition() throws RecognitionException, TokenStreamException { 377 378 returnAST = null; 379 ASTPair currentAST = new ASTPair(); 380 AST typeDefinition_AST = null; 381 AST m_AST = null; 382 383 try { // for error handling 384 switch ( LA(1)) { 385 case FINAL: 386 case ABSTRACT: 387 case STRICTFP: 388 case LITERAL_private: 389 case LITERAL_public: 390 case LITERAL_protected: 391 case LITERAL_static: 392 case LITERAL_transient: 393 case LITERAL_native: 394 case LITERAL_synchronized: 395 case LITERAL_volatile: 396 case LITERAL_class: 397 case LITERAL_interface: 398 case LITERAL_default: 399 case ENUM: 400 case AT: 401 case LITERAL_record: 402 case LITERAL_sealed: 403 case LITERAL_non: 404 { 405 modifiers(); 406 m_AST = (AST)returnAST; 407 typeDefinitionInternal(m_AST); 408 astFactory.addASTChild(currentAST, returnAST); 409 typeDefinition_AST = (AST)currentAST.root; 410 break; 411 } 412 case SEMI: 413 { 414 AST tmp6_AST = null; 415 tmp6_AST = astFactory.create(LT(1)); 416 astFactory.addASTChild(currentAST, tmp6_AST); 417 match(SEMI); 418 typeDefinition_AST = (AST)currentAST.root; 419 break; 420 } 421 default: 422 { 423 throw new NoViableAltException(LT(1), getFilename()); 424 } 425 } 426 } 427 catch (RecognitionException ex) { 428 if (inputState.guessing==0) { 429 reportError(ex); 430 recover(ex,_tokenSet_5); 431 } else { 432 throw ex; 433 } 434 } 435 returnAST = typeDefinition_AST; 436 } 437 438 public final void identifier() throws RecognitionException, TokenStreamException { 439 440 returnAST = null; 441 ASTPair currentAST = new ASTPair(); 442 AST identifier_AST = null; 443 444 id(); 445 astFactory.addASTChild(currentAST, returnAST); 446 { 447 _loop68: 448 do { 449 if ((LA(1)==DOT)) { 450 AST tmp7_AST = null; 451 tmp7_AST = astFactory.create(LT(1)); 452 astFactory.makeASTRoot(currentAST, tmp7_AST); 453 match(DOT); 454 id(); 455 astFactory.addASTChild(currentAST, returnAST); 456 } 457 else { 458 break _loop68; 459 } 460 461 } while (true); 462 } 463 identifier_AST = (AST)currentAST.root; 464 returnAST = identifier_AST; 465 } 466 467 public final void identifierStar() throws RecognitionException, TokenStreamException { 468 469 returnAST = null; 470 ASTPair currentAST = new ASTPair(); 471 AST identifierStar_AST = null; 472 473 id(); 474 astFactory.addASTChild(currentAST, returnAST); 475 { 476 _loop71: 477 do { 478 if ((LA(1)==DOT) && (_tokenSet_0.member(LA(2)))) { 479 AST tmp8_AST = null; 480 tmp8_AST = astFactory.create(LT(1)); 481 astFactory.makeASTRoot(currentAST, tmp8_AST); 482 match(DOT); 483 id(); 484 astFactory.addASTChild(currentAST, returnAST); 485 } 486 else { 487 break _loop71; 488 } 489 490 } while (true); 491 } 492 { 493 switch ( LA(1)) { 494 case DOT: 495 { 496 AST tmp9_AST = null; 497 tmp9_AST = astFactory.create(LT(1)); 498 astFactory.makeASTRoot(currentAST, tmp9_AST); 499 match(DOT); 500 AST tmp10_AST = null; 501 tmp10_AST = astFactory.create(LT(1)); 502 astFactory.addASTChild(currentAST, tmp10_AST); 503 match(STAR); 504 break; 505 } 506 case SEMI: 507 { 508 break; 509 } 510 default: 511 { 512 throw new NoViableAltException(LT(1), getFilename()); 513 } 514 } 515 } 516 identifierStar_AST = (AST)currentAST.root; 517 returnAST = identifierStar_AST; 518 } 519 520 public final void modifiers() throws RecognitionException, TokenStreamException { 521 522 returnAST = null; 523 ASTPair currentAST = new ASTPair(); 524 AST modifiers_AST = null; 525 526 { 527 _loop75: 528 do { 529 if ((_tokenSet_6.member(LA(1))) && (_tokenSet_7.member(LA(2)))) { 530 modifier(); 531 astFactory.addASTChild(currentAST, returnAST); 532 } 533 else if (((LA(1)==AT) && (_tokenSet_0.member(LA(2))))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) { 534 annotation(); 535 astFactory.addASTChild(currentAST, returnAST); 536 } 537 else { 538 break _loop75; 539 } 540 541 } while (true); 542 } 543 if ( inputState.guessing==0 ) { 544 modifiers_AST = (AST)currentAST.root; 545 modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST)); 546 currentAST.root = modifiers_AST; 547 currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ? 548 modifiers_AST.getFirstChild() : modifiers_AST; 549 currentAST.advanceChildToEnd(); 550 } 551 modifiers_AST = (AST)currentAST.root; 552 returnAST = modifiers_AST; 553 } 554 555 protected final void typeDefinitionInternal( 556 AST modifiers 557 ) throws RecognitionException, TokenStreamException { 558 559 returnAST = null; 560 ASTPair currentAST = new ASTPair(); 561 AST typeDefinitionInternal_AST = null; 562 563 switch ( LA(1)) { 564 case LITERAL_class: 565 { 566 classDefinition(modifiers); 567 astFactory.addASTChild(currentAST, returnAST); 568 typeDefinitionInternal_AST = (AST)currentAST.root; 569 break; 570 } 571 case LITERAL_interface: 572 { 573 interfaceDefinition(modifiers); 574 astFactory.addASTChild(currentAST, returnAST); 575 typeDefinitionInternal_AST = (AST)currentAST.root; 576 break; 577 } 578 case ENUM: 579 { 580 enumDefinition(modifiers); 581 astFactory.addASTChild(currentAST, returnAST); 582 typeDefinitionInternal_AST = (AST)currentAST.root; 583 break; 584 } 585 case AT: 586 { 587 annotationDefinition(modifiers); 588 astFactory.addASTChild(currentAST, returnAST); 589 typeDefinitionInternal_AST = (AST)currentAST.root; 590 break; 591 } 592 case LITERAL_record: 593 { 594 recordDefinition(modifiers); 595 astFactory.addASTChild(currentAST, returnAST); 596 typeDefinitionInternal_AST = (AST)currentAST.root; 597 break; 598 } 599 default: 600 { 601 throw new NoViableAltException(LT(1), getFilename()); 602 } 603 } 604 returnAST = typeDefinitionInternal_AST; 605 } 606 607 public final void classDefinition( 608 AST modifiers 609 ) throws RecognitionException, TokenStreamException { 610 611 returnAST = null; 612 ASTPair currentAST = new ASTPair(); 613 AST classDefinition_AST = null; 614 Token c = null; 615 AST c_AST = null; 616 AST id_AST = null; 617 AST tp_AST = null; 618 AST sc_AST = null; 619 AST ic_AST = null; 620 AST ps_AST = null; 621 AST cb_AST = null; 622 623 c = LT(1); 624 c_AST = astFactory.create(c); 625 match(LITERAL_class); 626 id(); 627 id_AST = (AST)returnAST; 628 { 629 switch ( LA(1)) { 630 case LT: 631 { 632 typeParameters(); 633 tp_AST = (AST)returnAST; 634 break; 635 } 636 case LITERAL_extends: 637 case LCURLY: 638 case LITERAL_implements: 639 case LITERAL_permits: 640 { 641 break; 642 } 643 default: 644 { 645 throw new NoViableAltException(LT(1), getFilename()); 646 } 647 } 648 } 649 superClassClause(); 650 sc_AST = (AST)returnAST; 651 implementsClause(); 652 ic_AST = (AST)returnAST; 653 permittedSubclassesAndInterfaces(); 654 ps_AST = (AST)returnAST; 655 classBlock(); 656 cb_AST = (AST)returnAST; 657 if ( inputState.guessing==0 ) { 658 classDefinition_AST = (AST)currentAST.root; 659 classDefinition_AST = (AST)astFactory.make( (new ASTArray(9)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(c_AST).add(id_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(ps_AST).add(cb_AST)); 660 currentAST.root = classDefinition_AST; 661 currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ? 662 classDefinition_AST.getFirstChild() : classDefinition_AST; 663 currentAST.advanceChildToEnd(); 664 } 665 returnAST = classDefinition_AST; 666 } 667 668 public final void interfaceDefinition( 669 AST modifiers 670 ) throws RecognitionException, TokenStreamException { 671 672 returnAST = null; 673 ASTPair currentAST = new ASTPair(); 674 AST interfaceDefinition_AST = null; 675 Token i = null; 676 AST i_AST = null; 677 AST id_AST = null; 678 AST tp_AST = null; 679 AST ie_AST = null; 680 AST ps_AST = null; 681 AST cb_AST = null; 682 683 i = LT(1); 684 i_AST = astFactory.create(i); 685 match(LITERAL_interface); 686 id(); 687 id_AST = (AST)returnAST; 688 { 689 switch ( LA(1)) { 690 case LT: 691 { 692 typeParameters(); 693 tp_AST = (AST)returnAST; 694 break; 695 } 696 case LITERAL_extends: 697 case LCURLY: 698 case LITERAL_permits: 699 { 700 break; 701 } 702 default: 703 { 704 throw new NoViableAltException(LT(1), getFilename()); 705 } 706 } 707 } 708 interfaceExtends(); 709 ie_AST = (AST)returnAST; 710 permittedSubclassesAndInterfaces(); 711 ps_AST = (AST)returnAST; 712 classBlock(); 713 cb_AST = (AST)returnAST; 714 if ( inputState.guessing==0 ) { 715 interfaceDefinition_AST = (AST)currentAST.root; 716 interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(i_AST).add(id_AST).add(tp_AST).add(ie_AST).add(ps_AST).add(cb_AST)); 717 currentAST.root = interfaceDefinition_AST; 718 currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ? 719 interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST; 720 currentAST.advanceChildToEnd(); 721 } 722 returnAST = interfaceDefinition_AST; 723 } 724 725 public final void enumDefinition( 726 AST modifiers 727 ) throws RecognitionException, TokenStreamException { 728 729 returnAST = null; 730 ASTPair currentAST = new ASTPair(); 731 AST enumDefinition_AST = null; 732 Token e = null; 733 AST e_AST = null; 734 AST id_AST = null; 735 AST ic_AST = null; 736 AST eb_AST = null; 737 738 e = LT(1); 739 e_AST = astFactory.create(e); 740 match(ENUM); 741 id(); 742 id_AST = (AST)returnAST; 743 implementsClause(); 744 ic_AST = (AST)returnAST; 745 enumBlock(); 746 eb_AST = (AST)returnAST; 747 if ( inputState.guessing==0 ) { 748 enumDefinition_AST = (AST)currentAST.root; 749 enumDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(e_AST).add(id_AST).add(ic_AST).add(eb_AST)); 750 currentAST.root = enumDefinition_AST; 751 currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ? 752 enumDefinition_AST.getFirstChild() : enumDefinition_AST; 753 currentAST.advanceChildToEnd(); 754 } 755 returnAST = enumDefinition_AST; 756 } 757 758 public final void annotationDefinition( 759 AST modifiers 760 ) throws RecognitionException, TokenStreamException { 761 762 returnAST = null; 763 ASTPair currentAST = new ASTPair(); 764 AST annotationDefinition_AST = null; 765 Token a = null; 766 AST a_AST = null; 767 Token i = null; 768 AST i_AST = null; 769 AST id_AST = null; 770 AST ab_AST = null; 771 772 a = LT(1); 773 a_AST = astFactory.create(a); 774 match(AT); 775 i = LT(1); 776 i_AST = astFactory.create(i); 777 match(LITERAL_interface); 778 id(); 779 id_AST = (AST)returnAST; 780 annotationBlock(); 781 ab_AST = (AST)returnAST; 782 if ( inputState.guessing==0 ) { 783 annotationDefinition_AST = (AST)currentAST.root; 784 annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(a_AST).add(i_AST).add(id_AST).add(ab_AST)); 785 currentAST.root = annotationDefinition_AST; 786 currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ? 787 annotationDefinition_AST.getFirstChild() : annotationDefinition_AST; 788 currentAST.advanceChildToEnd(); 789 } 790 returnAST = annotationDefinition_AST; 791 } 792 793 public final void recordDefinition( 794 AST modifiers 795 ) throws RecognitionException, TokenStreamException { 796 797 returnAST = null; 798 ASTPair currentAST = new ASTPair(); 799 AST recordDefinition_AST = null; 800 Token r = null; 801 AST r_AST = null; 802 AST id_AST = null; 803 AST tp_AST = null; 804 AST rc_AST = null; 805 AST ic_AST = null; 806 AST rb_AST = null; 807 808 r = LT(1); 809 r_AST = astFactory.create(r); 810 match(LITERAL_record); 811 id(); 812 id_AST = (AST)returnAST; 813 { 814 switch ( LA(1)) { 815 case LT: 816 { 817 typeParameters(); 818 tp_AST = (AST)returnAST; 819 break; 820 } 821 case LPAREN: 822 { 823 break; 824 } 825 default: 826 { 827 throw new NoViableAltException(LT(1), getFilename()); 828 } 829 } 830 } 831 recordComponentsList(); 832 rc_AST = (AST)returnAST; 833 implementsClause(); 834 ic_AST = (AST)returnAST; 835 recordBodyDeclaration(); 836 rb_AST = (AST)returnAST; 837 if ( inputState.guessing==0 ) { 838 recordDefinition_AST = (AST)currentAST.root; 839 recordDefinition_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(RECORD_DEF,"RECORD_DEF")).add(modifiers).add(r_AST).add(id_AST).add(tp_AST).add(rc_AST).add(ic_AST).add(rb_AST)); 840 currentAST.root = recordDefinition_AST; 841 currentAST.child = recordDefinition_AST!=null &&recordDefinition_AST.getFirstChild()!=null ? 842 recordDefinition_AST.getFirstChild() : recordDefinition_AST; 843 currentAST.advanceChildToEnd(); 844 } 845 returnAST = recordDefinition_AST; 846 } 847 848 public final void typeSpec( 849 boolean addImagNode 850 ) throws RecognitionException, TokenStreamException { 851 852 returnAST = null; 853 ASTPair currentAST = new ASTPair(); 854 AST typeSpec_AST = null; 855 856 switch ( LA(1)) { 857 case IDENT: 858 case AT: 859 case LITERAL_record: 860 case LITERAL_yield: 861 case LITERAL_sealed: 862 case LITERAL_permits: 863 case LITERAL_non: 864 { 865 classTypeSpec(addImagNode); 866 astFactory.addASTChild(currentAST, returnAST); 867 typeSpec_AST = (AST)currentAST.root; 868 break; 869 } 870 case LITERAL_void: 871 case LITERAL_boolean: 872 case LITERAL_byte: 873 case LITERAL_char: 874 case LITERAL_short: 875 case LITERAL_int: 876 case LITERAL_float: 877 case LITERAL_long: 878 case LITERAL_double: 879 { 880 builtInTypeSpec(addImagNode); 881 astFactory.addASTChild(currentAST, returnAST); 882 typeSpec_AST = (AST)currentAST.root; 883 break; 884 } 885 default: 886 { 887 throw new NoViableAltException(LT(1), getFilename()); 888 } 889 } 890 returnAST = typeSpec_AST; 891 } 892 893 public final void classTypeSpec( 894 boolean addImagNode 895 ) throws RecognitionException, TokenStreamException { 896 897 returnAST = null; 898 ASTPair currentAST = new ASTPair(); 899 AST classTypeSpec_AST = null; 900 901 classOrInterfaceType(addImagNode); 902 astFactory.addASTChild(currentAST, returnAST); 903 typeSpecBracketsAndAnnotations(); 904 astFactory.addASTChild(currentAST, returnAST); 905 if ( inputState.guessing==0 ) { 906 classTypeSpec_AST = (AST)currentAST.root; 907 908 if ( addImagNode ) { 909 classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST)); 910 } 911 912 currentAST.root = classTypeSpec_AST; 913 currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ? 914 classTypeSpec_AST.getFirstChild() : classTypeSpec_AST; 915 currentAST.advanceChildToEnd(); 916 } 917 classTypeSpec_AST = (AST)currentAST.root; 918 returnAST = classTypeSpec_AST; 919 } 920 921 public final void builtInTypeSpec( 922 boolean addImagNode 923 ) throws RecognitionException, TokenStreamException { 924 925 returnAST = null; 926 ASTPair currentAST = new ASTPair(); 927 AST builtInTypeSpec_AST = null; 928 AST b_AST = null; 929 AST a_AST = null; 930 931 builtInType(); 932 b_AST = (AST)returnAST; 933 astFactory.addASTChild(currentAST, returnAST); 934 typeSpecBracketsAndAnnotations(); 935 a_AST = (AST)returnAST; 936 astFactory.addASTChild(currentAST, returnAST); 937 if ( inputState.guessing==0 ) { 938 builtInTypeSpec_AST = (AST)currentAST.root; 939 940 if ( addImagNode ) { 941 builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST)); 942 } 943 else if (a_AST != null) { 944 builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(1)).add(b_AST)); 945 } 946 947 currentAST.root = builtInTypeSpec_AST; 948 currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ? 949 builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST; 950 currentAST.advanceChildToEnd(); 951 } 952 builtInTypeSpec_AST = (AST)currentAST.root; 953 returnAST = builtInTypeSpec_AST; 954 } 955 956 public final void variableLengthParameterTypeSpec() throws RecognitionException, TokenStreamException { 957 958 returnAST = null; 959 ASTPair currentAST = new ASTPair(); 960 AST variableLengthParameterTypeSpec_AST = null; 961 962 { 963 switch ( LA(1)) { 964 case IDENT: 965 case AT: 966 case LITERAL_record: 967 case LITERAL_yield: 968 case LITERAL_sealed: 969 case LITERAL_permits: 970 case LITERAL_non: 971 { 972 classOrInterfaceType(false); 973 astFactory.addASTChild(currentAST, returnAST); 974 break; 975 } 976 case LITERAL_void: 977 case LITERAL_boolean: 978 case LITERAL_byte: 979 case LITERAL_char: 980 case LITERAL_short: 981 case LITERAL_int: 982 case LITERAL_float: 983 case LITERAL_long: 984 case LITERAL_double: 985 { 986 builtInType(); 987 astFactory.addASTChild(currentAST, returnAST); 988 break; 989 } 990 default: 991 { 992 throw new NoViableAltException(LT(1), getFilename()); 993 } 994 } 995 } 996 { 997 if (((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2))))&&(LA(1) == AT)) { 998 annotations(); 999 astFactory.addASTChild(currentAST, returnAST); 1000 } 1001 else if ((LA(1)==LBRACK||LA(1)==ELLIPSIS) && (_tokenSet_9.member(LA(2)))) { 1002 } 1003 else { 1004 throw new NoViableAltException(LT(1), getFilename()); 1005 } 1006 1007 } 1008 variableLengthParameterTypeSpecArrayBrackets(); 1009 astFactory.addASTChild(currentAST, returnAST); 1010 variableLengthParameterTypeSpec_AST = (AST)currentAST.root; 1011 returnAST = variableLengthParameterTypeSpec_AST; 1012 } 1013 1014 public final void classOrInterfaceType( 1015 boolean addImagNode 1016 ) throws RecognitionException, TokenStreamException { 1017 1018 returnAST = null; 1019 ASTPair currentAST = new ASTPair(); 1020 AST classOrInterfaceType_AST = null; 1021 1022 { 1023 if (((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2))))&&(LA(1) == AT)) { 1024 annotations(); 1025 astFactory.addASTChild(currentAST, returnAST); 1026 } 1027 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_11.member(LA(2)))) { 1028 } 1029 else { 1030 throw new NoViableAltException(LT(1), getFilename()); 1031 } 1032 1033 } 1034 id(); 1035 astFactory.addASTChild(currentAST, returnAST); 1036 { 1037 if ((LA(1)==LT) && (_tokenSet_11.member(LA(2)))) { 1038 typeArguments(addImagNode); 1039 astFactory.addASTChild(currentAST, returnAST); 1040 } 1041 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) { 1042 } 1043 else { 1044 throw new NoViableAltException(LT(1), getFilename()); 1045 } 1046 1047 } 1048 { 1049 _loop29: 1050 do { 1051 if ((LA(1)==DOT) && (_tokenSet_10.member(LA(2)))) { 1052 AST tmp11_AST = null; 1053 tmp11_AST = astFactory.create(LT(1)); 1054 astFactory.makeASTRoot(currentAST, tmp11_AST); 1055 match(DOT); 1056 { 1057 if (((_tokenSet_10.member(LA(1))) && (_tokenSet_11.member(LA(2))))&&(LA(1) == AT)) { 1058 annotations(); 1059 astFactory.addASTChild(currentAST, returnAST); 1060 } 1061 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_11.member(LA(2)))) { 1062 } 1063 else { 1064 throw new NoViableAltException(LT(1), getFilename()); 1065 } 1066 1067 } 1068 id(); 1069 astFactory.addASTChild(currentAST, returnAST); 1070 { 1071 if ((LA(1)==LT) && (_tokenSet_11.member(LA(2)))) { 1072 typeArguments(addImagNode); 1073 astFactory.addASTChild(currentAST, returnAST); 1074 } 1075 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) { 1076 } 1077 else { 1078 throw new NoViableAltException(LT(1), getFilename()); 1079 } 1080 1081 } 1082 } 1083 else { 1084 break _loop29; 1085 } 1086 1087 } while (true); 1088 } 1089 classOrInterfaceType_AST = (AST)currentAST.root; 1090 returnAST = classOrInterfaceType_AST; 1091 } 1092 1093 public final void builtInType() throws RecognitionException, TokenStreamException { 1094 1095 returnAST = null; 1096 ASTPair currentAST = new ASTPair(); 1097 AST builtInType_AST = null; 1098 1099 switch ( LA(1)) { 1100 case LITERAL_void: 1101 { 1102 AST tmp12_AST = null; 1103 tmp12_AST = astFactory.create(LT(1)); 1104 astFactory.addASTChild(currentAST, tmp12_AST); 1105 match(LITERAL_void); 1106 builtInType_AST = (AST)currentAST.root; 1107 break; 1108 } 1109 case LITERAL_boolean: 1110 { 1111 AST tmp13_AST = null; 1112 tmp13_AST = astFactory.create(LT(1)); 1113 astFactory.addASTChild(currentAST, tmp13_AST); 1114 match(LITERAL_boolean); 1115 builtInType_AST = (AST)currentAST.root; 1116 break; 1117 } 1118 case LITERAL_byte: 1119 { 1120 AST tmp14_AST = null; 1121 tmp14_AST = astFactory.create(LT(1)); 1122 astFactory.addASTChild(currentAST, tmp14_AST); 1123 match(LITERAL_byte); 1124 builtInType_AST = (AST)currentAST.root; 1125 break; 1126 } 1127 case LITERAL_char: 1128 { 1129 AST tmp15_AST = null; 1130 tmp15_AST = astFactory.create(LT(1)); 1131 astFactory.addASTChild(currentAST, tmp15_AST); 1132 match(LITERAL_char); 1133 builtInType_AST = (AST)currentAST.root; 1134 break; 1135 } 1136 case LITERAL_short: 1137 { 1138 AST tmp16_AST = null; 1139 tmp16_AST = astFactory.create(LT(1)); 1140 astFactory.addASTChild(currentAST, tmp16_AST); 1141 match(LITERAL_short); 1142 builtInType_AST = (AST)currentAST.root; 1143 break; 1144 } 1145 case LITERAL_int: 1146 { 1147 AST tmp17_AST = null; 1148 tmp17_AST = astFactory.create(LT(1)); 1149 astFactory.addASTChild(currentAST, tmp17_AST); 1150 match(LITERAL_int); 1151 builtInType_AST = (AST)currentAST.root; 1152 break; 1153 } 1154 case LITERAL_float: 1155 { 1156 AST tmp18_AST = null; 1157 tmp18_AST = astFactory.create(LT(1)); 1158 astFactory.addASTChild(currentAST, tmp18_AST); 1159 match(LITERAL_float); 1160 builtInType_AST = (AST)currentAST.root; 1161 break; 1162 } 1163 case LITERAL_long: 1164 { 1165 AST tmp19_AST = null; 1166 tmp19_AST = astFactory.create(LT(1)); 1167 astFactory.addASTChild(currentAST, tmp19_AST); 1168 match(LITERAL_long); 1169 builtInType_AST = (AST)currentAST.root; 1170 break; 1171 } 1172 case LITERAL_double: 1173 { 1174 AST tmp20_AST = null; 1175 tmp20_AST = astFactory.create(LT(1)); 1176 astFactory.addASTChild(currentAST, tmp20_AST); 1177 match(LITERAL_double); 1178 builtInType_AST = (AST)currentAST.root; 1179 break; 1180 } 1181 default: 1182 { 1183 throw new NoViableAltException(LT(1), getFilename()); 1184 } 1185 } 1186 returnAST = builtInType_AST; 1187 } 1188 1189 public final void variableLengthParameterTypeSpecArrayBrackets() throws RecognitionException, TokenStreamException { 1190 1191 returnAST = null; 1192 ASTPair currentAST = new ASTPair(); 1193 AST variableLengthParameterTypeSpecArrayBrackets_AST = null; 1194 1195 { 1196 _loop21: 1197 do { 1198 if ((LA(1)==LBRACK)) { 1199 brackets(); 1200 astFactory.addASTChild(currentAST, returnAST); 1201 { 1202 if (((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2))))&&(LA(1) == AT)) { 1203 annotations(); 1204 astFactory.addASTChild(currentAST, returnAST); 1205 } 1206 else if ((LA(1)==LBRACK||LA(1)==ELLIPSIS) && (_tokenSet_9.member(LA(2)))) { 1207 } 1208 else { 1209 throw new NoViableAltException(LT(1), getFilename()); 1210 } 1211 1212 } 1213 } 1214 else { 1215 break _loop21; 1216 } 1217 1218 } while (true); 1219 } 1220 variableLengthParameterTypeSpecArrayBrackets_AST = (AST)currentAST.root; 1221 returnAST = variableLengthParameterTypeSpecArrayBrackets_AST; 1222 } 1223 1224 public final void brackets() throws RecognitionException, TokenStreamException { 1225 1226 returnAST = null; 1227 ASTPair currentAST = new ASTPair(); 1228 AST brackets_AST = null; 1229 Token lb = null; 1230 AST lb_AST = null; 1231 Token rb = null; 1232 AST rb_AST = null; 1233 1234 { 1235 lb = LT(1); 1236 lb_AST = astFactory.create(lb); 1237 astFactory.makeASTRoot(currentAST, lb_AST); 1238 match(LBRACK); 1239 if ( inputState.guessing==0 ) { 1240 lb_AST.setType(ARRAY_DECLARATOR); 1241 } 1242 rb = LT(1); 1243 rb_AST = astFactory.create(rb); 1244 astFactory.addASTChild(currentAST, rb_AST); 1245 match(RBRACK); 1246 } 1247 brackets_AST = (AST)currentAST.root; 1248 returnAST = brackets_AST; 1249 } 1250 1251 public final void typeSpecBracketsAndAnnotations() throws RecognitionException, TokenStreamException { 1252 1253 returnAST = null; 1254 ASTPair currentAST = new ASTPair(); 1255 AST typeSpecBracketsAndAnnotations_AST = null; 1256 1257 { 1258 _loop58: 1259 do { 1260 if ((LA(1)==LBRACK||LA(1)==AT) && (_tokenSet_9.member(LA(2)))) { 1261 { 1262 if (((LA(1)==LBRACK||LA(1)==AT) && (_tokenSet_9.member(LA(2))))&&(LA(1) == AT)) { 1263 annotations(); 1264 astFactory.addASTChild(currentAST, returnAST); 1265 } 1266 else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 1267 } 1268 else { 1269 throw new NoViableAltException(LT(1), getFilename()); 1270 } 1271 1272 } 1273 brackets(); 1274 astFactory.addASTChild(currentAST, returnAST); 1275 } 1276 else { 1277 break _loop58; 1278 } 1279 1280 } while (true); 1281 } 1282 typeSpecBracketsAndAnnotations_AST = (AST)currentAST.root; 1283 returnAST = typeSpecBracketsAndAnnotations_AST; 1284 } 1285 1286 public final void id() throws RecognitionException, TokenStreamException { 1287 1288 returnAST = null; 1289 ASTPair currentAST = new ASTPair(); 1290 AST id_AST = null; 1291 1292 switch ( LA(1)) { 1293 case IDENT: 1294 { 1295 AST tmp21_AST = null; 1296 tmp21_AST = astFactory.create(LT(1)); 1297 astFactory.addASTChild(currentAST, tmp21_AST); 1298 match(IDENT); 1299 id_AST = (AST)currentAST.root; 1300 break; 1301 } 1302 case LITERAL_record: 1303 { 1304 recordKey(); 1305 astFactory.addASTChild(currentAST, returnAST); 1306 id_AST = (AST)currentAST.root; 1307 break; 1308 } 1309 case LITERAL_yield: 1310 { 1311 yieldKey(); 1312 astFactory.addASTChild(currentAST, returnAST); 1313 id_AST = (AST)currentAST.root; 1314 break; 1315 } 1316 case LITERAL_non: 1317 { 1318 nonKey(); 1319 astFactory.addASTChild(currentAST, returnAST); 1320 id_AST = (AST)currentAST.root; 1321 break; 1322 } 1323 case LITERAL_sealed: 1324 { 1325 sealedKey(); 1326 astFactory.addASTChild(currentAST, returnAST); 1327 id_AST = (AST)currentAST.root; 1328 break; 1329 } 1330 case LITERAL_permits: 1331 { 1332 permitsKey(); 1333 astFactory.addASTChild(currentAST, returnAST); 1334 id_AST = (AST)currentAST.root; 1335 break; 1336 } 1337 default: 1338 { 1339 throw new NoViableAltException(LT(1), getFilename()); 1340 } 1341 } 1342 returnAST = id_AST; 1343 } 1344 1345 public final void typeArguments( 1346 boolean addImagNode 1347 ) throws RecognitionException, TokenStreamException { 1348 1349 returnAST = null; 1350 ASTPair currentAST = new ASTPair(); 1351 AST typeArguments_AST = null; 1352 Token lt = null; 1353 AST lt_AST = null; 1354 int currentLtLevel = 0; 1355 1356 if ( inputState.guessing==0 ) { 1357 currentLtLevel = ltCounter; 1358 } 1359 lt = LT(1); 1360 lt_AST = astFactory.create(lt); 1361 astFactory.addASTChild(currentAST, lt_AST); 1362 match(LT); 1363 if ( inputState.guessing==0 ) { 1364 lt_AST.setType(GENERIC_START); ;ltCounter++; 1365 } 1366 { 1367 if ((_tokenSet_13.member(LA(1))) && (_tokenSet_11.member(LA(2)))) { 1368 typeArgument(addImagNode); 1369 astFactory.addASTChild(currentAST, returnAST); 1370 { 1371 _loop41: 1372 do { 1373 if (((LA(1)==COMMA) && (_tokenSet_13.member(LA(2))))&&(gtToReconcile == 0)) { 1374 AST tmp22_AST = null; 1375 tmp22_AST = astFactory.create(LT(1)); 1376 astFactory.addASTChild(currentAST, tmp22_AST); 1377 match(COMMA); 1378 typeArgument(addImagNode); 1379 astFactory.addASTChild(currentAST, returnAST); 1380 } 1381 else { 1382 break _loop41; 1383 } 1384 1385 } while (true); 1386 } 1387 } 1388 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) { 1389 } 1390 else { 1391 throw new NoViableAltException(LT(1), getFilename()); 1392 } 1393 1394 } 1395 { 1396 if ((_tokenSet_14.member(LA(1))) && (_tokenSet_11.member(LA(2)))) { 1397 typeArgumentsOrParametersEnd(); 1398 astFactory.addASTChild(currentAST, returnAST); 1399 } 1400 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) { 1401 } 1402 else { 1403 throw new NoViableAltException(LT(1), getFilename()); 1404 } 1405 1406 } 1407 if ( inputState.guessing==0 ) { 1408 1409 if (areThereGtsToEmit()) 1410 { 1411 astFactory.addASTChild(currentAST, emitSingleGt()); 1412 } 1413 1414 } 1415 if (!(areLtsAndGtsBalanced(currentLtLevel))) 1416 throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)"); 1417 if ( inputState.guessing==0 ) { 1418 typeArguments_AST = (AST)currentAST.root; 1419 typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).add(typeArguments_AST)); 1420 currentAST.root = typeArguments_AST; 1421 currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ? 1422 typeArguments_AST.getFirstChild() : typeArguments_AST; 1423 currentAST.advanceChildToEnd(); 1424 } 1425 typeArguments_AST = (AST)currentAST.root; 1426 returnAST = typeArguments_AST; 1427 } 1428 1429 public final void typeArgument( 1430 boolean addImagNode 1431 ) throws RecognitionException, TokenStreamException { 1432 1433 returnAST = null; 1434 ASTPair currentAST = new ASTPair(); 1435 AST typeArgument_AST = null; 1436 1437 { 1438 { 1439 if (((_tokenSet_13.member(LA(1))) && (_tokenSet_11.member(LA(2))))&&(LA(1) == AT)) { 1440 annotations(); 1441 astFactory.addASTChild(currentAST, returnAST); 1442 } 1443 else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_11.member(LA(2)))) { 1444 } 1445 else { 1446 throw new NoViableAltException(LT(1), getFilename()); 1447 } 1448 1449 } 1450 { 1451 switch ( LA(1)) { 1452 case IDENT: 1453 case AT: 1454 case LITERAL_record: 1455 case LITERAL_yield: 1456 case LITERAL_sealed: 1457 case LITERAL_permits: 1458 case LITERAL_non: 1459 { 1460 classTypeSpec(addImagNode); 1461 astFactory.addASTChild(currentAST, returnAST); 1462 break; 1463 } 1464 case LITERAL_void: 1465 case LITERAL_boolean: 1466 case LITERAL_byte: 1467 case LITERAL_char: 1468 case LITERAL_short: 1469 case LITERAL_int: 1470 case LITERAL_float: 1471 case LITERAL_long: 1472 case LITERAL_double: 1473 { 1474 builtInTypeSpec(addImagNode); 1475 astFactory.addASTChild(currentAST, returnAST); 1476 break; 1477 } 1478 case QUESTION: 1479 { 1480 wildcardType(addImagNode); 1481 astFactory.addASTChild(currentAST, returnAST); 1482 break; 1483 } 1484 default: 1485 { 1486 throw new NoViableAltException(LT(1), getFilename()); 1487 } 1488 } 1489 } 1490 } 1491 if ( inputState.guessing==0 ) { 1492 typeArgument_AST = (AST)currentAST.root; 1493 typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).add(typeArgument_AST)); 1494 currentAST.root = typeArgument_AST; 1495 currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ? 1496 typeArgument_AST.getFirstChild() : typeArgument_AST; 1497 currentAST.advanceChildToEnd(); 1498 } 1499 typeArgument_AST = (AST)currentAST.root; 1500 returnAST = typeArgument_AST; 1501 } 1502 1503 public final void wildcardType( 1504 boolean addImagNode 1505 ) throws RecognitionException, TokenStreamException { 1506 1507 returnAST = null; 1508 ASTPair currentAST = new ASTPair(); 1509 AST wildcardType_AST = null; 1510 Token q = null; 1511 AST q_AST = null; 1512 1513 q = LT(1); 1514 q_AST = astFactory.create(q); 1515 astFactory.addASTChild(currentAST, q_AST); 1516 match(QUESTION); 1517 if ( inputState.guessing==0 ) { 1518 q_AST.setType(WILDCARD_TYPE); 1519 } 1520 { 1521 boolean synPredMatched37 = false; 1522 if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (_tokenSet_15.member(LA(2))))) { 1523 int _m37 = mark(); 1524 synPredMatched37 = true; 1525 inputState.guessing++; 1526 try { 1527 { 1528 switch ( LA(1)) { 1529 case LITERAL_extends: 1530 { 1531 match(LITERAL_extends); 1532 break; 1533 } 1534 case LITERAL_super: 1535 { 1536 match(LITERAL_super); 1537 break; 1538 } 1539 default: 1540 { 1541 throw new NoViableAltException(LT(1), getFilename()); 1542 } 1543 } 1544 } 1545 } 1546 catch (RecognitionException pe) { 1547 synPredMatched37 = false; 1548 } 1549 rewind(_m37); 1550inputState.guessing--; 1551 } 1552 if ( synPredMatched37 ) { 1553 typeArgumentBounds(addImagNode); 1554 astFactory.addASTChild(currentAST, returnAST); 1555 } 1556 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) { 1557 } 1558 else { 1559 throw new NoViableAltException(LT(1), getFilename()); 1560 } 1561 1562 } 1563 wildcardType_AST = (AST)currentAST.root; 1564 returnAST = wildcardType_AST; 1565 } 1566 1567 public final void typeArgumentBounds( 1568 boolean addImagNode 1569 ) throws RecognitionException, TokenStreamException { 1570 1571 returnAST = null; 1572 ASTPair currentAST = new ASTPair(); 1573 AST typeArgumentBounds_AST = null; 1574 Token e = null; 1575 AST e_AST = null; 1576 Token s = null; 1577 AST s_AST = null; 1578 1579 { 1580 switch ( LA(1)) { 1581 case LITERAL_extends: 1582 { 1583 e = LT(1); 1584 e_AST = astFactory.create(e); 1585 astFactory.makeASTRoot(currentAST, e_AST); 1586 match(LITERAL_extends); 1587 if ( inputState.guessing==0 ) { 1588 e_AST.setType(TYPE_UPPER_BOUNDS); 1589 } 1590 break; 1591 } 1592 case LITERAL_super: 1593 { 1594 s = LT(1); 1595 s_AST = astFactory.create(s); 1596 astFactory.makeASTRoot(currentAST, s_AST); 1597 match(LITERAL_super); 1598 if ( inputState.guessing==0 ) { 1599 s_AST.setType(TYPE_LOWER_BOUNDS); 1600 } 1601 break; 1602 } 1603 default: 1604 { 1605 throw new NoViableAltException(LT(1), getFilename()); 1606 } 1607 } 1608 } 1609 { 1610 switch ( LA(1)) { 1611 case IDENT: 1612 case AT: 1613 case LITERAL_record: 1614 case LITERAL_yield: 1615 case LITERAL_sealed: 1616 case LITERAL_permits: 1617 case LITERAL_non: 1618 { 1619 classOrInterfaceType(addImagNode); 1620 astFactory.addASTChild(currentAST, returnAST); 1621 break; 1622 } 1623 case LITERAL_void: 1624 case LITERAL_boolean: 1625 case LITERAL_byte: 1626 case LITERAL_char: 1627 case LITERAL_short: 1628 case LITERAL_int: 1629 case LITERAL_float: 1630 case LITERAL_long: 1631 case LITERAL_double: 1632 { 1633 builtInType(); 1634 astFactory.addASTChild(currentAST, returnAST); 1635 break; 1636 } 1637 default: 1638 { 1639 throw new NoViableAltException(LT(1), getFilename()); 1640 } 1641 } 1642 } 1643 typeArgumentBoundsArrayDeclarator(); 1644 astFactory.addASTChild(currentAST, returnAST); 1645 typeArgumentBounds_AST = (AST)currentAST.root; 1646 returnAST = typeArgumentBounds_AST; 1647 } 1648 1649 protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException { 1650 1651 returnAST = null; 1652 ASTPair currentAST = new ASTPair(); 1653 AST typeArgumentsOrParametersEnd_AST = null; 1654 Token g = null; 1655 AST g_AST = null; 1656 Token sr = null; 1657 AST sr_AST = null; 1658 Token bsr = null; 1659 AST bsr_AST = null; 1660 1661 switch ( LA(1)) { 1662 case GT: 1663 { 1664 g = LT(1); 1665 g_AST = astFactory.create(g); 1666 match(GT); 1667 if ( inputState.guessing==0 ) { 1668 consumeCurrentGtSequence((DetailAstImpl)g_AST); 1669 } 1670 break; 1671 } 1672 case SR: 1673 { 1674 sr = LT(1); 1675 sr_AST = astFactory.create(sr); 1676 match(SR); 1677 if ( inputState.guessing==0 ) { 1678 consumeCurrentGtSequence((DetailAstImpl)sr_AST); 1679 } 1680 break; 1681 } 1682 case BSR: 1683 { 1684 bsr = LT(1); 1685 bsr_AST = astFactory.create(bsr); 1686 match(BSR); 1687 if ( inputState.guessing==0 ) { 1688 consumeCurrentGtSequence((DetailAstImpl)bsr_AST); 1689 } 1690 break; 1691 } 1692 default: 1693 { 1694 throw new NoViableAltException(LT(1), getFilename()); 1695 } 1696 } 1697 returnAST = typeArgumentsOrParametersEnd_AST; 1698 } 1699 1700 public final void typeArgumentBoundsArrayDeclarator() throws RecognitionException, TokenStreamException { 1701 1702 returnAST = null; 1703 ASTPair currentAST = new ASTPair(); 1704 AST typeArgumentBoundsArrayDeclarator_AST = null; 1705 1706 { 1707 _loop49: 1708 do { 1709 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 1710 brackets(); 1711 astFactory.addASTChild(currentAST, returnAST); 1712 } 1713 else { 1714 break _loop49; 1715 } 1716 1717 } while (true); 1718 } 1719 typeArgumentBoundsArrayDeclarator_AST = (AST)currentAST.root; 1720 returnAST = typeArgumentBoundsArrayDeclarator_AST; 1721 } 1722 1723 public final void typeSpecBracketsAndAnnotationsNonGreedy() throws RecognitionException, TokenStreamException { 1724 1725 returnAST = null; 1726 ASTPair currentAST = new ASTPair(); 1727 AST typeSpecBracketsAndAnnotationsNonGreedy_AST = null; 1728 1729 { 1730 _loop54: 1731 do { 1732 if ((LA(1)==LBRACK||LA(1)==AT) && (_tokenSet_9.member(LA(2)))) { 1733 { 1734 if (((LA(1)==LBRACK||LA(1)==AT) && (_tokenSet_9.member(LA(2))))&&(LA(1) == AT)) { 1735 annotations(); 1736 astFactory.addASTChild(currentAST, returnAST); 1737 } 1738 else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 1739 } 1740 else { 1741 throw new NoViableAltException(LT(1), getFilename()); 1742 } 1743 1744 } 1745 brackets(); 1746 astFactory.addASTChild(currentAST, returnAST); 1747 } 1748 else { 1749 break _loop54; 1750 } 1751 1752 } while (true); 1753 } 1754 typeSpecBracketsAndAnnotationsNonGreedy_AST = (AST)currentAST.root; 1755 returnAST = typeSpecBracketsAndAnnotationsNonGreedy_AST; 1756 } 1757 1758 public final void type() throws RecognitionException, TokenStreamException { 1759 1760 returnAST = null; 1761 ASTPair currentAST = new ASTPair(); 1762 AST type_AST = null; 1763 1764 { 1765 if (((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2))))&&(LA(1) == AT)) { 1766 annotations(); 1767 astFactory.addASTChild(currentAST, returnAST); 1768 } 1769 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) { 1770 } 1771 else { 1772 throw new NoViableAltException(LT(1), getFilename()); 1773 } 1774 1775 } 1776 { 1777 switch ( LA(1)) { 1778 case IDENT: 1779 case AT: 1780 case LITERAL_record: 1781 case LITERAL_yield: 1782 case LITERAL_sealed: 1783 case LITERAL_permits: 1784 case LITERAL_non: 1785 { 1786 classOrInterfaceType(false); 1787 astFactory.addASTChild(currentAST, returnAST); 1788 break; 1789 } 1790 case LITERAL_void: 1791 case LITERAL_boolean: 1792 case LITERAL_byte: 1793 case LITERAL_char: 1794 case LITERAL_short: 1795 case LITERAL_int: 1796 case LITERAL_float: 1797 case LITERAL_long: 1798 case LITERAL_double: 1799 { 1800 builtInType(); 1801 astFactory.addASTChild(currentAST, returnAST); 1802 break; 1803 } 1804 default: 1805 { 1806 throw new NoViableAltException(LT(1), getFilename()); 1807 } 1808 } 1809 } 1810 type_AST = (AST)currentAST.root; 1811 returnAST = type_AST; 1812 } 1813 1814/** A declaration is the creation of a reference or primitive-type variable 1815 * Create a separate Type/Var tree for each var in the var list. 1816 @throws RecognitionException if recognition problem occurs. 1817 @throws TokenStreamException if problem occurs while generating a stream of tokens. 1818 */ 1819 public final void declaration() throws RecognitionException, TokenStreamException { 1820 1821 returnAST = null; 1822 ASTPair currentAST = new ASTPair(); 1823 AST declaration_AST = null; 1824 AST m_AST = null; 1825 AST t_AST = null; 1826 AST v_AST = null; 1827 1828 modifiers(); 1829 m_AST = (AST)returnAST; 1830 typeSpec(false); 1831 t_AST = (AST)returnAST; 1832 variableDefinitions(m_AST,t_AST); 1833 v_AST = (AST)returnAST; 1834 if ( inputState.guessing==0 ) { 1835 declaration_AST = (AST)currentAST.root; 1836 declaration_AST = v_AST; 1837 currentAST.root = declaration_AST; 1838 currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ? 1839 declaration_AST.getFirstChild() : declaration_AST; 1840 currentAST.advanceChildToEnd(); 1841 } 1842 returnAST = declaration_AST; 1843 } 1844 1845 public final void variableDefinitions( 1846 AST mods, AST t 1847 ) throws RecognitionException, TokenStreamException { 1848 1849 returnAST = null; 1850 ASTPair currentAST = new ASTPair(); 1851 AST variableDefinitions_AST = null; 1852 1853 variableDeclarator((AST) getASTFactory().dupTree(mods), 1854 //dupList as this also copies siblings (like TYPE_ARGUMENTS) 1855 (AST) getASTFactory().dupList(t)); 1856 astFactory.addASTChild(currentAST, returnAST); 1857 { 1858 _loop200: 1859 do { 1860 if ((LA(1)==COMMA)) { 1861 AST tmp23_AST = null; 1862 tmp23_AST = astFactory.create(LT(1)); 1863 astFactory.addASTChild(currentAST, tmp23_AST); 1864 match(COMMA); 1865 variableDeclarator((AST) getASTFactory().dupTree(mods), 1866 //dupList as this also copies siblings (like TYPE_ARGUMENTS) 1867 (AST) getASTFactory().dupList(t)); 1868 astFactory.addASTChild(currentAST, returnAST); 1869 } 1870 else { 1871 break _loop200; 1872 } 1873 1874 } while (true); 1875 } 1876 variableDefinitions_AST = (AST)currentAST.root; 1877 returnAST = variableDefinitions_AST; 1878 } 1879 1880 public final void modifier() throws RecognitionException, TokenStreamException { 1881 1882 returnAST = null; 1883 ASTPair currentAST = new ASTPair(); 1884 AST modifier_AST = null; 1885 1886 switch ( LA(1)) { 1887 case LITERAL_private: 1888 { 1889 AST tmp24_AST = null; 1890 tmp24_AST = astFactory.create(LT(1)); 1891 astFactory.addASTChild(currentAST, tmp24_AST); 1892 match(LITERAL_private); 1893 modifier_AST = (AST)currentAST.root; 1894 break; 1895 } 1896 case LITERAL_public: 1897 { 1898 AST tmp25_AST = null; 1899 tmp25_AST = astFactory.create(LT(1)); 1900 astFactory.addASTChild(currentAST, tmp25_AST); 1901 match(LITERAL_public); 1902 modifier_AST = (AST)currentAST.root; 1903 break; 1904 } 1905 case LITERAL_protected: 1906 { 1907 AST tmp26_AST = null; 1908 tmp26_AST = astFactory.create(LT(1)); 1909 astFactory.addASTChild(currentAST, tmp26_AST); 1910 match(LITERAL_protected); 1911 modifier_AST = (AST)currentAST.root; 1912 break; 1913 } 1914 case LITERAL_static: 1915 { 1916 AST tmp27_AST = null; 1917 tmp27_AST = astFactory.create(LT(1)); 1918 astFactory.addASTChild(currentAST, tmp27_AST); 1919 match(LITERAL_static); 1920 modifier_AST = (AST)currentAST.root; 1921 break; 1922 } 1923 case LITERAL_transient: 1924 { 1925 AST tmp28_AST = null; 1926 tmp28_AST = astFactory.create(LT(1)); 1927 astFactory.addASTChild(currentAST, tmp28_AST); 1928 match(LITERAL_transient); 1929 modifier_AST = (AST)currentAST.root; 1930 break; 1931 } 1932 case FINAL: 1933 { 1934 AST tmp29_AST = null; 1935 tmp29_AST = astFactory.create(LT(1)); 1936 astFactory.addASTChild(currentAST, tmp29_AST); 1937 match(FINAL); 1938 modifier_AST = (AST)currentAST.root; 1939 break; 1940 } 1941 case ABSTRACT: 1942 { 1943 AST tmp30_AST = null; 1944 tmp30_AST = astFactory.create(LT(1)); 1945 astFactory.addASTChild(currentAST, tmp30_AST); 1946 match(ABSTRACT); 1947 modifier_AST = (AST)currentAST.root; 1948 break; 1949 } 1950 case LITERAL_native: 1951 { 1952 AST tmp31_AST = null; 1953 tmp31_AST = astFactory.create(LT(1)); 1954 astFactory.addASTChild(currentAST, tmp31_AST); 1955 match(LITERAL_native); 1956 modifier_AST = (AST)currentAST.root; 1957 break; 1958 } 1959 case LITERAL_synchronized: 1960 { 1961 AST tmp32_AST = null; 1962 tmp32_AST = astFactory.create(LT(1)); 1963 astFactory.addASTChild(currentAST, tmp32_AST); 1964 match(LITERAL_synchronized); 1965 modifier_AST = (AST)currentAST.root; 1966 break; 1967 } 1968 case LITERAL_volatile: 1969 { 1970 AST tmp33_AST = null; 1971 tmp33_AST = astFactory.create(LT(1)); 1972 astFactory.addASTChild(currentAST, tmp33_AST); 1973 match(LITERAL_volatile); 1974 modifier_AST = (AST)currentAST.root; 1975 break; 1976 } 1977 case STRICTFP: 1978 { 1979 AST tmp34_AST = null; 1980 tmp34_AST = astFactory.create(LT(1)); 1981 astFactory.addASTChild(currentAST, tmp34_AST); 1982 match(STRICTFP); 1983 modifier_AST = (AST)currentAST.root; 1984 break; 1985 } 1986 case LITERAL_default: 1987 { 1988 AST tmp35_AST = null; 1989 tmp35_AST = astFactory.create(LT(1)); 1990 astFactory.addASTChild(currentAST, tmp35_AST); 1991 match(LITERAL_default); 1992 modifier_AST = (AST)currentAST.root; 1993 break; 1994 } 1995 case LITERAL_non: 1996 { 1997 nonSealed(); 1998 astFactory.addASTChild(currentAST, returnAST); 1999 modifier_AST = (AST)currentAST.root; 2000 break; 2001 } 2002 case LITERAL_sealed: 2003 { 2004 AST tmp36_AST = null; 2005 tmp36_AST = astFactory.create(LT(1)); 2006 astFactory.addASTChild(currentAST, tmp36_AST); 2007 match(LITERAL_sealed); 2008 modifier_AST = (AST)currentAST.root; 2009 break; 2010 } 2011 default: 2012 { 2013 throw new NoViableAltException(LT(1), getFilename()); 2014 } 2015 } 2016 returnAST = modifier_AST; 2017 } 2018 2019 public final void annotation() throws RecognitionException, TokenStreamException { 2020 2021 returnAST = null; 2022 ASTPair currentAST = new ASTPair(); 2023 AST annotation_AST = null; 2024 AST i_AST = null; 2025 Token l = null; 2026 AST l_AST = null; 2027 AST args_AST = null; 2028 Token r = null; 2029 AST r_AST = null; 2030 2031 AST tmp37_AST = null; 2032 tmp37_AST = astFactory.create(LT(1)); 2033 match(AT); 2034 identifier(); 2035 i_AST = (AST)returnAST; 2036 { 2037 switch ( LA(1)) { 2038 case LPAREN: 2039 { 2040 l = LT(1); 2041 l_AST = astFactory.create(l); 2042 match(LPAREN); 2043 { 2044 switch ( LA(1)) { 2045 case LITERAL_void: 2046 case LITERAL_boolean: 2047 case LITERAL_byte: 2048 case LITERAL_char: 2049 case LITERAL_short: 2050 case LITERAL_int: 2051 case LITERAL_float: 2052 case LITERAL_long: 2053 case LITERAL_double: 2054 case IDENT: 2055 case LCURLY: 2056 case LPAREN: 2057 case LITERAL_this: 2058 case LITERAL_super: 2059 case LITERAL_switch: 2060 case PLUS: 2061 case MINUS: 2062 case INC: 2063 case DEC: 2064 case BNOT: 2065 case LNOT: 2066 case LITERAL_true: 2067 case LITERAL_false: 2068 case LITERAL_null: 2069 case LITERAL_new: 2070 case NUM_INT: 2071 case CHAR_LITERAL: 2072 case STRING_LITERAL: 2073 case NUM_FLOAT: 2074 case NUM_LONG: 2075 case NUM_DOUBLE: 2076 case AT: 2077 case LITERAL_record: 2078 case TEXT_BLOCK_CONTENT: 2079 case LITERAL_yield: 2080 case LITERAL_sealed: 2081 case LITERAL_permits: 2082 case LITERAL_non: 2083 { 2084 annotationArguments(); 2085 args_AST = (AST)returnAST; 2086 break; 2087 } 2088 case RPAREN: 2089 { 2090 break; 2091 } 2092 default: 2093 { 2094 throw new NoViableAltException(LT(1), getFilename()); 2095 } 2096 } 2097 } 2098 r = LT(1); 2099 r_AST = astFactory.create(r); 2100 match(RPAREN); 2101 break; 2102 } 2103 case FINAL: 2104 case ABSTRACT: 2105 case STRICTFP: 2106 case LITERAL_package: 2107 case SEMI: 2108 case LBRACK: 2109 case LITERAL_void: 2110 case LITERAL_boolean: 2111 case LITERAL_byte: 2112 case LITERAL_char: 2113 case LITERAL_short: 2114 case LITERAL_int: 2115 case LITERAL_float: 2116 case LITERAL_long: 2117 case LITERAL_double: 2118 case IDENT: 2119 case LITERAL_private: 2120 case LITERAL_public: 2121 case LITERAL_protected: 2122 case LITERAL_static: 2123 case LITERAL_transient: 2124 case LITERAL_native: 2125 case LITERAL_synchronized: 2126 case LITERAL_volatile: 2127 case LITERAL_class: 2128 case LITERAL_interface: 2129 case RCURLY: 2130 case COMMA: 2131 case RPAREN: 2132 case LITERAL_this: 2133 case LITERAL_default: 2134 case QUESTION: 2135 case LT: 2136 case ENUM: 2137 case AT: 2138 case ELLIPSIS: 2139 case LITERAL_record: 2140 case LITERAL_yield: 2141 case LITERAL_sealed: 2142 case LITERAL_permits: 2143 case LITERAL_non: 2144 { 2145 break; 2146 } 2147 default: 2148 { 2149 throw new NoViableAltException(LT(1), getFilename()); 2150 } 2151 } 2152 } 2153 if ( inputState.guessing==0 ) { 2154 annotation_AST = (AST)currentAST.root; 2155 annotation_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(tmp37_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST)); 2156 currentAST.root = annotation_AST; 2157 currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ? 2158 annotation_AST.getFirstChild() : annotation_AST; 2159 currentAST.advanceChildToEnd(); 2160 } 2161 returnAST = annotation_AST; 2162 } 2163 2164 public final void nonSealed() throws RecognitionException, TokenStreamException { 2165 2166 returnAST = null; 2167 ASTPair currentAST = new ASTPair(); 2168 AST nonSealed_AST = null; 2169 Token ns = null; 2170 AST ns_AST = null; 2171 2172 ns = LT(1); 2173 ns_AST = astFactory.create(ns); 2174 match(LITERAL_non); 2175 AST tmp38_AST = null; 2176 tmp38_AST = astFactory.create(LT(1)); 2177 match(MINUS); 2178 match(LITERAL_sealed); 2179 if ( inputState.guessing==0 ) { 2180 ns_AST.setType(LITERAL_non_sealed);ns_AST.setText("non-sealed"); 2181 } 2182 if ( inputState.guessing==0 ) { 2183 nonSealed_AST = (AST)currentAST.root; 2184 nonSealed_AST=(AST)astFactory.make( (new ASTArray(1)).add(ns_AST)); 2185 currentAST.root = nonSealed_AST; 2186 currentAST.child = nonSealed_AST!=null &&nonSealed_AST.getFirstChild()!=null ? 2187 nonSealed_AST.getFirstChild() : nonSealed_AST; 2188 currentAST.advanceChildToEnd(); 2189 } 2190 returnAST = nonSealed_AST; 2191 } 2192 2193 public final void annotationArguments() throws RecognitionException, TokenStreamException { 2194 2195 returnAST = null; 2196 ASTPair currentAST = new ASTPair(); 2197 AST annotationArguments_AST = null; 2198 2199 if ((_tokenSet_17.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { 2200 annotationMemberValueInitializer(); 2201 astFactory.addASTChild(currentAST, returnAST); 2202 annotationArguments_AST = (AST)currentAST.root; 2203 } 2204 else if ((_tokenSet_0.member(LA(1))) && (LA(2)==ASSIGN)) { 2205 annotationMemberValuePairs(); 2206 astFactory.addASTChild(currentAST, returnAST); 2207 annotationArguments_AST = (AST)currentAST.root; 2208 } 2209 else { 2210 throw new NoViableAltException(LT(1), getFilename()); 2211 } 2212 2213 returnAST = annotationArguments_AST; 2214 } 2215 2216 public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException { 2217 2218 returnAST = null; 2219 ASTPair currentAST = new ASTPair(); 2220 AST annotationMemberValueInitializer_AST = null; 2221 2222 boolean synPredMatched91 = false; 2223 if (((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2))))) { 2224 int _m91 = mark(); 2225 synPredMatched91 = true; 2226 inputState.guessing++; 2227 try { 2228 { 2229 annotationExpression(); 2230 } 2231 } 2232 catch (RecognitionException pe) { 2233 synPredMatched91 = false; 2234 } 2235 rewind(_m91); 2236inputState.guessing--; 2237 } 2238 if ( synPredMatched91 ) { 2239 annotationExpression(); 2240 astFactory.addASTChild(currentAST, returnAST); 2241 annotationMemberValueInitializer_AST = (AST)currentAST.root; 2242 } 2243 else if ((LA(1)==AT) && (_tokenSet_0.member(LA(2)))) { 2244 annotation(); 2245 astFactory.addASTChild(currentAST, returnAST); 2246 annotationMemberValueInitializer_AST = (AST)currentAST.root; 2247 } 2248 else if ((LA(1)==LCURLY)) { 2249 annotationMemberArrayInitializer(); 2250 astFactory.addASTChild(currentAST, returnAST); 2251 annotationMemberValueInitializer_AST = (AST)currentAST.root; 2252 } 2253 else { 2254 throw new NoViableAltException(LT(1), getFilename()); 2255 } 2256 2257 returnAST = annotationMemberValueInitializer_AST; 2258 } 2259 2260 public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException { 2261 2262 returnAST = null; 2263 ASTPair currentAST = new ASTPair(); 2264 AST annotationMemberValuePairs_AST = null; 2265 2266 annotationMemberValuePair(); 2267 astFactory.addASTChild(currentAST, returnAST); 2268 { 2269 _loop87: 2270 do { 2271 if ((LA(1)==COMMA)) { 2272 AST tmp40_AST = null; 2273 tmp40_AST = astFactory.create(LT(1)); 2274 astFactory.addASTChild(currentAST, tmp40_AST); 2275 match(COMMA); 2276 annotationMemberValuePair(); 2277 astFactory.addASTChild(currentAST, returnAST); 2278 } 2279 else { 2280 break _loop87; 2281 } 2282 2283 } while (true); 2284 } 2285 annotationMemberValuePairs_AST = (AST)currentAST.root; 2286 returnAST = annotationMemberValuePairs_AST; 2287 } 2288 2289 public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException { 2290 2291 returnAST = null; 2292 ASTPair currentAST = new ASTPair(); 2293 AST annotationMemberValuePair_AST = null; 2294 AST i_AST = null; 2295 Token a = null; 2296 AST a_AST = null; 2297 AST v_AST = null; 2298 2299 id(); 2300 i_AST = (AST)returnAST; 2301 a = LT(1); 2302 a_AST = astFactory.create(a); 2303 match(ASSIGN); 2304 annotationMemberValueInitializer(); 2305 v_AST = (AST)returnAST; 2306 if ( inputState.guessing==0 ) { 2307 annotationMemberValuePair_AST = (AST)currentAST.root; 2308 annotationMemberValuePair_AST = 2309 (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(ANNOTATION_MEMBER_VALUE_PAIR,"ANNOTATION_MEMBER_VALUE_PAIR")).add(i_AST).add(a_AST).add(v_AST)); 2310 currentAST.root = annotationMemberValuePair_AST; 2311 currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ? 2312 annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST; 2313 currentAST.advanceChildToEnd(); 2314 } 2315 returnAST = annotationMemberValuePair_AST; 2316 } 2317 2318 public final void annotationExpression() throws RecognitionException, TokenStreamException { 2319 2320 returnAST = null; 2321 ASTPair currentAST = new ASTPair(); 2322 AST annotationExpression_AST = null; 2323 2324 conditionalExpression(); 2325 astFactory.addASTChild(currentAST, returnAST); 2326 if ( inputState.guessing==0 ) { 2327 annotationExpression_AST = (AST)currentAST.root; 2328 annotationExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(annotationExpression_AST)); 2329 currentAST.root = annotationExpression_AST; 2330 currentAST.child = annotationExpression_AST!=null &&annotationExpression_AST.getFirstChild()!=null ? 2331 annotationExpression_AST.getFirstChild() : annotationExpression_AST; 2332 currentAST.advanceChildToEnd(); 2333 } 2334 annotationExpression_AST = (AST)currentAST.root; 2335 returnAST = annotationExpression_AST; 2336 } 2337 2338 public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException { 2339 2340 returnAST = null; 2341 ASTPair currentAST = new ASTPair(); 2342 AST annotationMemberArrayInitializer_AST = null; 2343 Token lc = null; 2344 AST lc_AST = null; 2345 2346 lc = LT(1); 2347 lc_AST = astFactory.create(lc); 2348 astFactory.makeASTRoot(currentAST, lc_AST); 2349 match(LCURLY); 2350 if ( inputState.guessing==0 ) { 2351 lc_AST.setType(ANNOTATION_ARRAY_INIT); 2352 } 2353 { 2354 switch ( LA(1)) { 2355 case LITERAL_void: 2356 case LITERAL_boolean: 2357 case LITERAL_byte: 2358 case LITERAL_char: 2359 case LITERAL_short: 2360 case LITERAL_int: 2361 case LITERAL_float: 2362 case LITERAL_long: 2363 case LITERAL_double: 2364 case IDENT: 2365 case LPAREN: 2366 case LITERAL_this: 2367 case LITERAL_super: 2368 case LITERAL_switch: 2369 case PLUS: 2370 case MINUS: 2371 case INC: 2372 case DEC: 2373 case BNOT: 2374 case LNOT: 2375 case LITERAL_true: 2376 case LITERAL_false: 2377 case LITERAL_null: 2378 case LITERAL_new: 2379 case NUM_INT: 2380 case CHAR_LITERAL: 2381 case STRING_LITERAL: 2382 case NUM_FLOAT: 2383 case NUM_LONG: 2384 case NUM_DOUBLE: 2385 case AT: 2386 case LITERAL_record: 2387 case TEXT_BLOCK_CONTENT: 2388 case LITERAL_yield: 2389 case LITERAL_sealed: 2390 case LITERAL_permits: 2391 case LITERAL_non: 2392 { 2393 annotationMemberArrayValueInitializer(); 2394 astFactory.addASTChild(currentAST, returnAST); 2395 { 2396 _loop95: 2397 do { 2398 if ((LA(1)==COMMA) && (_tokenSet_19.member(LA(2)))) { 2399 AST tmp41_AST = null; 2400 tmp41_AST = astFactory.create(LT(1)); 2401 astFactory.addASTChild(currentAST, tmp41_AST); 2402 match(COMMA); 2403 annotationMemberArrayValueInitializer(); 2404 astFactory.addASTChild(currentAST, returnAST); 2405 } 2406 else { 2407 break _loop95; 2408 } 2409 2410 } while (true); 2411 } 2412 { 2413 switch ( LA(1)) { 2414 case COMMA: 2415 { 2416 AST tmp42_AST = null; 2417 tmp42_AST = astFactory.create(LT(1)); 2418 astFactory.addASTChild(currentAST, tmp42_AST); 2419 match(COMMA); 2420 break; 2421 } 2422 case RCURLY: 2423 { 2424 break; 2425 } 2426 default: 2427 { 2428 throw new NoViableAltException(LT(1), getFilename()); 2429 } 2430 } 2431 } 2432 break; 2433 } 2434 case RCURLY: 2435 { 2436 break; 2437 } 2438 default: 2439 { 2440 throw new NoViableAltException(LT(1), getFilename()); 2441 } 2442 } 2443 } 2444 AST tmp43_AST = null; 2445 tmp43_AST = astFactory.create(LT(1)); 2446 astFactory.addASTChild(currentAST, tmp43_AST); 2447 match(RCURLY); 2448 annotationMemberArrayInitializer_AST = (AST)currentAST.root; 2449 returnAST = annotationMemberArrayInitializer_AST; 2450 } 2451 2452 public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException { 2453 2454 returnAST = null; 2455 ASTPair currentAST = new ASTPair(); 2456 AST annotationMemberArrayValueInitializer_AST = null; 2457 2458 boolean synPredMatched99 = false; 2459 if (((_tokenSet_19.member(LA(1))) && (_tokenSet_21.member(LA(2))))) { 2460 int _m99 = mark(); 2461 synPredMatched99 = true; 2462 inputState.guessing++; 2463 try { 2464 { 2465 annotationExpression(); 2466 } 2467 } 2468 catch (RecognitionException pe) { 2469 synPredMatched99 = false; 2470 } 2471 rewind(_m99); 2472inputState.guessing--; 2473 } 2474 if ( synPredMatched99 ) { 2475 annotationExpression(); 2476 astFactory.addASTChild(currentAST, returnAST); 2477 annotationMemberArrayValueInitializer_AST = (AST)currentAST.root; 2478 } 2479 else if ((LA(1)==AT) && (_tokenSet_0.member(LA(2)))) { 2480 annotation(); 2481 astFactory.addASTChild(currentAST, returnAST); 2482 annotationMemberArrayValueInitializer_AST = (AST)currentAST.root; 2483 } 2484 else { 2485 throw new NoViableAltException(LT(1), getFilename()); 2486 } 2487 2488 returnAST = annotationMemberArrayValueInitializer_AST; 2489 } 2490 2491 public final void conditionalExpression() throws RecognitionException, TokenStreamException { 2492 2493 returnAST = null; 2494 ASTPair currentAST = new ASTPair(); 2495 AST conditionalExpression_AST = null; 2496 2497 logicalOrExpression(); 2498 astFactory.addASTChild(currentAST, returnAST); 2499 { 2500 switch ( LA(1)) { 2501 case QUESTION: 2502 { 2503 AST tmp44_AST = null; 2504 tmp44_AST = astFactory.create(LT(1)); 2505 astFactory.makeASTRoot(currentAST, tmp44_AST); 2506 match(QUESTION); 2507 { 2508 boolean synPredMatched357 = false; 2509 if (((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2))))) { 2510 int _m357 = mark(); 2511 synPredMatched357 = true; 2512 inputState.guessing++; 2513 try { 2514 { 2515 lambdaExpression(); 2516 } 2517 } 2518 catch (RecognitionException pe) { 2519 synPredMatched357 = false; 2520 } 2521 rewind(_m357); 2522inputState.guessing--; 2523 } 2524 if ( synPredMatched357 ) { 2525 lambdaExpression(); 2526 astFactory.addASTChild(currentAST, returnAST); 2527 } 2528 else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_24.member(LA(2)))) { 2529 assignmentExpression(); 2530 astFactory.addASTChild(currentAST, returnAST); 2531 } 2532 else { 2533 throw new NoViableAltException(LT(1), getFilename()); 2534 } 2535 2536 } 2537 AST tmp45_AST = null; 2538 tmp45_AST = astFactory.create(LT(1)); 2539 astFactory.addASTChild(currentAST, tmp45_AST); 2540 match(COLON); 2541 { 2542 boolean synPredMatched360 = false; 2543 if (((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2))))) { 2544 int _m360 = mark(); 2545 synPredMatched360 = true; 2546 inputState.guessing++; 2547 try { 2548 { 2549 lambdaExpression(); 2550 } 2551 } 2552 catch (RecognitionException pe) { 2553 synPredMatched360 = false; 2554 } 2555 rewind(_m360); 2556inputState.guessing--; 2557 } 2558 if ( synPredMatched360 ) { 2559 lambdaExpression(); 2560 astFactory.addASTChild(currentAST, returnAST); 2561 } 2562 else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { 2563 conditionalExpression(); 2564 astFactory.addASTChild(currentAST, returnAST); 2565 } 2566 else { 2567 throw new NoViableAltException(LT(1), getFilename()); 2568 } 2569 2570 } 2571 break; 2572 } 2573 case FINAL: 2574 case ABSTRACT: 2575 case STRICTFP: 2576 case SEMI: 2577 case RBRACK: 2578 case LITERAL_void: 2579 case LITERAL_boolean: 2580 case LITERAL_byte: 2581 case LITERAL_char: 2582 case LITERAL_short: 2583 case LITERAL_int: 2584 case LITERAL_float: 2585 case LITERAL_long: 2586 case LITERAL_double: 2587 case IDENT: 2588 case STAR: 2589 case LITERAL_private: 2590 case LITERAL_public: 2591 case LITERAL_protected: 2592 case LITERAL_static: 2593 case LITERAL_transient: 2594 case LITERAL_native: 2595 case LITERAL_synchronized: 2596 case LITERAL_volatile: 2597 case LITERAL_class: 2598 case LITERAL_interface: 2599 case LCURLY: 2600 case RCURLY: 2601 case COMMA: 2602 case LPAREN: 2603 case RPAREN: 2604 case LITERAL_this: 2605 case LITERAL_super: 2606 case ASSIGN: 2607 case COLON: 2608 case LITERAL_if: 2609 case LITERAL_while: 2610 case LITERAL_do: 2611 case LITERAL_break: 2612 case LITERAL_continue: 2613 case LITERAL_return: 2614 case LITERAL_switch: 2615 case LITERAL_throw: 2616 case LITERAL_for: 2617 case LITERAL_else: 2618 case LITERAL_case: 2619 case LITERAL_default: 2620 case LITERAL_try: 2621 case PLUS_ASSIGN: 2622 case MINUS_ASSIGN: 2623 case STAR_ASSIGN: 2624 case DIV_ASSIGN: 2625 case MOD_ASSIGN: 2626 case SR_ASSIGN: 2627 case BSR_ASSIGN: 2628 case SL_ASSIGN: 2629 case BAND_ASSIGN: 2630 case BXOR_ASSIGN: 2631 case BOR_ASSIGN: 2632 case LT: 2633 case GT: 2634 case LE: 2635 case GE: 2636 case LITERAL_instanceof: 2637 case SL: 2638 case SR: 2639 case BSR: 2640 case PLUS: 2641 case MINUS: 2642 case DIV: 2643 case MOD: 2644 case INC: 2645 case DEC: 2646 case BNOT: 2647 case LNOT: 2648 case LITERAL_true: 2649 case LITERAL_false: 2650 case LITERAL_null: 2651 case LITERAL_new: 2652 case NUM_INT: 2653 case CHAR_LITERAL: 2654 case STRING_LITERAL: 2655 case NUM_FLOAT: 2656 case NUM_LONG: 2657 case NUM_DOUBLE: 2658 case ASSERT: 2659 case ENUM: 2660 case AT: 2661 case LAMBDA: 2662 case LITERAL_record: 2663 case TEXT_BLOCK_CONTENT: 2664 case LITERAL_yield: 2665 case LITERAL_sealed: 2666 case LITERAL_permits: 2667 case LITERAL_non: 2668 { 2669 break; 2670 } 2671 default: 2672 { 2673 throw new NoViableAltException(LT(1), getFilename()); 2674 } 2675 } 2676 } 2677 conditionalExpression_AST = (AST)currentAST.root; 2678 returnAST = conditionalExpression_AST; 2679 } 2680 2681 public final void typeParameters() throws RecognitionException, TokenStreamException { 2682 2683 returnAST = null; 2684 ASTPair currentAST = new ASTPair(); 2685 AST typeParameters_AST = null; 2686 Token lt = null; 2687 AST lt_AST = null; 2688 int currentLtLevel = 0; 2689 2690 if ( inputState.guessing==0 ) { 2691 currentLtLevel = ltCounter; 2692 } 2693 lt = LT(1); 2694 lt_AST = astFactory.create(lt); 2695 astFactory.addASTChild(currentAST, lt_AST); 2696 match(LT); 2697 if ( inputState.guessing==0 ) { 2698 lt_AST.setType(GENERIC_START); ltCounter++; 2699 } 2700 typeParameter(); 2701 astFactory.addASTChild(currentAST, returnAST); 2702 { 2703 _loop131: 2704 do { 2705 if ((LA(1)==COMMA)) { 2706 AST tmp46_AST = null; 2707 tmp46_AST = astFactory.create(LT(1)); 2708 astFactory.addASTChild(currentAST, tmp46_AST); 2709 match(COMMA); 2710 typeParameter(); 2711 astFactory.addASTChild(currentAST, returnAST); 2712 } 2713 else { 2714 break _loop131; 2715 } 2716 2717 } while (true); 2718 } 2719 { 2720 switch ( LA(1)) { 2721 case GT: 2722 case SR: 2723 case BSR: 2724 { 2725 typeArgumentsOrParametersEnd(); 2726 astFactory.addASTChild(currentAST, returnAST); 2727 break; 2728 } 2729 case LITERAL_void: 2730 case LITERAL_boolean: 2731 case LITERAL_byte: 2732 case LITERAL_char: 2733 case LITERAL_short: 2734 case LITERAL_int: 2735 case LITERAL_float: 2736 case LITERAL_long: 2737 case LITERAL_double: 2738 case IDENT: 2739 case LITERAL_extends: 2740 case LCURLY: 2741 case LITERAL_implements: 2742 case LPAREN: 2743 case AT: 2744 case LITERAL_record: 2745 case LITERAL_yield: 2746 case LITERAL_sealed: 2747 case LITERAL_permits: 2748 case LITERAL_non: 2749 { 2750 break; 2751 } 2752 default: 2753 { 2754 throw new NoViableAltException(LT(1), getFilename()); 2755 } 2756 } 2757 } 2758 if ( inputState.guessing==0 ) { 2759 2760 if (isThereASingleGtToEmit()) { 2761 astFactory.addASTChild(currentAST, emitSingleGt()); 2762 } 2763 2764 } 2765 if (!(areLtsAndGtsBalanced(currentLtLevel))) 2766 throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)"); 2767 if ( inputState.guessing==0 ) { 2768 typeParameters_AST = (AST)currentAST.root; 2769 typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).add(typeParameters_AST)); 2770 currentAST.root = typeParameters_AST; 2771 currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ? 2772 typeParameters_AST.getFirstChild() : typeParameters_AST; 2773 currentAST.advanceChildToEnd(); 2774 } 2775 typeParameters_AST = (AST)currentAST.root; 2776 returnAST = typeParameters_AST; 2777 } 2778 2779 public final void recordComponentsList() throws RecognitionException, TokenStreamException { 2780 2781 returnAST = null; 2782 ASTPair currentAST = new ASTPair(); 2783 AST recordComponentsList_AST = null; 2784 2785 AST tmp47_AST = null; 2786 tmp47_AST = astFactory.create(LT(1)); 2787 astFactory.addASTChild(currentAST, tmp47_AST); 2788 match(LPAREN); 2789 recordComponents(); 2790 astFactory.addASTChild(currentAST, returnAST); 2791 AST tmp48_AST = null; 2792 tmp48_AST = astFactory.create(LT(1)); 2793 astFactory.addASTChild(currentAST, tmp48_AST); 2794 match(RPAREN); 2795 recordComponentsList_AST = (AST)currentAST.root; 2796 returnAST = recordComponentsList_AST; 2797 } 2798 2799 public final void implementsClause() throws RecognitionException, TokenStreamException { 2800 2801 returnAST = null; 2802 ASTPair currentAST = new ASTPair(); 2803 AST implementsClause_AST = null; 2804 Token i = null; 2805 AST i_AST = null; 2806 2807 { 2808 switch ( LA(1)) { 2809 case LITERAL_implements: 2810 { 2811 i = LT(1); 2812 i_AST = astFactory.create(i); 2813 astFactory.makeASTRoot(currentAST, i_AST); 2814 match(LITERAL_implements); 2815 if ( inputState.guessing==0 ) { 2816 i_AST.setType(IMPLEMENTS_CLAUSE); 2817 } 2818 classOrInterfaceType(false); 2819 astFactory.addASTChild(currentAST, returnAST); 2820 { 2821 _loop178: 2822 do { 2823 if ((LA(1)==COMMA)) { 2824 AST tmp49_AST = null; 2825 tmp49_AST = astFactory.create(LT(1)); 2826 astFactory.addASTChild(currentAST, tmp49_AST); 2827 match(COMMA); 2828 classOrInterfaceType(false); 2829 astFactory.addASTChild(currentAST, returnAST); 2830 } 2831 else { 2832 break _loop178; 2833 } 2834 2835 } while (true); 2836 } 2837 break; 2838 } 2839 case LCURLY: 2840 case LITERAL_permits: 2841 { 2842 break; 2843 } 2844 default: 2845 { 2846 throw new NoViableAltException(LT(1), getFilename()); 2847 } 2848 } 2849 } 2850 implementsClause_AST = (AST)currentAST.root; 2851 returnAST = implementsClause_AST; 2852 } 2853 2854 public final void recordBodyDeclaration() throws RecognitionException, TokenStreamException { 2855 2856 returnAST = null; 2857 ASTPair currentAST = new ASTPair(); 2858 AST recordBodyDeclaration_AST = null; 2859 2860 AST tmp50_AST = null; 2861 tmp50_AST = astFactory.create(LT(1)); 2862 astFactory.addASTChild(currentAST, tmp50_AST); 2863 match(LCURLY); 2864 { 2865 _loop119: 2866 do { 2867 boolean synPredMatched118 = false; 2868 if (((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2))))) { 2869 int _m118 = mark(); 2870 synPredMatched118 = true; 2871 inputState.guessing++; 2872 try { 2873 { 2874 compactConstructorDeclaration(); 2875 } 2876 } 2877 catch (RecognitionException pe) { 2878 synPredMatched118 = false; 2879 } 2880 rewind(_m118); 2881inputState.guessing--; 2882 } 2883 if ( synPredMatched118 ) { 2884 compactConstructorDeclaration(); 2885 astFactory.addASTChild(currentAST, returnAST); 2886 } 2887 else if ((_tokenSet_28.member(LA(1))) && (_tokenSet_29.member(LA(2)))) { 2888 field(); 2889 astFactory.addASTChild(currentAST, returnAST); 2890 } 2891 else if ((LA(1)==SEMI)) { 2892 AST tmp51_AST = null; 2893 tmp51_AST = astFactory.create(LT(1)); 2894 astFactory.addASTChild(currentAST, tmp51_AST); 2895 match(SEMI); 2896 } 2897 else { 2898 break _loop119; 2899 } 2900 2901 } while (true); 2902 } 2903 AST tmp52_AST = null; 2904 tmp52_AST = astFactory.create(LT(1)); 2905 astFactory.addASTChild(currentAST, tmp52_AST); 2906 match(RCURLY); 2907 if ( inputState.guessing==0 ) { 2908 recordBodyDeclaration_AST = (AST)currentAST.root; 2909 recordBodyDeclaration_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(recordBodyDeclaration_AST)); 2910 currentAST.root = recordBodyDeclaration_AST; 2911 currentAST.child = recordBodyDeclaration_AST!=null &&recordBodyDeclaration_AST.getFirstChild()!=null ? 2912 recordBodyDeclaration_AST.getFirstChild() : recordBodyDeclaration_AST; 2913 currentAST.advanceChildToEnd(); 2914 } 2915 recordBodyDeclaration_AST = (AST)currentAST.root; 2916 returnAST = recordBodyDeclaration_AST; 2917 } 2918 2919 public final void recordComponents() throws RecognitionException, TokenStreamException { 2920 2921 returnAST = null; 2922 ASTPair currentAST = new ASTPair(); 2923 AST recordComponents_AST = null; 2924 2925 { 2926 boolean synPredMatched107 = false; 2927 if (((_tokenSet_15.member(LA(1))) && (_tokenSet_30.member(LA(2))))) { 2928 int _m107 = mark(); 2929 synPredMatched107 = true; 2930 inputState.guessing++; 2931 try { 2932 { 2933 recordComponent(); 2934 } 2935 } 2936 catch (RecognitionException pe) { 2937 synPredMatched107 = false; 2938 } 2939 rewind(_m107); 2940inputState.guessing--; 2941 } 2942 if ( synPredMatched107 ) { 2943 recordComponent(); 2944 astFactory.addASTChild(currentAST, returnAST); 2945 { 2946 _loop111: 2947 do { 2948 boolean synPredMatched110 = false; 2949 if (((LA(1)==COMMA) && (_tokenSet_15.member(LA(2))))) { 2950 int _m110 = mark(); 2951 synPredMatched110 = true; 2952 inputState.guessing++; 2953 try { 2954 { 2955 match(COMMA); 2956 recordComponent(); 2957 } 2958 } 2959 catch (RecognitionException pe) { 2960 synPredMatched110 = false; 2961 } 2962 rewind(_m110); 2963inputState.guessing--; 2964 } 2965 if ( synPredMatched110 ) { 2966 AST tmp53_AST = null; 2967 tmp53_AST = astFactory.create(LT(1)); 2968 astFactory.addASTChild(currentAST, tmp53_AST); 2969 match(COMMA); 2970 recordComponent(); 2971 astFactory.addASTChild(currentAST, returnAST); 2972 } 2973 else { 2974 break _loop111; 2975 } 2976 2977 } while (true); 2978 } 2979 { 2980 switch ( LA(1)) { 2981 case COMMA: 2982 { 2983 AST tmp54_AST = null; 2984 tmp54_AST = astFactory.create(LT(1)); 2985 astFactory.addASTChild(currentAST, tmp54_AST); 2986 match(COMMA); 2987 recordComponentVariableLength(); 2988 astFactory.addASTChild(currentAST, returnAST); 2989 break; 2990 } 2991 case RPAREN: 2992 { 2993 break; 2994 } 2995 default: 2996 { 2997 throw new NoViableAltException(LT(1), getFilename()); 2998 } 2999 } 3000 } 3001 } 3002 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_31.member(LA(2)))) { 3003 recordComponentVariableLength(); 3004 astFactory.addASTChild(currentAST, returnAST); 3005 } 3006 else if ((LA(1)==RPAREN)) { 3007 } 3008 else { 3009 throw new NoViableAltException(LT(1), getFilename()); 3010 } 3011 3012 } 3013 if ( inputState.guessing==0 ) { 3014 recordComponents_AST = (AST)currentAST.root; 3015 recordComponents_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RECORD_COMPONENTS,"RECORD_COMPONENTS")).add(recordComponents_AST)); 3016 currentAST.root = recordComponents_AST; 3017 currentAST.child = recordComponents_AST!=null &&recordComponents_AST.getFirstChild()!=null ? 3018 recordComponents_AST.getFirstChild() : recordComponents_AST; 3019 currentAST.advanceChildToEnd(); 3020 } 3021 recordComponents_AST = (AST)currentAST.root; 3022 returnAST = recordComponents_AST; 3023 } 3024 3025 public final void recordComponent() throws RecognitionException, TokenStreamException { 3026 3027 returnAST = null; 3028 ASTPair currentAST = new ASTPair(); 3029 AST recordComponent_AST = null; 3030 AST a_AST = null; 3031 AST t_AST = null; 3032 AST i_AST = null; 3033 AST d_AST = null; 3034 3035 annotations(); 3036 a_AST = (AST)returnAST; 3037 typeSpec(false); 3038 t_AST = (AST)returnAST; 3039 id(); 3040 i_AST = (AST)returnAST; 3041 typeSpecBracketsAndAnnotationsNonGreedy(); 3042 d_AST = (AST)returnAST; 3043 if ( inputState.guessing==0 ) { 3044 recordComponent_AST = (AST)currentAST.root; 3045 recordComponent_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(RECORD_COMPONENT_DEF,"RECORD_COMPONENT_DEF")).add(a_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(d_AST))).add(i_AST)); 3046 currentAST.root = recordComponent_AST; 3047 currentAST.child = recordComponent_AST!=null &&recordComponent_AST.getFirstChild()!=null ? 3048 recordComponent_AST.getFirstChild() : recordComponent_AST; 3049 currentAST.advanceChildToEnd(); 3050 } 3051 returnAST = recordComponent_AST; 3052 } 3053 3054 public final void recordComponentVariableLength() throws RecognitionException, TokenStreamException { 3055 3056 returnAST = null; 3057 ASTPair currentAST = new ASTPair(); 3058 AST recordComponentVariableLength_AST = null; 3059 AST a_AST = null; 3060 AST t_AST = null; 3061 Token e = null; 3062 AST e_AST = null; 3063 AST i_AST = null; 3064 AST d_AST = null; 3065 3066 annotations(); 3067 a_AST = (AST)returnAST; 3068 variableLengthParameterTypeSpec(); 3069 t_AST = (AST)returnAST; 3070 e = LT(1); 3071 e_AST = astFactory.create(e); 3072 match(ELLIPSIS); 3073 id(); 3074 i_AST = (AST)returnAST; 3075 typeSpecBracketsAndAnnotationsNonGreedy(); 3076 d_AST = (AST)returnAST; 3077 if ( inputState.guessing==0 ) { 3078 recordComponentVariableLength_AST = (AST)currentAST.root; 3079 recordComponentVariableLength_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(RECORD_COMPONENT_DEF,"RECORD_COMPONENT_DEF")).add(a_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(d_AST))).add(e_AST).add(i_AST)); 3080 currentAST.root = recordComponentVariableLength_AST; 3081 currentAST.child = recordComponentVariableLength_AST!=null &&recordComponentVariableLength_AST.getFirstChild()!=null ? 3082 recordComponentVariableLength_AST.getFirstChild() : recordComponentVariableLength_AST; 3083 currentAST.advanceChildToEnd(); 3084 } 3085 returnAST = recordComponentVariableLength_AST; 3086 } 3087 3088 public final void compactConstructorDeclaration() throws RecognitionException, TokenStreamException { 3089 3090 returnAST = null; 3091 ASTPair currentAST = new ASTPair(); 3092 AST compactConstructorDeclaration_AST = null; 3093 AST m_AST = null; 3094 AST i_AST = null; 3095 AST c_AST = null; 3096 3097 modifiers(); 3098 m_AST = (AST)returnAST; 3099 id(); 3100 i_AST = (AST)returnAST; 3101 constructorBody(); 3102 c_AST = (AST)returnAST; 3103 if ( inputState.guessing==0 ) { 3104 compactConstructorDeclaration_AST = (AST)currentAST.root; 3105 compactConstructorDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(COMPACT_CTOR_DEF,"COMPACT_CTOR_DEF")).add(m_AST).add(i_AST).add(c_AST)); 3106 currentAST.root = compactConstructorDeclaration_AST; 3107 currentAST.child = compactConstructorDeclaration_AST!=null &&compactConstructorDeclaration_AST.getFirstChild()!=null ? 3108 compactConstructorDeclaration_AST.getFirstChild() : compactConstructorDeclaration_AST; 3109 currentAST.advanceChildToEnd(); 3110 } 3111 returnAST = compactConstructorDeclaration_AST; 3112 } 3113 3114 public final void field() throws RecognitionException, TokenStreamException { 3115 3116 returnAST = null; 3117 ASTPair currentAST = new ASTPair(); 3118 AST field_AST = null; 3119 AST mods_AST = null; 3120 AST td_AST = null; 3121 AST tp_AST = null; 3122 AST h_AST = null; 3123 AST s_AST = null; 3124 AST t_AST = null; 3125 AST id_AST = null; 3126 AST param_AST = null; 3127 AST rt_AST = null; 3128 AST tc_AST = null; 3129 AST s2_AST = null; 3130 Token s5 = null; 3131 AST s5_AST = null; 3132 AST v_AST = null; 3133 Token s6 = null; 3134 AST s6_AST = null; 3135 Token si = null; 3136 AST si_AST = null; 3137 AST s3_AST = null; 3138 AST s4_AST = null; 3139 3140 if ((_tokenSet_32.member(LA(1))) && (_tokenSet_33.member(LA(2)))) { 3141 modifiers(); 3142 mods_AST = (AST)returnAST; 3143 { 3144 if ((_tokenSet_34.member(LA(1))) && (_tokenSet_35.member(LA(2)))) { 3145 typeDefinitionInternal(mods_AST); 3146 td_AST = (AST)returnAST; 3147 if ( inputState.guessing==0 ) { 3148 field_AST = (AST)currentAST.root; 3149 field_AST = td_AST; 3150 currentAST.root = field_AST; 3151 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3152 field_AST.getFirstChild() : field_AST; 3153 currentAST.advanceChildToEnd(); 3154 } 3155 } 3156 else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_16.member(LA(2)))) { 3157 { 3158 switch ( LA(1)) { 3159 case LT: 3160 { 3161 typeParameters(); 3162 tp_AST = (AST)returnAST; 3163 break; 3164 } 3165 case LITERAL_void: 3166 case LITERAL_boolean: 3167 case LITERAL_byte: 3168 case LITERAL_char: 3169 case LITERAL_short: 3170 case LITERAL_int: 3171 case LITERAL_float: 3172 case LITERAL_long: 3173 case LITERAL_double: 3174 case IDENT: 3175 case AT: 3176 case LITERAL_record: 3177 case LITERAL_yield: 3178 case LITERAL_sealed: 3179 case LITERAL_permits: 3180 case LITERAL_non: 3181 { 3182 break; 3183 } 3184 default: 3185 { 3186 throw new NoViableAltException(LT(1), getFilename()); 3187 } 3188 } 3189 } 3190 { 3191 if ((_tokenSet_0.member(LA(1))) && (LA(2)==LPAREN)) { 3192 ctorHead(); 3193 h_AST = (AST)returnAST; 3194 constructorBody(); 3195 s_AST = (AST)returnAST; 3196 if ( inputState.guessing==0 ) { 3197 field_AST = (AST)currentAST.root; 3198 field_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(CTOR_DEF,"CTOR_DEF")).add(mods_AST).add(tp_AST).add(h_AST).add(s_AST)); 3199 currentAST.root = field_AST; 3200 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3201 field_AST.getFirstChild() : field_AST; 3202 currentAST.advanceChildToEnd(); 3203 } 3204 } 3205 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_30.member(LA(2)))) { 3206 typeSpec(false); 3207 t_AST = (AST)returnAST; 3208 { 3209 if ((_tokenSet_0.member(LA(1))) && (LA(2)==LPAREN)) { 3210 id(); 3211 id_AST = (AST)returnAST; 3212 AST tmp55_AST = null; 3213 tmp55_AST = astFactory.create(LT(1)); 3214 match(LPAREN); 3215 parameterDeclarationList(); 3216 param_AST = (AST)returnAST; 3217 AST tmp56_AST = null; 3218 tmp56_AST = astFactory.create(LT(1)); 3219 match(RPAREN); 3220 typeSpecBracketsAndAnnotationsNonGreedy(); 3221 rt_AST = (AST)returnAST; 3222 { 3223 switch ( LA(1)) { 3224 case LITERAL_throws: 3225 { 3226 throwsClause(); 3227 tc_AST = (AST)returnAST; 3228 break; 3229 } 3230 case SEMI: 3231 case LCURLY: 3232 { 3233 break; 3234 } 3235 default: 3236 { 3237 throw new NoViableAltException(LT(1), getFilename()); 3238 } 3239 } 3240 } 3241 { 3242 switch ( LA(1)) { 3243 case LCURLY: 3244 { 3245 compoundStatement(); 3246 s2_AST = (AST)returnAST; 3247 break; 3248 } 3249 case SEMI: 3250 { 3251 s5 = LT(1); 3252 s5_AST = astFactory.create(s5); 3253 match(SEMI); 3254 break; 3255 } 3256 default: 3257 { 3258 throw new NoViableAltException(LT(1), getFilename()); 3259 } 3260 } 3261 } 3262 if ( inputState.guessing==0 ) { 3263 field_AST = (AST)currentAST.root; 3264 field_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(rt_AST))).add(id_AST).add(tmp55_AST).add(param_AST).add(tmp56_AST).add(tc_AST).add(s2_AST).add(s5_AST)); 3265 currentAST.root = field_AST; 3266 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3267 field_AST.getFirstChild() : field_AST; 3268 currentAST.advanceChildToEnd(); 3269 } 3270 } 3271 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_37.member(LA(2)))) { 3272 variableDefinitions(mods_AST,t_AST); 3273 v_AST = (AST)returnAST; 3274 { 3275 if ((LA(1)==SEMI) && (_tokenSet_38.member(LA(2)))) { 3276 s6 = LT(1); 3277 s6_AST = astFactory.create(s6); 3278 match(SEMI); 3279 } 3280 else if ((_tokenSet_38.member(LA(1))) && (_tokenSet_39.member(LA(2)))) { 3281 } 3282 else { 3283 throw new NoViableAltException(LT(1), getFilename()); 3284 } 3285 3286 } 3287 if ( inputState.guessing==0 ) { 3288 field_AST = (AST)currentAST.root; 3289 3290 field_AST = v_AST; 3291 v_AST.addChild(s6_AST); 3292 3293 currentAST.root = field_AST; 3294 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3295 field_AST.getFirstChild() : field_AST; 3296 currentAST.advanceChildToEnd(); 3297 } 3298 } 3299 else { 3300 throw new NoViableAltException(LT(1), getFilename()); 3301 } 3302 3303 } 3304 } 3305 else { 3306 throw new NoViableAltException(LT(1), getFilename()); 3307 } 3308 3309 } 3310 } 3311 else { 3312 throw new NoViableAltException(LT(1), getFilename()); 3313 } 3314 3315 } 3316 } 3317 else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) { 3318 si = LT(1); 3319 si_AST = astFactory.create(si); 3320 match(LITERAL_static); 3321 compoundStatement(); 3322 s3_AST = (AST)returnAST; 3323 if ( inputState.guessing==0 ) { 3324 field_AST = (AST)currentAST.root; 3325 si_AST.setType(STATIC_INIT); 3326 si_AST.setText("STATIC_INIT"); 3327 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(si_AST).add(s3_AST)); 3328 currentAST.root = field_AST; 3329 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3330 field_AST.getFirstChild() : field_AST; 3331 currentAST.advanceChildToEnd(); 3332 } 3333 } 3334 else if ((LA(1)==LCURLY)) { 3335 compoundStatement(); 3336 s4_AST = (AST)returnAST; 3337 if ( inputState.guessing==0 ) { 3338 field_AST = (AST)currentAST.root; 3339 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST)); 3340 currentAST.root = field_AST; 3341 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3342 field_AST.getFirstChild() : field_AST; 3343 currentAST.advanceChildToEnd(); 3344 } 3345 } 3346 else { 3347 throw new NoViableAltException(LT(1), getFilename()); 3348 } 3349 3350 returnAST = field_AST; 3351 } 3352 3353 public final void constructorBody() throws RecognitionException, TokenStreamException { 3354 3355 returnAST = null; 3356 ASTPair currentAST = new ASTPair(); 3357 AST constructorBody_AST = null; 3358 Token lc = null; 3359 AST lc_AST = null; 3360 3361 lc = LT(1); 3362 lc_AST = astFactory.create(lc); 3363 astFactory.makeASTRoot(currentAST, lc_AST); 3364 match(LCURLY); 3365 if ( inputState.guessing==0 ) { 3366 lc_AST.setType(SLIST); 3367 } 3368 { 3369 boolean synPredMatched190 = false; 3370 if (((_tokenSet_40.member(LA(1))) && (_tokenSet_41.member(LA(2))))) { 3371 int _m190 = mark(); 3372 synPredMatched190 = true; 3373 inputState.guessing++; 3374 try { 3375 { 3376 explicitConstructorInvocation(); 3377 } 3378 } 3379 catch (RecognitionException pe) { 3380 synPredMatched190 = false; 3381 } 3382 rewind(_m190); 3383inputState.guessing--; 3384 } 3385 if ( synPredMatched190 ) { 3386 explicitConstructorInvocation(); 3387 astFactory.addASTChild(currentAST, returnAST); 3388 } 3389 else if ((_tokenSet_42.member(LA(1))) && (_tokenSet_43.member(LA(2)))) { 3390 } 3391 else { 3392 throw new NoViableAltException(LT(1), getFilename()); 3393 } 3394 3395 } 3396 { 3397 _loop192: 3398 do { 3399 if ((_tokenSet_44.member(LA(1)))) { 3400 statement(); 3401 astFactory.addASTChild(currentAST, returnAST); 3402 } 3403 else { 3404 break _loop192; 3405 } 3406 3407 } while (true); 3408 } 3409 AST tmp57_AST = null; 3410 tmp57_AST = astFactory.create(LT(1)); 3411 astFactory.addASTChild(currentAST, tmp57_AST); 3412 match(RCURLY); 3413 constructorBody_AST = (AST)currentAST.root; 3414 returnAST = constructorBody_AST; 3415 } 3416 3417 public final void superClassClause() throws RecognitionException, TokenStreamException { 3418 3419 returnAST = null; 3420 ASTPair currentAST = new ASTPair(); 3421 AST superClassClause_AST = null; 3422 Token e = null; 3423 AST e_AST = null; 3424 AST c_AST = null; 3425 3426 { 3427 switch ( LA(1)) { 3428 case LITERAL_extends: 3429 { 3430 e = LT(1); 3431 e_AST = astFactory.create(e); 3432 astFactory.makeASTRoot(currentAST, e_AST); 3433 match(LITERAL_extends); 3434 if ( inputState.guessing==0 ) { 3435 e_AST.setType(EXTENDS_CLAUSE); 3436 } 3437 classOrInterfaceType(false); 3438 c_AST = (AST)returnAST; 3439 astFactory.addASTChild(currentAST, returnAST); 3440 break; 3441 } 3442 case LCURLY: 3443 case LITERAL_implements: 3444 case LITERAL_permits: 3445 { 3446 break; 3447 } 3448 default: 3449 { 3450 throw new NoViableAltException(LT(1), getFilename()); 3451 } 3452 } 3453 } 3454 superClassClause_AST = (AST)currentAST.root; 3455 returnAST = superClassClause_AST; 3456 } 3457 3458 public final void permittedSubclassesAndInterfaces() throws RecognitionException, TokenStreamException { 3459 3460 returnAST = null; 3461 ASTPair currentAST = new ASTPair(); 3462 AST permittedSubclassesAndInterfaces_AST = null; 3463 Token p = null; 3464 AST p_AST = null; 3465 3466 { 3467 switch ( LA(1)) { 3468 case LITERAL_permits: 3469 { 3470 p = LT(1); 3471 p_AST = astFactory.create(p); 3472 astFactory.makeASTRoot(currentAST, p_AST); 3473 match(LITERAL_permits); 3474 if ( inputState.guessing==0 ) { 3475 p_AST.setType(PERMITS_CLAUSE); 3476 } 3477 classOrInterfaceType(false); 3478 astFactory.addASTChild(currentAST, returnAST); 3479 { 3480 _loop463: 3481 do { 3482 if ((LA(1)==COMMA)) { 3483 AST tmp58_AST = null; 3484 tmp58_AST = astFactory.create(LT(1)); 3485 astFactory.addASTChild(currentAST, tmp58_AST); 3486 match(COMMA); 3487 classOrInterfaceType(false); 3488 astFactory.addASTChild(currentAST, returnAST); 3489 } 3490 else { 3491 break _loop463; 3492 } 3493 3494 } while (true); 3495 } 3496 break; 3497 } 3498 case LCURLY: 3499 { 3500 break; 3501 } 3502 default: 3503 { 3504 throw new NoViableAltException(LT(1), getFilename()); 3505 } 3506 } 3507 } 3508 permittedSubclassesAndInterfaces_AST = (AST)currentAST.root; 3509 returnAST = permittedSubclassesAndInterfaces_AST; 3510 } 3511 3512 public final void classBlock() throws RecognitionException, TokenStreamException { 3513 3514 returnAST = null; 3515 ASTPair currentAST = new ASTPair(); 3516 AST classBlock_AST = null; 3517 3518 AST tmp59_AST = null; 3519 tmp59_AST = astFactory.create(LT(1)); 3520 astFactory.addASTChild(currentAST, tmp59_AST); 3521 match(LCURLY); 3522 { 3523 _loop170: 3524 do { 3525 switch ( LA(1)) { 3526 case FINAL: 3527 case ABSTRACT: 3528 case STRICTFP: 3529 case LITERAL_void: 3530 case LITERAL_boolean: 3531 case LITERAL_byte: 3532 case LITERAL_char: 3533 case LITERAL_short: 3534 case LITERAL_int: 3535 case LITERAL_float: 3536 case LITERAL_long: 3537 case LITERAL_double: 3538 case IDENT: 3539 case LITERAL_private: 3540 case LITERAL_public: 3541 case LITERAL_protected: 3542 case LITERAL_static: 3543 case LITERAL_transient: 3544 case LITERAL_native: 3545 case LITERAL_synchronized: 3546 case LITERAL_volatile: 3547 case LITERAL_class: 3548 case LITERAL_interface: 3549 case LCURLY: 3550 case LITERAL_default: 3551 case LT: 3552 case ENUM: 3553 case AT: 3554 case LITERAL_record: 3555 case LITERAL_yield: 3556 case LITERAL_sealed: 3557 case LITERAL_permits: 3558 case LITERAL_non: 3559 { 3560 field(); 3561 astFactory.addASTChild(currentAST, returnAST); 3562 break; 3563 } 3564 case SEMI: 3565 { 3566 AST tmp60_AST = null; 3567 tmp60_AST = astFactory.create(LT(1)); 3568 astFactory.addASTChild(currentAST, tmp60_AST); 3569 match(SEMI); 3570 break; 3571 } 3572 default: 3573 { 3574 break _loop170; 3575 } 3576 } 3577 } while (true); 3578 } 3579 AST tmp61_AST = null; 3580 tmp61_AST = astFactory.create(LT(1)); 3581 astFactory.addASTChild(currentAST, tmp61_AST); 3582 match(RCURLY); 3583 if ( inputState.guessing==0 ) { 3584 classBlock_AST = (AST)currentAST.root; 3585 classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST)); 3586 currentAST.root = classBlock_AST; 3587 currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ? 3588 classBlock_AST.getFirstChild() : classBlock_AST; 3589 currentAST.advanceChildToEnd(); 3590 } 3591 classBlock_AST = (AST)currentAST.root; 3592 returnAST = classBlock_AST; 3593 } 3594 3595 public final void interfaceExtends() throws RecognitionException, TokenStreamException { 3596 3597 returnAST = null; 3598 ASTPair currentAST = new ASTPair(); 3599 AST interfaceExtends_AST = null; 3600 Token e = null; 3601 AST e_AST = null; 3602 3603 { 3604 switch ( LA(1)) { 3605 case LITERAL_extends: 3606 { 3607 e = LT(1); 3608 e_AST = astFactory.create(e); 3609 astFactory.makeASTRoot(currentAST, e_AST); 3610 match(LITERAL_extends); 3611 if ( inputState.guessing==0 ) { 3612 e_AST.setType(EXTENDS_CLAUSE); 3613 } 3614 classOrInterfaceType(false); 3615 astFactory.addASTChild(currentAST, returnAST); 3616 { 3617 _loop174: 3618 do { 3619 if ((LA(1)==COMMA)) { 3620 AST tmp62_AST = null; 3621 tmp62_AST = astFactory.create(LT(1)); 3622 astFactory.addASTChild(currentAST, tmp62_AST); 3623 match(COMMA); 3624 classOrInterfaceType(false); 3625 astFactory.addASTChild(currentAST, returnAST); 3626 } 3627 else { 3628 break _loop174; 3629 } 3630 3631 } while (true); 3632 } 3633 break; 3634 } 3635 case LCURLY: 3636 case LITERAL_permits: 3637 { 3638 break; 3639 } 3640 default: 3641 { 3642 throw new NoViableAltException(LT(1), getFilename()); 3643 } 3644 } 3645 } 3646 interfaceExtends_AST = (AST)currentAST.root; 3647 returnAST = interfaceExtends_AST; 3648 } 3649 3650 public final void enumBlock() throws RecognitionException, TokenStreamException { 3651 3652 returnAST = null; 3653 ASTPair currentAST = new ASTPair(); 3654 AST enumBlock_AST = null; 3655 3656 AST tmp63_AST = null; 3657 tmp63_AST = astFactory.create(LT(1)); 3658 astFactory.addASTChild(currentAST, tmp63_AST); 3659 match(LCURLY); 3660 { 3661 switch ( LA(1)) { 3662 case IDENT: 3663 case AT: 3664 case LITERAL_record: 3665 case LITERAL_yield: 3666 case LITERAL_sealed: 3667 case LITERAL_permits: 3668 case LITERAL_non: 3669 { 3670 enumConstant(); 3671 astFactory.addASTChild(currentAST, returnAST); 3672 { 3673 _loop151: 3674 do { 3675 if ((LA(1)==COMMA) && (_tokenSet_10.member(LA(2)))) { 3676 AST tmp64_AST = null; 3677 tmp64_AST = astFactory.create(LT(1)); 3678 astFactory.addASTChild(currentAST, tmp64_AST); 3679 match(COMMA); 3680 enumConstant(); 3681 astFactory.addASTChild(currentAST, returnAST); 3682 } 3683 else { 3684 break _loop151; 3685 } 3686 3687 } while (true); 3688 } 3689 break; 3690 } 3691 case SEMI: 3692 case RCURLY: 3693 case COMMA: 3694 { 3695 break; 3696 } 3697 default: 3698 { 3699 throw new NoViableAltException(LT(1), getFilename()); 3700 } 3701 } 3702 } 3703 { 3704 switch ( LA(1)) { 3705 case COMMA: 3706 { 3707 AST tmp65_AST = null; 3708 tmp65_AST = astFactory.create(LT(1)); 3709 astFactory.addASTChild(currentAST, tmp65_AST); 3710 match(COMMA); 3711 break; 3712 } 3713 case SEMI: 3714 case RCURLY: 3715 { 3716 break; 3717 } 3718 default: 3719 { 3720 throw new NoViableAltException(LT(1), getFilename()); 3721 } 3722 } 3723 } 3724 { 3725 switch ( LA(1)) { 3726 case SEMI: 3727 { 3728 AST tmp66_AST = null; 3729 tmp66_AST = astFactory.create(LT(1)); 3730 astFactory.addASTChild(currentAST, tmp66_AST); 3731 match(SEMI); 3732 { 3733 _loop155: 3734 do { 3735 switch ( LA(1)) { 3736 case FINAL: 3737 case ABSTRACT: 3738 case STRICTFP: 3739 case LITERAL_void: 3740 case LITERAL_boolean: 3741 case LITERAL_byte: 3742 case LITERAL_char: 3743 case LITERAL_short: 3744 case LITERAL_int: 3745 case LITERAL_float: 3746 case LITERAL_long: 3747 case LITERAL_double: 3748 case IDENT: 3749 case LITERAL_private: 3750 case LITERAL_public: 3751 case LITERAL_protected: 3752 case LITERAL_static: 3753 case LITERAL_transient: 3754 case LITERAL_native: 3755 case LITERAL_synchronized: 3756 case LITERAL_volatile: 3757 case LITERAL_class: 3758 case LITERAL_interface: 3759 case LCURLY: 3760 case LITERAL_default: 3761 case LT: 3762 case ENUM: 3763 case AT: 3764 case LITERAL_record: 3765 case LITERAL_yield: 3766 case LITERAL_sealed: 3767 case LITERAL_permits: 3768 case LITERAL_non: 3769 { 3770 field(); 3771 astFactory.addASTChild(currentAST, returnAST); 3772 break; 3773 } 3774 case SEMI: 3775 { 3776 AST tmp67_AST = null; 3777 tmp67_AST = astFactory.create(LT(1)); 3778 astFactory.addASTChild(currentAST, tmp67_AST); 3779 match(SEMI); 3780 break; 3781 } 3782 default: 3783 { 3784 break _loop155; 3785 } 3786 } 3787 } while (true); 3788 } 3789 break; 3790 } 3791 case RCURLY: 3792 { 3793 break; 3794 } 3795 default: 3796 { 3797 throw new NoViableAltException(LT(1), getFilename()); 3798 } 3799 } 3800 } 3801 AST tmp68_AST = null; 3802 tmp68_AST = astFactory.create(LT(1)); 3803 astFactory.addASTChild(currentAST, tmp68_AST); 3804 match(RCURLY); 3805 if ( inputState.guessing==0 ) { 3806 enumBlock_AST = (AST)currentAST.root; 3807 enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST)); 3808 currentAST.root = enumBlock_AST; 3809 currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ? 3810 enumBlock_AST.getFirstChild() : enumBlock_AST; 3811 currentAST.advanceChildToEnd(); 3812 } 3813 enumBlock_AST = (AST)currentAST.root; 3814 returnAST = enumBlock_AST; 3815 } 3816 3817 public final void annotationBlock() throws RecognitionException, TokenStreamException { 3818 3819 returnAST = null; 3820 ASTPair currentAST = new ASTPair(); 3821 AST annotationBlock_AST = null; 3822 3823 AST tmp69_AST = null; 3824 tmp69_AST = astFactory.create(LT(1)); 3825 astFactory.addASTChild(currentAST, tmp69_AST); 3826 match(LCURLY); 3827 { 3828 _loop142: 3829 do { 3830 switch ( LA(1)) { 3831 case FINAL: 3832 case ABSTRACT: 3833 case STRICTFP: 3834 case LITERAL_void: 3835 case LITERAL_boolean: 3836 case LITERAL_byte: 3837 case LITERAL_char: 3838 case LITERAL_short: 3839 case LITERAL_int: 3840 case LITERAL_float: 3841 case LITERAL_long: 3842 case LITERAL_double: 3843 case IDENT: 3844 case LITERAL_private: 3845 case LITERAL_public: 3846 case LITERAL_protected: 3847 case LITERAL_static: 3848 case LITERAL_transient: 3849 case LITERAL_native: 3850 case LITERAL_synchronized: 3851 case LITERAL_volatile: 3852 case LITERAL_class: 3853 case LITERAL_interface: 3854 case LITERAL_default: 3855 case ENUM: 3856 case AT: 3857 case LITERAL_record: 3858 case LITERAL_yield: 3859 case LITERAL_sealed: 3860 case LITERAL_permits: 3861 case LITERAL_non: 3862 { 3863 annotationField(); 3864 astFactory.addASTChild(currentAST, returnAST); 3865 break; 3866 } 3867 case SEMI: 3868 { 3869 AST tmp70_AST = null; 3870 tmp70_AST = astFactory.create(LT(1)); 3871 astFactory.addASTChild(currentAST, tmp70_AST); 3872 match(SEMI); 3873 break; 3874 } 3875 default: 3876 { 3877 break _loop142; 3878 } 3879 } 3880 } while (true); 3881 } 3882 AST tmp71_AST = null; 3883 tmp71_AST = astFactory.create(LT(1)); 3884 astFactory.addASTChild(currentAST, tmp71_AST); 3885 match(RCURLY); 3886 if ( inputState.guessing==0 ) { 3887 annotationBlock_AST = (AST)currentAST.root; 3888 annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST)); 3889 currentAST.root = annotationBlock_AST; 3890 currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ? 3891 annotationBlock_AST.getFirstChild() : annotationBlock_AST; 3892 currentAST.advanceChildToEnd(); 3893 } 3894 annotationBlock_AST = (AST)currentAST.root; 3895 returnAST = annotationBlock_AST; 3896 } 3897 3898 public final void typeParameter() throws RecognitionException, TokenStreamException { 3899 3900 returnAST = null; 3901 ASTPair currentAST = new ASTPair(); 3902 AST typeParameter_AST = null; 3903 AST id_AST = null; 3904 3905 { 3906 if (((_tokenSet_10.member(LA(1))) && (_tokenSet_45.member(LA(2))))&&(LA(1) == AT)) { 3907 annotations(); 3908 astFactory.addASTChild(currentAST, returnAST); 3909 } 3910 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 3911 } 3912 else { 3913 throw new NoViableAltException(LT(1), getFilename()); 3914 } 3915 3916 } 3917 { 3918 id(); 3919 id_AST = (AST)returnAST; 3920 astFactory.addASTChild(currentAST, returnAST); 3921 } 3922 { 3923 if ((LA(1)==LITERAL_extends) && (_tokenSet_10.member(LA(2)))) { 3924 typeParameterBounds(); 3925 astFactory.addASTChild(currentAST, returnAST); 3926 } 3927 else if ((_tokenSet_45.member(LA(1))) && (_tokenSet_46.member(LA(2)))) { 3928 } 3929 else { 3930 throw new NoViableAltException(LT(1), getFilename()); 3931 } 3932 3933 } 3934 if ( inputState.guessing==0 ) { 3935 typeParameter_AST = (AST)currentAST.root; 3936 typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).add(typeParameter_AST)); 3937 currentAST.root = typeParameter_AST; 3938 currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ? 3939 typeParameter_AST.getFirstChild() : typeParameter_AST; 3940 currentAST.advanceChildToEnd(); 3941 } 3942 typeParameter_AST = (AST)currentAST.root; 3943 returnAST = typeParameter_AST; 3944 } 3945 3946 public final void typeParameterBounds() throws RecognitionException, TokenStreamException { 3947 3948 returnAST = null; 3949 ASTPair currentAST = new ASTPair(); 3950 AST typeParameterBounds_AST = null; 3951 Token e = null; 3952 AST e_AST = null; 3953 Token b = null; 3954 AST b_AST = null; 3955 3956 e = LT(1); 3957 e_AST = astFactory.create(e); 3958 astFactory.makeASTRoot(currentAST, e_AST); 3959 match(LITERAL_extends); 3960 classOrInterfaceType(true); 3961 astFactory.addASTChild(currentAST, returnAST); 3962 { 3963 _loop139: 3964 do { 3965 if ((LA(1)==BAND)) { 3966 b = LT(1); 3967 b_AST = astFactory.create(b); 3968 astFactory.addASTChild(currentAST, b_AST); 3969 match(BAND); 3970 if ( inputState.guessing==0 ) { 3971 b_AST.setType(TYPE_EXTENSION_AND); 3972 } 3973 classOrInterfaceType(true); 3974 astFactory.addASTChild(currentAST, returnAST); 3975 } 3976 else { 3977 break _loop139; 3978 } 3979 3980 } while (true); 3981 } 3982 if ( inputState.guessing==0 ) { 3983 e_AST.setType(TYPE_UPPER_BOUNDS); 3984 } 3985 typeParameterBounds_AST = (AST)currentAST.root; 3986 returnAST = typeParameterBounds_AST; 3987 } 3988 3989 public final void annotationField() throws RecognitionException, TokenStreamException { 3990 3991 returnAST = null; 3992 ASTPair currentAST = new ASTPair(); 3993 AST annotationField_AST = null; 3994 AST mods_AST = null; 3995 AST td_AST = null; 3996 AST t_AST = null; 3997 AST i_AST = null; 3998 AST rt_AST = null; 3999 AST d_AST = null; 4000 Token s = null; 4001 AST s_AST = null; 4002 AST v_AST = null; 4003 Token s6 = null; 4004 AST s6_AST = null; 4005 4006 modifiers(); 4007 mods_AST = (AST)returnAST; 4008 { 4009 if ((_tokenSet_34.member(LA(1))) && (_tokenSet_35.member(LA(2)))) { 4010 typeDefinitionInternal(mods_AST); 4011 td_AST = (AST)returnAST; 4012 if ( inputState.guessing==0 ) { 4013 annotationField_AST = (AST)currentAST.root; 4014 annotationField_AST = td_AST; 4015 currentAST.root = annotationField_AST; 4016 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? 4017 annotationField_AST.getFirstChild() : annotationField_AST; 4018 currentAST.advanceChildToEnd(); 4019 } 4020 } 4021 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_30.member(LA(2)))) { 4022 typeSpec(false); 4023 t_AST = (AST)returnAST; 4024 { 4025 if ((_tokenSet_0.member(LA(1))) && (LA(2)==LPAREN)) { 4026 id(); 4027 i_AST = (AST)returnAST; 4028 AST tmp72_AST = null; 4029 tmp72_AST = astFactory.create(LT(1)); 4030 match(LPAREN); 4031 AST tmp73_AST = null; 4032 tmp73_AST = astFactory.create(LT(1)); 4033 match(RPAREN); 4034 typeSpecBracketsAndAnnotationsNonGreedy(); 4035 rt_AST = (AST)returnAST; 4036 { 4037 switch ( LA(1)) { 4038 case LITERAL_default: 4039 { 4040 annotationDefault(); 4041 d_AST = (AST)returnAST; 4042 break; 4043 } 4044 case SEMI: 4045 { 4046 break; 4047 } 4048 default: 4049 { 4050 throw new NoViableAltException(LT(1), getFilename()); 4051 } 4052 } 4053 } 4054 s = LT(1); 4055 s_AST = astFactory.create(s); 4056 match(SEMI); 4057 if ( inputState.guessing==0 ) { 4058 annotationField_AST = (AST)currentAST.root; 4059 annotationField_AST = 4060 (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(rt_AST))).add(i_AST).add(tmp72_AST).add(tmp73_AST).add(d_AST).add(s_AST)); 4061 currentAST.root = annotationField_AST; 4062 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? 4063 annotationField_AST.getFirstChild() : annotationField_AST; 4064 currentAST.advanceChildToEnd(); 4065 } 4066 } 4067 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_47.member(LA(2)))) { 4068 variableDefinitions(mods_AST,t_AST); 4069 v_AST = (AST)returnAST; 4070 s6 = LT(1); 4071 s6_AST = astFactory.create(s6); 4072 match(SEMI); 4073 if ( inputState.guessing==0 ) { 4074 annotationField_AST = (AST)currentAST.root; 4075 4076 annotationField_AST = v_AST; 4077 v_AST.addChild(s6_AST); 4078 4079 currentAST.root = annotationField_AST; 4080 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? 4081 annotationField_AST.getFirstChild() : annotationField_AST; 4082 currentAST.advanceChildToEnd(); 4083 } 4084 } 4085 else { 4086 throw new NoViableAltException(LT(1), getFilename()); 4087 } 4088 4089 } 4090 } 4091 else { 4092 throw new NoViableAltException(LT(1), getFilename()); 4093 } 4094 4095 } 4096 returnAST = annotationField_AST; 4097 } 4098 4099 public final void annotationDefault() throws RecognitionException, TokenStreamException { 4100 4101 returnAST = null; 4102 ASTPair currentAST = new ASTPair(); 4103 AST annotationDefault_AST = null; 4104 4105 AST tmp74_AST = null; 4106 tmp74_AST = astFactory.create(LT(1)); 4107 astFactory.makeASTRoot(currentAST, tmp74_AST); 4108 match(LITERAL_default); 4109 annotationMemberValueInitializer(); 4110 astFactory.addASTChild(currentAST, returnAST); 4111 annotationDefault_AST = (AST)currentAST.root; 4112 returnAST = annotationDefault_AST; 4113 } 4114 4115 public final void enumConstant() throws RecognitionException, TokenStreamException { 4116 4117 returnAST = null; 4118 ASTPair currentAST = new ASTPair(); 4119 AST enumConstant_AST = null; 4120 AST an_AST = null; 4121 AST i_AST = null; 4122 Token l = null; 4123 AST l_AST = null; 4124 AST args_AST = null; 4125 Token r = null; 4126 AST r_AST = null; 4127 AST b_AST = null; 4128 4129 annotations(); 4130 an_AST = (AST)returnAST; 4131 id(); 4132 i_AST = (AST)returnAST; 4133 { 4134 switch ( LA(1)) { 4135 case LPAREN: 4136 { 4137 l = LT(1); 4138 l_AST = astFactory.create(l); 4139 match(LPAREN); 4140 argList(); 4141 args_AST = (AST)returnAST; 4142 r = LT(1); 4143 r_AST = astFactory.create(r); 4144 match(RPAREN); 4145 break; 4146 } 4147 case SEMI: 4148 case LCURLY: 4149 case RCURLY: 4150 case COMMA: 4151 { 4152 break; 4153 } 4154 default: 4155 { 4156 throw new NoViableAltException(LT(1), getFilename()); 4157 } 4158 } 4159 } 4160 { 4161 switch ( LA(1)) { 4162 case LCURLY: 4163 { 4164 enumConstantBlock(); 4165 b_AST = (AST)returnAST; 4166 break; 4167 } 4168 case SEMI: 4169 case RCURLY: 4170 case COMMA: 4171 { 4172 break; 4173 } 4174 default: 4175 { 4176 throw new NoViableAltException(LT(1), getFilename()); 4177 } 4178 } 4179 } 4180 if ( inputState.guessing==0 ) { 4181 enumConstant_AST = (AST)currentAST.root; 4182 enumConstant_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(ENUM_CONSTANT_DEF,"ENUM_CONSTANT_DEF")).add(an_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST).add(b_AST)); 4183 currentAST.root = enumConstant_AST; 4184 currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ? 4185 enumConstant_AST.getFirstChild() : enumConstant_AST; 4186 currentAST.advanceChildToEnd(); 4187 } 4188 returnAST = enumConstant_AST; 4189 } 4190 4191 public final void argList() throws RecognitionException, TokenStreamException { 4192 4193 returnAST = null; 4194 ASTPair currentAST = new ASTPair(); 4195 AST argList_AST = null; 4196 4197 { 4198 if (((_tokenSet_19.member(LA(1))))&&(LA(1)!=RPAREN)) { 4199 expressionList(); 4200 astFactory.addASTChild(currentAST, returnAST); 4201 } 4202 else if ((LA(1)==RPAREN)) { 4203 if ( inputState.guessing==0 ) { 4204 argList_AST = (AST)currentAST.root; 4205 argList_AST = astFactory.create(ELIST,"ELIST"); 4206 currentAST.root = argList_AST; 4207 currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ? 4208 argList_AST.getFirstChild() : argList_AST; 4209 currentAST.advanceChildToEnd(); 4210 } 4211 } 4212 else { 4213 throw new NoViableAltException(LT(1), getFilename()); 4214 } 4215 4216 } 4217 argList_AST = (AST)currentAST.root; 4218 returnAST = argList_AST; 4219 } 4220 4221 public final void enumConstantBlock() throws RecognitionException, TokenStreamException { 4222 4223 returnAST = null; 4224 ASTPair currentAST = new ASTPair(); 4225 AST enumConstantBlock_AST = null; 4226 4227 AST tmp75_AST = null; 4228 tmp75_AST = astFactory.create(LT(1)); 4229 astFactory.addASTChild(currentAST, tmp75_AST); 4230 match(LCURLY); 4231 { 4232 _loop161: 4233 do { 4234 switch ( LA(1)) { 4235 case FINAL: 4236 case ABSTRACT: 4237 case STRICTFP: 4238 case LITERAL_void: 4239 case LITERAL_boolean: 4240 case LITERAL_byte: 4241 case LITERAL_char: 4242 case LITERAL_short: 4243 case LITERAL_int: 4244 case LITERAL_float: 4245 case LITERAL_long: 4246 case LITERAL_double: 4247 case IDENT: 4248 case LITERAL_private: 4249 case LITERAL_public: 4250 case LITERAL_protected: 4251 case LITERAL_static: 4252 case LITERAL_transient: 4253 case LITERAL_native: 4254 case LITERAL_synchronized: 4255 case LITERAL_volatile: 4256 case LITERAL_class: 4257 case LITERAL_interface: 4258 case LCURLY: 4259 case LITERAL_default: 4260 case LT: 4261 case ENUM: 4262 case AT: 4263 case LITERAL_record: 4264 case LITERAL_yield: 4265 case LITERAL_sealed: 4266 case LITERAL_permits: 4267 case LITERAL_non: 4268 { 4269 enumConstantField(); 4270 astFactory.addASTChild(currentAST, returnAST); 4271 break; 4272 } 4273 case SEMI: 4274 { 4275 AST tmp76_AST = null; 4276 tmp76_AST = astFactory.create(LT(1)); 4277 astFactory.addASTChild(currentAST, tmp76_AST); 4278 match(SEMI); 4279 break; 4280 } 4281 default: 4282 { 4283 break _loop161; 4284 } 4285 } 4286 } while (true); 4287 } 4288 AST tmp77_AST = null; 4289 tmp77_AST = astFactory.create(LT(1)); 4290 astFactory.addASTChild(currentAST, tmp77_AST); 4291 match(RCURLY); 4292 if ( inputState.guessing==0 ) { 4293 enumConstantBlock_AST = (AST)currentAST.root; 4294 enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST)); 4295 currentAST.root = enumConstantBlock_AST; 4296 currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ? 4297 enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST; 4298 currentAST.advanceChildToEnd(); 4299 } 4300 enumConstantBlock_AST = (AST)currentAST.root; 4301 returnAST = enumConstantBlock_AST; 4302 } 4303 4304 public final void enumConstantField() throws RecognitionException, TokenStreamException { 4305 4306 returnAST = null; 4307 ASTPair currentAST = new ASTPair(); 4308 AST enumConstantField_AST = null; 4309 AST mods_AST = null; 4310 AST td_AST = null; 4311 AST tp_AST = null; 4312 AST t_AST = null; 4313 AST id_AST = null; 4314 AST param_AST = null; 4315 AST rt_AST = null; 4316 AST tc_AST = null; 4317 AST s2_AST = null; 4318 Token s3 = null; 4319 AST s3_AST = null; 4320 AST v_AST = null; 4321 Token s6 = null; 4322 AST s6_AST = null; 4323 AST s4_AST = null; 4324 4325 switch ( LA(1)) { 4326 case FINAL: 4327 case ABSTRACT: 4328 case STRICTFP: 4329 case LITERAL_void: 4330 case LITERAL_boolean: 4331 case LITERAL_byte: 4332 case LITERAL_char: 4333 case LITERAL_short: 4334 case LITERAL_int: 4335 case LITERAL_float: 4336 case LITERAL_long: 4337 case LITERAL_double: 4338 case IDENT: 4339 case LITERAL_private: 4340 case LITERAL_public: 4341 case LITERAL_protected: 4342 case LITERAL_static: 4343 case LITERAL_transient: 4344 case LITERAL_native: 4345 case LITERAL_synchronized: 4346 case LITERAL_volatile: 4347 case LITERAL_class: 4348 case LITERAL_interface: 4349 case LITERAL_default: 4350 case LT: 4351 case ENUM: 4352 case AT: 4353 case LITERAL_record: 4354 case LITERAL_yield: 4355 case LITERAL_sealed: 4356 case LITERAL_permits: 4357 case LITERAL_non: 4358 { 4359 modifiers(); 4360 mods_AST = (AST)returnAST; 4361 { 4362 if ((_tokenSet_34.member(LA(1))) && (_tokenSet_35.member(LA(2)))) { 4363 typeDefinitionInternal(mods_AST); 4364 td_AST = (AST)returnAST; 4365 if ( inputState.guessing==0 ) { 4366 enumConstantField_AST = (AST)currentAST.root; 4367 enumConstantField_AST = td_AST; 4368 currentAST.root = enumConstantField_AST; 4369 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 4370 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 4371 currentAST.advanceChildToEnd(); 4372 } 4373 } 4374 else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_30.member(LA(2)))) { 4375 { 4376 switch ( LA(1)) { 4377 case LT: 4378 { 4379 typeParameters(); 4380 tp_AST = (AST)returnAST; 4381 break; 4382 } 4383 case LITERAL_void: 4384 case LITERAL_boolean: 4385 case LITERAL_byte: 4386 case LITERAL_char: 4387 case LITERAL_short: 4388 case LITERAL_int: 4389 case LITERAL_float: 4390 case LITERAL_long: 4391 case LITERAL_double: 4392 case IDENT: 4393 case AT: 4394 case LITERAL_record: 4395 case LITERAL_yield: 4396 case LITERAL_sealed: 4397 case LITERAL_permits: 4398 case LITERAL_non: 4399 { 4400 break; 4401 } 4402 default: 4403 { 4404 throw new NoViableAltException(LT(1), getFilename()); 4405 } 4406 } 4407 } 4408 typeSpec(false); 4409 t_AST = (AST)returnAST; 4410 { 4411 if ((_tokenSet_0.member(LA(1))) && (LA(2)==LPAREN)) { 4412 id(); 4413 id_AST = (AST)returnAST; 4414 AST tmp78_AST = null; 4415 tmp78_AST = astFactory.create(LT(1)); 4416 match(LPAREN); 4417 parameterDeclarationList(); 4418 param_AST = (AST)returnAST; 4419 AST tmp79_AST = null; 4420 tmp79_AST = astFactory.create(LT(1)); 4421 match(RPAREN); 4422 typeSpecBracketsAndAnnotationsNonGreedy(); 4423 rt_AST = (AST)returnAST; 4424 { 4425 switch ( LA(1)) { 4426 case LITERAL_throws: 4427 { 4428 throwsClause(); 4429 tc_AST = (AST)returnAST; 4430 break; 4431 } 4432 case SEMI: 4433 case LCURLY: 4434 { 4435 break; 4436 } 4437 default: 4438 { 4439 throw new NoViableAltException(LT(1), getFilename()); 4440 } 4441 } 4442 } 4443 { 4444 switch ( LA(1)) { 4445 case LCURLY: 4446 { 4447 compoundStatement(); 4448 s2_AST = (AST)returnAST; 4449 break; 4450 } 4451 case SEMI: 4452 { 4453 s3 = LT(1); 4454 s3_AST = astFactory.create(s3); 4455 match(SEMI); 4456 break; 4457 } 4458 default: 4459 { 4460 throw new NoViableAltException(LT(1), getFilename()); 4461 } 4462 } 4463 } 4464 if ( inputState.guessing==0 ) { 4465 enumConstantField_AST = (AST)currentAST.root; 4466 enumConstantField_AST = (AST)astFactory.make( (new ASTArray(11)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add(tp_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(rt_AST))).add(id_AST).add(tmp78_AST).add(param_AST).add(tmp79_AST).add(tc_AST).add(s2_AST).add(s3_AST)); 4467 currentAST.root = enumConstantField_AST; 4468 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 4469 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 4470 currentAST.advanceChildToEnd(); 4471 } 4472 } 4473 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_47.member(LA(2)))) { 4474 variableDefinitions(mods_AST,t_AST); 4475 v_AST = (AST)returnAST; 4476 s6 = LT(1); 4477 s6_AST = astFactory.create(s6); 4478 match(SEMI); 4479 if ( inputState.guessing==0 ) { 4480 enumConstantField_AST = (AST)currentAST.root; 4481 4482 enumConstantField_AST = v_AST; 4483 v_AST.addChild(s6_AST); 4484 4485 currentAST.root = enumConstantField_AST; 4486 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 4487 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 4488 currentAST.advanceChildToEnd(); 4489 } 4490 } 4491 else { 4492 throw new NoViableAltException(LT(1), getFilename()); 4493 } 4494 4495 } 4496 } 4497 else { 4498 throw new NoViableAltException(LT(1), getFilename()); 4499 } 4500 4501 } 4502 break; 4503 } 4504 case LCURLY: 4505 { 4506 compoundStatement(); 4507 s4_AST = (AST)returnAST; 4508 if ( inputState.guessing==0 ) { 4509 enumConstantField_AST = (AST)currentAST.root; 4510 enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST)); 4511 currentAST.root = enumConstantField_AST; 4512 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 4513 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 4514 currentAST.advanceChildToEnd(); 4515 } 4516 break; 4517 } 4518 default: 4519 { 4520 throw new NoViableAltException(LT(1), getFilename()); 4521 } 4522 } 4523 returnAST = enumConstantField_AST; 4524 } 4525 4526 public final void parameterDeclarationList() throws RecognitionException, TokenStreamException { 4527 4528 returnAST = null; 4529 ASTPair currentAST = new ASTPair(); 4530 AST parameterDeclarationList_AST = null; 4531 4532 { 4533 boolean synPredMatched220 = false; 4534 if (((_tokenSet_48.member(LA(1))) && (_tokenSet_49.member(LA(2))))) { 4535 int _m220 = mark(); 4536 synPredMatched220 = true; 4537 inputState.guessing++; 4538 try { 4539 { 4540 parameterDeclaration(); 4541 } 4542 } 4543 catch (RecognitionException pe) { 4544 synPredMatched220 = false; 4545 } 4546 rewind(_m220); 4547inputState.guessing--; 4548 } 4549 if ( synPredMatched220 ) { 4550 parameterDeclaration(); 4551 astFactory.addASTChild(currentAST, returnAST); 4552 { 4553 _loop224: 4554 do { 4555 boolean synPredMatched223 = false; 4556 if (((LA(1)==COMMA) && (_tokenSet_48.member(LA(2))))) { 4557 int _m223 = mark(); 4558 synPredMatched223 = true; 4559 inputState.guessing++; 4560 try { 4561 { 4562 match(COMMA); 4563 parameterDeclaration(); 4564 } 4565 } 4566 catch (RecognitionException pe) { 4567 synPredMatched223 = false; 4568 } 4569 rewind(_m223); 4570inputState.guessing--; 4571 } 4572 if ( synPredMatched223 ) { 4573 AST tmp80_AST = null; 4574 tmp80_AST = astFactory.create(LT(1)); 4575 astFactory.addASTChild(currentAST, tmp80_AST); 4576 match(COMMA); 4577 parameterDeclaration(); 4578 astFactory.addASTChild(currentAST, returnAST); 4579 } 4580 else { 4581 break _loop224; 4582 } 4583 4584 } while (true); 4585 } 4586 { 4587 switch ( LA(1)) { 4588 case COMMA: 4589 { 4590 AST tmp81_AST = null; 4591 tmp81_AST = astFactory.create(LT(1)); 4592 astFactory.addASTChild(currentAST, tmp81_AST); 4593 match(COMMA); 4594 variableLengthParameterDeclaration(); 4595 astFactory.addASTChild(currentAST, returnAST); 4596 break; 4597 } 4598 case RPAREN: 4599 { 4600 break; 4601 } 4602 default: 4603 { 4604 throw new NoViableAltException(LT(1), getFilename()); 4605 } 4606 } 4607 } 4608 } 4609 else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) { 4610 variableLengthParameterDeclaration(); 4611 astFactory.addASTChild(currentAST, returnAST); 4612 } 4613 else if ((LA(1)==RPAREN)) { 4614 } 4615 else { 4616 throw new NoViableAltException(LT(1), getFilename()); 4617 } 4618 4619 } 4620 if ( inputState.guessing==0 ) { 4621 parameterDeclarationList_AST = (AST)currentAST.root; 4622 parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST)); 4623 currentAST.root = parameterDeclarationList_AST; 4624 currentAST.child = parameterDeclarationList_AST!=null &¶meterDeclarationList_AST.getFirstChild()!=null ? 4625 parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST; 4626 currentAST.advanceChildToEnd(); 4627 } 4628 parameterDeclarationList_AST = (AST)currentAST.root; 4629 returnAST = parameterDeclarationList_AST; 4630 } 4631 4632 public final void throwsClause() throws RecognitionException, TokenStreamException { 4633 4634 returnAST = null; 4635 ASTPair currentAST = new ASTPair(); 4636 AST throwsClause_AST = null; 4637 4638 AST tmp82_AST = null; 4639 tmp82_AST = astFactory.create(LT(1)); 4640 astFactory.makeASTRoot(currentAST, tmp82_AST); 4641 match(LITERAL_throws); 4642 { 4643 if (((_tokenSet_10.member(LA(1))) && (_tokenSet_52.member(LA(2))))&&(LA(1) == AT)) { 4644 annotations(); 4645 astFactory.addASTChild(currentAST, returnAST); 4646 } 4647 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_53.member(LA(2)))) { 4648 } 4649 else { 4650 throw new NoViableAltException(LT(1), getFilename()); 4651 } 4652 4653 } 4654 identifier(); 4655 astFactory.addASTChild(currentAST, returnAST); 4656 { 4657 _loop216: 4658 do { 4659 if ((LA(1)==COMMA)) { 4660 AST tmp83_AST = null; 4661 tmp83_AST = astFactory.create(LT(1)); 4662 astFactory.addASTChild(currentAST, tmp83_AST); 4663 match(COMMA); 4664 { 4665 if (((_tokenSet_10.member(LA(1))) && (_tokenSet_52.member(LA(2))))&&(LA(1) == AT)) { 4666 annotations(); 4667 astFactory.addASTChild(currentAST, returnAST); 4668 } 4669 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_53.member(LA(2)))) { 4670 } 4671 else { 4672 throw new NoViableAltException(LT(1), getFilename()); 4673 } 4674 4675 } 4676 identifier(); 4677 astFactory.addASTChild(currentAST, returnAST); 4678 } 4679 else { 4680 break _loop216; 4681 } 4682 4683 } while (true); 4684 } 4685 throwsClause_AST = (AST)currentAST.root; 4686 returnAST = throwsClause_AST; 4687 } 4688 4689 public final void compoundStatement() throws RecognitionException, TokenStreamException { 4690 4691 returnAST = null; 4692 ASTPair currentAST = new ASTPair(); 4693 AST compoundStatement_AST = null; 4694 Token lc = null; 4695 AST lc_AST = null; 4696 4697 lc = LT(1); 4698 lc_AST = astFactory.create(lc); 4699 astFactory.makeASTRoot(currentAST, lc_AST); 4700 match(LCURLY); 4701 if ( inputState.guessing==0 ) { 4702 lc_AST.setType(SLIST); 4703 } 4704 { 4705 _loop244: 4706 do { 4707 if ((_tokenSet_44.member(LA(1)))) { 4708 statement(); 4709 astFactory.addASTChild(currentAST, returnAST); 4710 } 4711 else { 4712 break _loop244; 4713 } 4714 4715 } while (true); 4716 } 4717 AST tmp84_AST = null; 4718 tmp84_AST = astFactory.create(LT(1)); 4719 astFactory.addASTChild(currentAST, tmp84_AST); 4720 match(RCURLY); 4721 compoundStatement_AST = (AST)currentAST.root; 4722 returnAST = compoundStatement_AST; 4723 } 4724 4725 public final void ctorHead() throws RecognitionException, TokenStreamException { 4726 4727 returnAST = null; 4728 ASTPair currentAST = new ASTPair(); 4729 AST ctorHead_AST = null; 4730 4731 id(); 4732 astFactory.addASTChild(currentAST, returnAST); 4733 AST tmp85_AST = null; 4734 tmp85_AST = astFactory.create(LT(1)); 4735 astFactory.addASTChild(currentAST, tmp85_AST); 4736 match(LPAREN); 4737 parameterDeclarationList(); 4738 astFactory.addASTChild(currentAST, returnAST); 4739 AST tmp86_AST = null; 4740 tmp86_AST = astFactory.create(LT(1)); 4741 astFactory.addASTChild(currentAST, tmp86_AST); 4742 match(RPAREN); 4743 { 4744 switch ( LA(1)) { 4745 case LITERAL_throws: 4746 { 4747 throwsClause(); 4748 astFactory.addASTChild(currentAST, returnAST); 4749 break; 4750 } 4751 case LCURLY: 4752 { 4753 break; 4754 } 4755 default: 4756 { 4757 throw new NoViableAltException(LT(1), getFilename()); 4758 } 4759 } 4760 } 4761 ctorHead_AST = (AST)currentAST.root; 4762 returnAST = ctorHead_AST; 4763 } 4764 4765 public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException { 4766 4767 returnAST = null; 4768 ASTPair currentAST = new ASTPair(); 4769 AST explicitConstructorInvocation_AST = null; 4770 Token t = null; 4771 AST t_AST = null; 4772 Token s = null; 4773 AST s_AST = null; 4774 Token s1 = null; 4775 AST s1_AST = null; 4776 4777 { 4778 if ((_tokenSet_54.member(LA(1))) && (_tokenSet_55.member(LA(2)))) { 4779 { 4780 switch ( LA(1)) { 4781 case LT: 4782 { 4783 typeArguments(false); 4784 astFactory.addASTChild(currentAST, returnAST); 4785 break; 4786 } 4787 case LITERAL_this: 4788 case LITERAL_super: 4789 { 4790 break; 4791 } 4792 default: 4793 { 4794 throw new NoViableAltException(LT(1), getFilename()); 4795 } 4796 } 4797 } 4798 { 4799 switch ( LA(1)) { 4800 case LITERAL_this: 4801 { 4802 t = LT(1); 4803 t_AST = astFactory.create(t); 4804 astFactory.makeASTRoot(currentAST, t_AST); 4805 match(LITERAL_this); 4806 AST tmp87_AST = null; 4807 tmp87_AST = astFactory.create(LT(1)); 4808 astFactory.addASTChild(currentAST, tmp87_AST); 4809 match(LPAREN); 4810 argList(); 4811 astFactory.addASTChild(currentAST, returnAST); 4812 AST tmp88_AST = null; 4813 tmp88_AST = astFactory.create(LT(1)); 4814 astFactory.addASTChild(currentAST, tmp88_AST); 4815 match(RPAREN); 4816 AST tmp89_AST = null; 4817 tmp89_AST = astFactory.create(LT(1)); 4818 astFactory.addASTChild(currentAST, tmp89_AST); 4819 match(SEMI); 4820 if ( inputState.guessing==0 ) { 4821 t_AST.setType(CTOR_CALL); 4822 } 4823 break; 4824 } 4825 case LITERAL_super: 4826 { 4827 s = LT(1); 4828 s_AST = astFactory.create(s); 4829 astFactory.makeASTRoot(currentAST, s_AST); 4830 match(LITERAL_super); 4831 AST tmp90_AST = null; 4832 tmp90_AST = astFactory.create(LT(1)); 4833 astFactory.addASTChild(currentAST, tmp90_AST); 4834 match(LPAREN); 4835 argList(); 4836 astFactory.addASTChild(currentAST, returnAST); 4837 AST tmp91_AST = null; 4838 tmp91_AST = astFactory.create(LT(1)); 4839 astFactory.addASTChild(currentAST, tmp91_AST); 4840 match(RPAREN); 4841 AST tmp92_AST = null; 4842 tmp92_AST = astFactory.create(LT(1)); 4843 astFactory.addASTChild(currentAST, tmp92_AST); 4844 match(SEMI); 4845 if ( inputState.guessing==0 ) { 4846 s_AST.setType(SUPER_CTOR_CALL); 4847 } 4848 break; 4849 } 4850 default: 4851 { 4852 throw new NoViableAltException(LT(1), getFilename()); 4853 } 4854 } 4855 } 4856 } 4857 else if ((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2)))) { 4858 primaryExpression(); 4859 astFactory.addASTChild(currentAST, returnAST); 4860 AST tmp93_AST = null; 4861 tmp93_AST = astFactory.create(LT(1)); 4862 astFactory.addASTChild(currentAST, tmp93_AST); 4863 match(DOT); 4864 { 4865 switch ( LA(1)) { 4866 case LT: 4867 { 4868 typeArguments(false); 4869 astFactory.addASTChild(currentAST, returnAST); 4870 break; 4871 } 4872 case LITERAL_super: 4873 { 4874 break; 4875 } 4876 default: 4877 { 4878 throw new NoViableAltException(LT(1), getFilename()); 4879 } 4880 } 4881 } 4882 s1 = LT(1); 4883 s1_AST = astFactory.create(s1); 4884 astFactory.makeASTRoot(currentAST, s1_AST); 4885 match(LITERAL_super); 4886 AST tmp94_AST = null; 4887 tmp94_AST = astFactory.create(LT(1)); 4888 astFactory.addASTChild(currentAST, tmp94_AST); 4889 match(LPAREN); 4890 argList(); 4891 astFactory.addASTChild(currentAST, returnAST); 4892 AST tmp95_AST = null; 4893 tmp95_AST = astFactory.create(LT(1)); 4894 astFactory.addASTChild(currentAST, tmp95_AST); 4895 match(RPAREN); 4896 AST tmp96_AST = null; 4897 tmp96_AST = astFactory.create(LT(1)); 4898 astFactory.addASTChild(currentAST, tmp96_AST); 4899 match(SEMI); 4900 if ( inputState.guessing==0 ) { 4901 s1_AST.setType(SUPER_CTOR_CALL); 4902 } 4903 } 4904 else { 4905 throw new NoViableAltException(LT(1), getFilename()); 4906 } 4907 4908 } 4909 explicitConstructorInvocation_AST = (AST)currentAST.root; 4910 returnAST = explicitConstructorInvocation_AST; 4911 } 4912 4913 public final void statement() throws RecognitionException, TokenStreamException { 4914 4915 returnAST = null; 4916 ASTPair currentAST = new ASTPair(); 4917 AST statement_AST = null; 4918 4919 switch ( LA(1)) { 4920 case FINAL: 4921 case ABSTRACT: 4922 case STRICTFP: 4923 case SEMI: 4924 case LITERAL_void: 4925 case LITERAL_boolean: 4926 case LITERAL_byte: 4927 case LITERAL_char: 4928 case LITERAL_short: 4929 case LITERAL_int: 4930 case LITERAL_float: 4931 case LITERAL_long: 4932 case LITERAL_double: 4933 case IDENT: 4934 case LITERAL_private: 4935 case LITERAL_public: 4936 case LITERAL_protected: 4937 case LITERAL_static: 4938 case LITERAL_transient: 4939 case LITERAL_native: 4940 case LITERAL_synchronized: 4941 case LITERAL_volatile: 4942 case LITERAL_class: 4943 case LCURLY: 4944 case LPAREN: 4945 case LITERAL_this: 4946 case LITERAL_super: 4947 case LITERAL_if: 4948 case LITERAL_while: 4949 case LITERAL_do: 4950 case LITERAL_break: 4951 case LITERAL_continue: 4952 case LITERAL_return: 4953 case LITERAL_switch: 4954 case LITERAL_throw: 4955 case LITERAL_for: 4956 case LITERAL_default: 4957 case LITERAL_try: 4958 case PLUS: 4959 case MINUS: 4960 case INC: 4961 case DEC: 4962 case BNOT: 4963 case LNOT: 4964 case LITERAL_true: 4965 case LITERAL_false: 4966 case LITERAL_null: 4967 case LITERAL_new: 4968 case NUM_INT: 4969 case CHAR_LITERAL: 4970 case STRING_LITERAL: 4971 case NUM_FLOAT: 4972 case NUM_LONG: 4973 case NUM_DOUBLE: 4974 case AT: 4975 case LITERAL_record: 4976 case TEXT_BLOCK_CONTENT: 4977 case LITERAL_yield: 4978 case LITERAL_sealed: 4979 case LITERAL_permits: 4980 case LITERAL_non: 4981 { 4982 traditionalStatement(); 4983 astFactory.addASTChild(currentAST, returnAST); 4984 statement_AST = (AST)currentAST.root; 4985 break; 4986 } 4987 case ASSERT: 4988 { 4989 assertStatement(); 4990 astFactory.addASTChild(currentAST, returnAST); 4991 statement_AST = (AST)currentAST.root; 4992 break; 4993 } 4994 default: 4995 { 4996 throw new NoViableAltException(LT(1), getFilename()); 4997 } 4998 } 4999 returnAST = statement_AST; 5000 } 5001 5002 public final void primaryExpression() throws RecognitionException, TokenStreamException { 5003 5004 returnAST = null; 5005 ASTPair currentAST = new ASTPair(); 5006 AST primaryExpression_AST = null; 5007 5008 switch ( LA(1)) { 5009 case NUM_INT: 5010 case CHAR_LITERAL: 5011 case STRING_LITERAL: 5012 case NUM_FLOAT: 5013 case NUM_LONG: 5014 case NUM_DOUBLE: 5015 case TEXT_BLOCK_CONTENT: 5016 { 5017 constant(); 5018 astFactory.addASTChild(currentAST, returnAST); 5019 primaryExpression_AST = (AST)currentAST.root; 5020 break; 5021 } 5022 case LITERAL_true: 5023 { 5024 AST tmp97_AST = null; 5025 tmp97_AST = astFactory.create(LT(1)); 5026 astFactory.addASTChild(currentAST, tmp97_AST); 5027 match(LITERAL_true); 5028 primaryExpression_AST = (AST)currentAST.root; 5029 break; 5030 } 5031 case LITERAL_false: 5032 { 5033 AST tmp98_AST = null; 5034 tmp98_AST = astFactory.create(LT(1)); 5035 astFactory.addASTChild(currentAST, tmp98_AST); 5036 match(LITERAL_false); 5037 primaryExpression_AST = (AST)currentAST.root; 5038 break; 5039 } 5040 case LITERAL_this: 5041 { 5042 AST tmp99_AST = null; 5043 tmp99_AST = astFactory.create(LT(1)); 5044 astFactory.addASTChild(currentAST, tmp99_AST); 5045 match(LITERAL_this); 5046 primaryExpression_AST = (AST)currentAST.root; 5047 break; 5048 } 5049 case LITERAL_null: 5050 { 5051 AST tmp100_AST = null; 5052 tmp100_AST = astFactory.create(LT(1)); 5053 astFactory.addASTChild(currentAST, tmp100_AST); 5054 match(LITERAL_null); 5055 primaryExpression_AST = (AST)currentAST.root; 5056 break; 5057 } 5058 case LITERAL_new: 5059 { 5060 newExpression(); 5061 astFactory.addASTChild(currentAST, returnAST); 5062 primaryExpression_AST = (AST)currentAST.root; 5063 break; 5064 } 5065 case LPAREN: 5066 { 5067 AST tmp101_AST = null; 5068 tmp101_AST = astFactory.create(LT(1)); 5069 astFactory.addASTChild(currentAST, tmp101_AST); 5070 match(LPAREN); 5071 { 5072 boolean synPredMatched436 = false; 5073 if (((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2))))) { 5074 int _m436 = mark(); 5075 synPredMatched436 = true; 5076 inputState.guessing++; 5077 try { 5078 { 5079 lambdaExpression(); 5080 } 5081 } 5082 catch (RecognitionException pe) { 5083 synPredMatched436 = false; 5084 } 5085 rewind(_m436); 5086inputState.guessing--; 5087 } 5088 if ( synPredMatched436 ) { 5089 lambdaExpression(); 5090 astFactory.addASTChild(currentAST, returnAST); 5091 } 5092 else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_58.member(LA(2)))) { 5093 assignmentExpression(); 5094 astFactory.addASTChild(currentAST, returnAST); 5095 } 5096 else { 5097 throw new NoViableAltException(LT(1), getFilename()); 5098 } 5099 5100 } 5101 AST tmp102_AST = null; 5102 tmp102_AST = astFactory.create(LT(1)); 5103 astFactory.addASTChild(currentAST, tmp102_AST); 5104 match(RPAREN); 5105 primaryExpression_AST = (AST)currentAST.root; 5106 break; 5107 } 5108 case LITERAL_super: 5109 { 5110 AST tmp103_AST = null; 5111 tmp103_AST = astFactory.create(LT(1)); 5112 astFactory.addASTChild(currentAST, tmp103_AST); 5113 match(LITERAL_super); 5114 primaryExpression_AST = (AST)currentAST.root; 5115 break; 5116 } 5117 default: 5118 boolean synPredMatched433 = false; 5119 if (((_tokenSet_15.member(LA(1))) && (_tokenSet_59.member(LA(2))))) { 5120 int _m433 = mark(); 5121 synPredMatched433 = true; 5122 inputState.guessing++; 5123 try { 5124 { 5125 typeSpec(false); 5126 match(DOUBLE_COLON); 5127 } 5128 } 5129 catch (RecognitionException pe) { 5130 synPredMatched433 = false; 5131 } 5132 rewind(_m433); 5133inputState.guessing--; 5134 } 5135 if ( synPredMatched433 ) { 5136 typeSpec(false); 5137 astFactory.addASTChild(currentAST, returnAST); 5138 primaryExpression_AST = (AST)currentAST.root; 5139 } 5140 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_59.member(LA(2)))) { 5141 id(); 5142 astFactory.addASTChild(currentAST, returnAST); 5143 primaryExpression_AST = (AST)currentAST.root; 5144 } 5145 else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_double)) && (_tokenSet_59.member(LA(2)))) { 5146 builtInType(); 5147 astFactory.addASTChild(currentAST, returnAST); 5148 { 5149 _loop438: 5150 do { 5151 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 5152 brackets(); 5153 astFactory.addASTChild(currentAST, returnAST); 5154 } 5155 else { 5156 break _loop438; 5157 } 5158 5159 } while (true); 5160 } 5161 { 5162 if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) { 5163 AST tmp104_AST = null; 5164 tmp104_AST = astFactory.create(LT(1)); 5165 astFactory.makeASTRoot(currentAST, tmp104_AST); 5166 match(DOT); 5167 AST tmp105_AST = null; 5168 tmp105_AST = astFactory.create(LT(1)); 5169 astFactory.addASTChild(currentAST, tmp105_AST); 5170 match(LITERAL_class); 5171 } 5172 else if ((_tokenSet_59.member(LA(1))) && (_tokenSet_60.member(LA(2)))) { 5173 } 5174 else { 5175 throw new NoViableAltException(LT(1), getFilename()); 5176 } 5177 5178 } 5179 primaryExpression_AST = (AST)currentAST.root; 5180 } 5181 else { 5182 throw new NoViableAltException(LT(1), getFilename()); 5183 } 5184 } 5185 returnAST = primaryExpression_AST; 5186 } 5187 5188/** Declaration of a variable. This can be a class/instance variable, 5189 * or a local variable in a method. 5190 @param mods declaration mods. 5191 @param t variable declaration type. 5192 @throws RecognitionException if recognition problem occurs. 5193 @throws TokenStreamException if problem occurs while generating a stream of tokens. 5194 * It can also include possible initialization. 5195 */ 5196 public final void variableDeclarator( 5197 AST mods, AST t 5198 ) throws RecognitionException, TokenStreamException { 5199 5200 returnAST = null; 5201 ASTPair currentAST = new ASTPair(); 5202 AST variableDeclarator_AST = null; 5203 AST id_AST = null; 5204 AST d_AST = null; 5205 AST v_AST = null; 5206 5207 id(); 5208 id_AST = (AST)returnAST; 5209 typeSpecBracketsAndAnnotationsNonGreedy(); 5210 d_AST = (AST)returnAST; 5211 varInitializer(); 5212 v_AST = (AST)returnAST; 5213 if ( inputState.guessing==0 ) { 5214 variableDeclarator_AST = (AST)currentAST.root; 5215 variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t).add(d_AST))).add(id_AST).add(v_AST)); 5216 currentAST.root = variableDeclarator_AST; 5217 currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ? 5218 variableDeclarator_AST.getFirstChild() : variableDeclarator_AST; 5219 currentAST.advanceChildToEnd(); 5220 } 5221 returnAST = variableDeclarator_AST; 5222 } 5223 5224 public final void varInitializer() throws RecognitionException, TokenStreamException { 5225 5226 returnAST = null; 5227 ASTPair currentAST = new ASTPair(); 5228 AST varInitializer_AST = null; 5229 5230 { 5231 switch ( LA(1)) { 5232 case ASSIGN: 5233 { 5234 AST tmp106_AST = null; 5235 tmp106_AST = astFactory.create(LT(1)); 5236 astFactory.makeASTRoot(currentAST, tmp106_AST); 5237 match(ASSIGN); 5238 initializer(); 5239 astFactory.addASTChild(currentAST, returnAST); 5240 break; 5241 } 5242 case FINAL: 5243 case ABSTRACT: 5244 case STRICTFP: 5245 case SEMI: 5246 case LITERAL_void: 5247 case LITERAL_boolean: 5248 case LITERAL_byte: 5249 case LITERAL_char: 5250 case LITERAL_short: 5251 case LITERAL_int: 5252 case LITERAL_float: 5253 case LITERAL_long: 5254 case LITERAL_double: 5255 case IDENT: 5256 case LITERAL_private: 5257 case LITERAL_public: 5258 case LITERAL_protected: 5259 case LITERAL_static: 5260 case LITERAL_transient: 5261 case LITERAL_native: 5262 case LITERAL_synchronized: 5263 case LITERAL_volatile: 5264 case LITERAL_class: 5265 case LITERAL_interface: 5266 case LCURLY: 5267 case RCURLY: 5268 case COMMA: 5269 case RPAREN: 5270 case LITERAL_default: 5271 case LT: 5272 case ENUM: 5273 case AT: 5274 case LITERAL_record: 5275 case LITERAL_yield: 5276 case LITERAL_sealed: 5277 case LITERAL_permits: 5278 case LITERAL_non: 5279 { 5280 break; 5281 } 5282 default: 5283 { 5284 throw new NoViableAltException(LT(1), getFilename()); 5285 } 5286 } 5287 } 5288 varInitializer_AST = (AST)currentAST.root; 5289 returnAST = varInitializer_AST; 5290 } 5291 5292 public final void initializer() throws RecognitionException, TokenStreamException { 5293 5294 returnAST = null; 5295 ASTPair currentAST = new ASTPair(); 5296 AST initializer_AST = null; 5297 5298 switch ( LA(1)) { 5299 case LITERAL_void: 5300 case LITERAL_boolean: 5301 case LITERAL_byte: 5302 case LITERAL_char: 5303 case LITERAL_short: 5304 case LITERAL_int: 5305 case LITERAL_float: 5306 case LITERAL_long: 5307 case LITERAL_double: 5308 case IDENT: 5309 case LPAREN: 5310 case LITERAL_this: 5311 case LITERAL_super: 5312 case LITERAL_switch: 5313 case PLUS: 5314 case MINUS: 5315 case INC: 5316 case DEC: 5317 case BNOT: 5318 case LNOT: 5319 case LITERAL_true: 5320 case LITERAL_false: 5321 case LITERAL_null: 5322 case LITERAL_new: 5323 case NUM_INT: 5324 case CHAR_LITERAL: 5325 case STRING_LITERAL: 5326 case NUM_FLOAT: 5327 case NUM_LONG: 5328 case NUM_DOUBLE: 5329 case AT: 5330 case LITERAL_record: 5331 case TEXT_BLOCK_CONTENT: 5332 case LITERAL_yield: 5333 case LITERAL_sealed: 5334 case LITERAL_permits: 5335 case LITERAL_non: 5336 { 5337 expression(); 5338 astFactory.addASTChild(currentAST, returnAST); 5339 initializer_AST = (AST)currentAST.root; 5340 break; 5341 } 5342 case LCURLY: 5343 { 5344 arrayInitializer(); 5345 astFactory.addASTChild(currentAST, returnAST); 5346 initializer_AST = (AST)currentAST.root; 5347 break; 5348 } 5349 default: 5350 { 5351 throw new NoViableAltException(LT(1), getFilename()); 5352 } 5353 } 5354 returnAST = initializer_AST; 5355 } 5356 5357 public final void arrayInitializer() throws RecognitionException, TokenStreamException { 5358 5359 returnAST = null; 5360 ASTPair currentAST = new ASTPair(); 5361 AST arrayInitializer_AST = null; 5362 Token lc = null; 5363 AST lc_AST = null; 5364 5365 lc = LT(1); 5366 lc_AST = astFactory.create(lc); 5367 astFactory.makeASTRoot(currentAST, lc_AST); 5368 match(LCURLY); 5369 if ( inputState.guessing==0 ) { 5370 lc_AST.setType(ARRAY_INIT); 5371 } 5372 { 5373 switch ( LA(1)) { 5374 case LITERAL_void: 5375 case LITERAL_boolean: 5376 case LITERAL_byte: 5377 case LITERAL_char: 5378 case LITERAL_short: 5379 case LITERAL_int: 5380 case LITERAL_float: 5381 case LITERAL_long: 5382 case LITERAL_double: 5383 case IDENT: 5384 case LCURLY: 5385 case LPAREN: 5386 case LITERAL_this: 5387 case LITERAL_super: 5388 case LITERAL_switch: 5389 case PLUS: 5390 case MINUS: 5391 case INC: 5392 case DEC: 5393 case BNOT: 5394 case LNOT: 5395 case LITERAL_true: 5396 case LITERAL_false: 5397 case LITERAL_null: 5398 case LITERAL_new: 5399 case NUM_INT: 5400 case CHAR_LITERAL: 5401 case STRING_LITERAL: 5402 case NUM_FLOAT: 5403 case NUM_LONG: 5404 case NUM_DOUBLE: 5405 case AT: 5406 case LITERAL_record: 5407 case TEXT_BLOCK_CONTENT: 5408 case LITERAL_yield: 5409 case LITERAL_sealed: 5410 case LITERAL_permits: 5411 case LITERAL_non: 5412 { 5413 initializer(); 5414 astFactory.addASTChild(currentAST, returnAST); 5415 { 5416 _loop207: 5417 do { 5418 if ((LA(1)==COMMA) && (_tokenSet_17.member(LA(2)))) { 5419 AST tmp107_AST = null; 5420 tmp107_AST = astFactory.create(LT(1)); 5421 astFactory.addASTChild(currentAST, tmp107_AST); 5422 match(COMMA); 5423 initializer(); 5424 astFactory.addASTChild(currentAST, returnAST); 5425 } 5426 else { 5427 break _loop207; 5428 } 5429 5430 } while (true); 5431 } 5432 break; 5433 } 5434 case RCURLY: 5435 case COMMA: 5436 { 5437 break; 5438 } 5439 default: 5440 { 5441 throw new NoViableAltException(LT(1), getFilename()); 5442 } 5443 } 5444 } 5445 { 5446 switch ( LA(1)) { 5447 case COMMA: 5448 { 5449 AST tmp108_AST = null; 5450 tmp108_AST = astFactory.create(LT(1)); 5451 astFactory.addASTChild(currentAST, tmp108_AST); 5452 match(COMMA); 5453 break; 5454 } 5455 case RCURLY: 5456 { 5457 break; 5458 } 5459 default: 5460 { 5461 throw new NoViableAltException(LT(1), getFilename()); 5462 } 5463 } 5464 } 5465 AST tmp109_AST = null; 5466 tmp109_AST = astFactory.create(LT(1)); 5467 astFactory.addASTChild(currentAST, tmp109_AST); 5468 match(RCURLY); 5469 arrayInitializer_AST = (AST)currentAST.root; 5470 returnAST = arrayInitializer_AST; 5471 } 5472 5473 public final void expression() throws RecognitionException, TokenStreamException { 5474 5475 returnAST = null; 5476 ASTPair currentAST = new ASTPair(); 5477 AST expression_AST = null; 5478 5479 boolean synPredMatched343 = false; 5480 if (((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2))))) { 5481 int _m343 = mark(); 5482 synPredMatched343 = true; 5483 inputState.guessing++; 5484 try { 5485 { 5486 lambdaExpression(); 5487 } 5488 } 5489 catch (RecognitionException pe) { 5490 synPredMatched343 = false; 5491 } 5492 rewind(_m343); 5493inputState.guessing--; 5494 } 5495 if ( synPredMatched343 ) { 5496 lambdaExpression(); 5497 astFactory.addASTChild(currentAST, returnAST); 5498 expression_AST = (AST)currentAST.root; 5499 } 5500 else if (((_tokenSet_19.member(LA(1))) && (_tokenSet_61.member(LA(2))))&&(LA(1)!=RPAREN)) { 5501 assignmentExpression(); 5502 astFactory.addASTChild(currentAST, returnAST); 5503 if ( inputState.guessing==0 ) { 5504 expression_AST = (AST)currentAST.root; 5505 expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST)); 5506 currentAST.root = expression_AST; 5507 currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ? 5508 expression_AST.getFirstChild() : expression_AST; 5509 currentAST.advanceChildToEnd(); 5510 } 5511 expression_AST = (AST)currentAST.root; 5512 } 5513 else { 5514 throw new NoViableAltException(LT(1), getFilename()); 5515 } 5516 5517 returnAST = expression_AST; 5518 } 5519 5520 public final void parameterDeclaration() throws RecognitionException, TokenStreamException { 5521 5522 returnAST = null; 5523 ASTPair currentAST = new ASTPair(); 5524 AST parameterDeclaration_AST = null; 5525 AST pm_AST = null; 5526 AST t_AST = null; 5527 AST id_AST = null; 5528 AST pd_AST = null; 5529 5530 parameterModifier(); 5531 pm_AST = (AST)returnAST; 5532 { 5533 if ((_tokenSet_15.member(LA(1))) && (_tokenSet_62.member(LA(2)))) { 5534 typeSpec(false); 5535 t_AST = (AST)returnAST; 5536 } 5537 else if ((_tokenSet_63.member(LA(1))) && (_tokenSet_64.member(LA(2)))) { 5538 } 5539 else { 5540 throw new NoViableAltException(LT(1), getFilename()); 5541 } 5542 5543 } 5544 parameterIdent(); 5545 id_AST = (AST)returnAST; 5546 typeSpecBracketsAndAnnotationsNonGreedy(); 5547 pd_AST = (AST)returnAST; 5548 if ( inputState.guessing==0 ) { 5549 parameterDeclaration_AST = (AST)currentAST.root; 5550 parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(pd_AST))).add(id_AST)); 5551 currentAST.root = parameterDeclaration_AST; 5552 currentAST.child = parameterDeclaration_AST!=null &¶meterDeclaration_AST.getFirstChild()!=null ? 5553 parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST; 5554 currentAST.advanceChildToEnd(); 5555 } 5556 returnAST = parameterDeclaration_AST; 5557 } 5558 5559 public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException { 5560 5561 returnAST = null; 5562 ASTPair currentAST = new ASTPair(); 5563 AST variableLengthParameterDeclaration_AST = null; 5564 AST pm_AST = null; 5565 AST t_AST = null; 5566 Token td = null; 5567 AST td_AST = null; 5568 AST id_AST = null; 5569 AST pd_AST = null; 5570 5571 parameterModifier(); 5572 pm_AST = (AST)returnAST; 5573 variableLengthParameterTypeSpec(); 5574 t_AST = (AST)returnAST; 5575 td = LT(1); 5576 td_AST = astFactory.create(td); 5577 match(ELLIPSIS); 5578 id(); 5579 id_AST = (AST)returnAST; 5580 typeSpecBracketsAndAnnotationsNonGreedy(); 5581 pd_AST = (AST)returnAST; 5582 if ( inputState.guessing==0 ) { 5583 variableLengthParameterDeclaration_AST = (AST)currentAST.root; 5584 variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(pd_AST))).add(td_AST).add(id_AST)); 5585 currentAST.root = variableLengthParameterDeclaration_AST; 5586 currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ? 5587 variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST; 5588 currentAST.advanceChildToEnd(); 5589 } 5590 returnAST = variableLengthParameterDeclaration_AST; 5591 } 5592 5593 public final void parameterModifier() throws RecognitionException, TokenStreamException { 5594 5595 returnAST = null; 5596 ASTPair currentAST = new ASTPair(); 5597 AST parameterModifier_AST = null; 5598 Token f = null; 5599 AST f_AST = null; 5600 5601 { 5602 _loop229: 5603 do { 5604 if ((LA(1)==AT) && (_tokenSet_0.member(LA(2)))) { 5605 annotation(); 5606 astFactory.addASTChild(currentAST, returnAST); 5607 } 5608 else { 5609 break _loop229; 5610 } 5611 5612 } while (true); 5613 } 5614 { 5615 switch ( LA(1)) { 5616 case FINAL: 5617 { 5618 f = LT(1); 5619 f_AST = astFactory.create(f); 5620 astFactory.addASTChild(currentAST, f_AST); 5621 match(FINAL); 5622 break; 5623 } 5624 case LITERAL_void: 5625 case LITERAL_boolean: 5626 case LITERAL_byte: 5627 case LITERAL_char: 5628 case LITERAL_short: 5629 case LITERAL_int: 5630 case LITERAL_float: 5631 case LITERAL_long: 5632 case LITERAL_double: 5633 case IDENT: 5634 case LITERAL_this: 5635 case AT: 5636 case LITERAL_record: 5637 case LITERAL_yield: 5638 case LITERAL_sealed: 5639 case LITERAL_permits: 5640 case LITERAL_non: 5641 { 5642 break; 5643 } 5644 default: 5645 { 5646 throw new NoViableAltException(LT(1), getFilename()); 5647 } 5648 } 5649 } 5650 { 5651 _loop232: 5652 do { 5653 if ((LA(1)==AT) && (_tokenSet_0.member(LA(2)))) { 5654 annotation(); 5655 astFactory.addASTChild(currentAST, returnAST); 5656 } 5657 else { 5658 break _loop232; 5659 } 5660 5661 } while (true); 5662 } 5663 if ( inputState.guessing==0 ) { 5664 parameterModifier_AST = (AST)currentAST.root; 5665 parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(parameterModifier_AST)); 5666 currentAST.root = parameterModifier_AST; 5667 currentAST.child = parameterModifier_AST!=null &¶meterModifier_AST.getFirstChild()!=null ? 5668 parameterModifier_AST.getFirstChild() : parameterModifier_AST; 5669 currentAST.advanceChildToEnd(); 5670 } 5671 parameterModifier_AST = (AST)currentAST.root; 5672 returnAST = parameterModifier_AST; 5673 } 5674 5675 public final void parameterIdent() throws RecognitionException, TokenStreamException { 5676 5677 returnAST = null; 5678 ASTPair currentAST = new ASTPair(); 5679 AST parameterIdent_AST = null; 5680 5681 switch ( LA(1)) { 5682 case LITERAL_this: 5683 { 5684 AST tmp110_AST = null; 5685 tmp110_AST = astFactory.create(LT(1)); 5686 astFactory.addASTChild(currentAST, tmp110_AST); 5687 match(LITERAL_this); 5688 parameterIdent_AST = (AST)currentAST.root; 5689 break; 5690 } 5691 case IDENT: 5692 case LITERAL_record: 5693 case LITERAL_yield: 5694 case LITERAL_sealed: 5695 case LITERAL_permits: 5696 case LITERAL_non: 5697 { 5698 { 5699 id(); 5700 astFactory.addASTChild(currentAST, returnAST); 5701 { 5702 switch ( LA(1)) { 5703 case DOT: 5704 { 5705 AST tmp111_AST = null; 5706 tmp111_AST = astFactory.create(LT(1)); 5707 astFactory.makeASTRoot(currentAST, tmp111_AST); 5708 match(DOT); 5709 AST tmp112_AST = null; 5710 tmp112_AST = astFactory.create(LT(1)); 5711 astFactory.addASTChild(currentAST, tmp112_AST); 5712 match(LITERAL_this); 5713 break; 5714 } 5715 case LBRACK: 5716 case COMMA: 5717 case RPAREN: 5718 case AT: 5719 { 5720 break; 5721 } 5722 default: 5723 { 5724 throw new NoViableAltException(LT(1), getFilename()); 5725 } 5726 } 5727 } 5728 } 5729 parameterIdent_AST = (AST)currentAST.root; 5730 break; 5731 } 5732 default: 5733 { 5734 throw new NoViableAltException(LT(1), getFilename()); 5735 } 5736 } 5737 returnAST = parameterIdent_AST; 5738 } 5739 5740 public final void catchParameterDeclaration() throws RecognitionException, TokenStreamException { 5741 5742 returnAST = null; 5743 ASTPair currentAST = new ASTPair(); 5744 AST catchParameterDeclaration_AST = null; 5745 AST pm_AST = null; 5746 AST mct_AST = null; 5747 AST id_AST = null; 5748 5749 parameterModifier(); 5750 pm_AST = (AST)returnAST; 5751 multiCatchTypes(); 5752 mct_AST = (AST)returnAST; 5753 id(); 5754 id_AST = (AST)returnAST; 5755 if ( inputState.guessing==0 ) { 5756 catchParameterDeclaration_AST = (AST)currentAST.root; 5757 catchParameterDeclaration_AST = 5758 (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(mct_AST))).add(id_AST)); 5759 currentAST.root = catchParameterDeclaration_AST; 5760 currentAST.child = catchParameterDeclaration_AST!=null &&catchParameterDeclaration_AST.getFirstChild()!=null ? 5761 catchParameterDeclaration_AST.getFirstChild() : catchParameterDeclaration_AST; 5762 currentAST.advanceChildToEnd(); 5763 } 5764 returnAST = catchParameterDeclaration_AST; 5765 } 5766 5767 public final void multiCatchTypes() throws RecognitionException, TokenStreamException { 5768 5769 returnAST = null; 5770 ASTPair currentAST = new ASTPair(); 5771 AST multiCatchTypes_AST = null; 5772 5773 typeSpec(false); 5774 astFactory.addASTChild(currentAST, returnAST); 5775 { 5776 _loop241: 5777 do { 5778 if ((LA(1)==BOR)) { 5779 AST tmp113_AST = null; 5780 tmp113_AST = astFactory.create(LT(1)); 5781 astFactory.makeASTRoot(currentAST, tmp113_AST); 5782 match(BOR); 5783 typeSpec(false); 5784 astFactory.addASTChild(currentAST, returnAST); 5785 } 5786 else { 5787 break _loop241; 5788 } 5789 5790 } while (true); 5791 } 5792 multiCatchTypes_AST = (AST)currentAST.root; 5793 returnAST = multiCatchTypes_AST; 5794 } 5795 5796 public final void traditionalStatement() throws RecognitionException, TokenStreamException { 5797 5798 returnAST = null; 5799 ASTPair currentAST = new ASTPair(); 5800 AST traditionalStatement_AST = null; 5801 AST a_AST = null; 5802 AST m_AST = null; 5803 Token c = null; 5804 AST c_AST = null; 5805 Token w = null; 5806 AST w_AST = null; 5807 Token s = null; 5808 AST s_AST = null; 5809 5810 switch ( LA(1)) { 5811 case LCURLY: 5812 { 5813 compoundStatement(); 5814 astFactory.addASTChild(currentAST, returnAST); 5815 traditionalStatement_AST = (AST)currentAST.root; 5816 break; 5817 } 5818 case LITERAL_if: 5819 { 5820 AST tmp114_AST = null; 5821 tmp114_AST = astFactory.create(LT(1)); 5822 astFactory.makeASTRoot(currentAST, tmp114_AST); 5823 match(LITERAL_if); 5824 AST tmp115_AST = null; 5825 tmp115_AST = astFactory.create(LT(1)); 5826 astFactory.addASTChild(currentAST, tmp115_AST); 5827 match(LPAREN); 5828 expression(); 5829 astFactory.addASTChild(currentAST, returnAST); 5830 AST tmp116_AST = null; 5831 tmp116_AST = astFactory.create(LT(1)); 5832 astFactory.addASTChild(currentAST, tmp116_AST); 5833 match(RPAREN); 5834 statement(); 5835 astFactory.addASTChild(currentAST, returnAST); 5836 { 5837 if ((LA(1)==LITERAL_else) && (_tokenSet_44.member(LA(2)))) { 5838 elseStatement(); 5839 astFactory.addASTChild(currentAST, returnAST); 5840 } 5841 else if ((_tokenSet_65.member(LA(1))) && (_tokenSet_66.member(LA(2)))) { 5842 } 5843 else { 5844 throw new NoViableAltException(LT(1), getFilename()); 5845 } 5846 5847 } 5848 traditionalStatement_AST = (AST)currentAST.root; 5849 break; 5850 } 5851 case LITERAL_for: 5852 { 5853 forStatement(); 5854 astFactory.addASTChild(currentAST, returnAST); 5855 traditionalStatement_AST = (AST)currentAST.root; 5856 break; 5857 } 5858 case LITERAL_while: 5859 { 5860 AST tmp117_AST = null; 5861 tmp117_AST = astFactory.create(LT(1)); 5862 astFactory.makeASTRoot(currentAST, tmp117_AST); 5863 match(LITERAL_while); 5864 AST tmp118_AST = null; 5865 tmp118_AST = astFactory.create(LT(1)); 5866 astFactory.addASTChild(currentAST, tmp118_AST); 5867 match(LPAREN); 5868 expression(); 5869 astFactory.addASTChild(currentAST, returnAST); 5870 AST tmp119_AST = null; 5871 tmp119_AST = astFactory.create(LT(1)); 5872 astFactory.addASTChild(currentAST, tmp119_AST); 5873 match(RPAREN); 5874 statement(); 5875 astFactory.addASTChild(currentAST, returnAST); 5876 traditionalStatement_AST = (AST)currentAST.root; 5877 break; 5878 } 5879 case LITERAL_do: 5880 { 5881 AST tmp120_AST = null; 5882 tmp120_AST = astFactory.create(LT(1)); 5883 astFactory.makeASTRoot(currentAST, tmp120_AST); 5884 match(LITERAL_do); 5885 statement(); 5886 astFactory.addASTChild(currentAST, returnAST); 5887 w = LT(1); 5888 w_AST = astFactory.create(w); 5889 astFactory.addASTChild(currentAST, w_AST); 5890 match(LITERAL_while); 5891 if ( inputState.guessing==0 ) { 5892 w_AST.setType(DO_WHILE); 5893 } 5894 AST tmp121_AST = null; 5895 tmp121_AST = astFactory.create(LT(1)); 5896 astFactory.addASTChild(currentAST, tmp121_AST); 5897 match(LPAREN); 5898 expression(); 5899 astFactory.addASTChild(currentAST, returnAST); 5900 AST tmp122_AST = null; 5901 tmp122_AST = astFactory.create(LT(1)); 5902 astFactory.addASTChild(currentAST, tmp122_AST); 5903 match(RPAREN); 5904 AST tmp123_AST = null; 5905 tmp123_AST = astFactory.create(LT(1)); 5906 astFactory.addASTChild(currentAST, tmp123_AST); 5907 match(SEMI); 5908 traditionalStatement_AST = (AST)currentAST.root; 5909 break; 5910 } 5911 case LITERAL_break: 5912 { 5913 AST tmp124_AST = null; 5914 tmp124_AST = astFactory.create(LT(1)); 5915 astFactory.makeASTRoot(currentAST, tmp124_AST); 5916 match(LITERAL_break); 5917 { 5918 switch ( LA(1)) { 5919 case IDENT: 5920 case LITERAL_record: 5921 case LITERAL_yield: 5922 case LITERAL_sealed: 5923 case LITERAL_permits: 5924 case LITERAL_non: 5925 { 5926 id(); 5927 astFactory.addASTChild(currentAST, returnAST); 5928 break; 5929 } 5930 case SEMI: 5931 { 5932 break; 5933 } 5934 default: 5935 { 5936 throw new NoViableAltException(LT(1), getFilename()); 5937 } 5938 } 5939 } 5940 AST tmp125_AST = null; 5941 tmp125_AST = astFactory.create(LT(1)); 5942 astFactory.addASTChild(currentAST, tmp125_AST); 5943 match(SEMI); 5944 traditionalStatement_AST = (AST)currentAST.root; 5945 break; 5946 } 5947 case LITERAL_continue: 5948 { 5949 AST tmp126_AST = null; 5950 tmp126_AST = astFactory.create(LT(1)); 5951 astFactory.makeASTRoot(currentAST, tmp126_AST); 5952 match(LITERAL_continue); 5953 { 5954 switch ( LA(1)) { 5955 case IDENT: 5956 case LITERAL_record: 5957 case LITERAL_yield: 5958 case LITERAL_sealed: 5959 case LITERAL_permits: 5960 case LITERAL_non: 5961 { 5962 id(); 5963 astFactory.addASTChild(currentAST, returnAST); 5964 break; 5965 } 5966 case SEMI: 5967 { 5968 break; 5969 } 5970 default: 5971 { 5972 throw new NoViableAltException(LT(1), getFilename()); 5973 } 5974 } 5975 } 5976 AST tmp127_AST = null; 5977 tmp127_AST = astFactory.create(LT(1)); 5978 astFactory.addASTChild(currentAST, tmp127_AST); 5979 match(SEMI); 5980 traditionalStatement_AST = (AST)currentAST.root; 5981 break; 5982 } 5983 case LITERAL_return: 5984 { 5985 AST tmp128_AST = null; 5986 tmp128_AST = astFactory.create(LT(1)); 5987 astFactory.makeASTRoot(currentAST, tmp128_AST); 5988 match(LITERAL_return); 5989 { 5990 switch ( LA(1)) { 5991 case LITERAL_void: 5992 case LITERAL_boolean: 5993 case LITERAL_byte: 5994 case LITERAL_char: 5995 case LITERAL_short: 5996 case LITERAL_int: 5997 case LITERAL_float: 5998 case LITERAL_long: 5999 case LITERAL_double: 6000 case IDENT: 6001 case LPAREN: 6002 case LITERAL_this: 6003 case LITERAL_super: 6004 case LITERAL_switch: 6005 case PLUS: 6006 case MINUS: 6007 case INC: 6008 case DEC: 6009 case BNOT: 6010 case LNOT: 6011 case LITERAL_true: 6012 case LITERAL_false: 6013 case LITERAL_null: 6014 case LITERAL_new: 6015 case NUM_INT: 6016 case CHAR_LITERAL: 6017 case STRING_LITERAL: 6018 case NUM_FLOAT: 6019 case NUM_LONG: 6020 case NUM_DOUBLE: 6021 case AT: 6022 case LITERAL_record: 6023 case TEXT_BLOCK_CONTENT: 6024 case LITERAL_yield: 6025 case LITERAL_sealed: 6026 case LITERAL_permits: 6027 case LITERAL_non: 6028 { 6029 expression(); 6030 astFactory.addASTChild(currentAST, returnAST); 6031 break; 6032 } 6033 case SEMI: 6034 { 6035 break; 6036 } 6037 default: 6038 { 6039 throw new NoViableAltException(LT(1), getFilename()); 6040 } 6041 } 6042 } 6043 AST tmp129_AST = null; 6044 tmp129_AST = astFactory.create(LT(1)); 6045 astFactory.addASTChild(currentAST, tmp129_AST); 6046 match(SEMI); 6047 traditionalStatement_AST = (AST)currentAST.root; 6048 break; 6049 } 6050 case LITERAL_try: 6051 { 6052 tryBlock(); 6053 astFactory.addASTChild(currentAST, returnAST); 6054 traditionalStatement_AST = (AST)currentAST.root; 6055 break; 6056 } 6057 case LITERAL_throw: 6058 { 6059 throwStatement(); 6060 astFactory.addASTChild(currentAST, returnAST); 6061 traditionalStatement_AST = (AST)currentAST.root; 6062 break; 6063 } 6064 case SEMI: 6065 { 6066 s = LT(1); 6067 s_AST = astFactory.create(s); 6068 astFactory.addASTChild(currentAST, s_AST); 6069 match(SEMI); 6070 if ( inputState.guessing==0 ) { 6071 s_AST.setType(EMPTY_STAT); 6072 } 6073 traditionalStatement_AST = (AST)currentAST.root; 6074 break; 6075 } 6076 default: 6077 if (((LA(1)==LITERAL_yield) && (_tokenSet_19.member(LA(2))))&&(this.switchBlockDepth>0)) { 6078 yieldStatement(); 6079 astFactory.addASTChild(currentAST, returnAST); 6080 traditionalStatement_AST = (AST)currentAST.root; 6081 } 6082 else { 6083 boolean synPredMatched250 = false; 6084 if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) { 6085 int _m250 = mark(); 6086 synPredMatched250 = true; 6087 inputState.guessing++; 6088 try { 6089 { 6090 declaration(); 6091 } 6092 } 6093 catch (RecognitionException pe) { 6094 synPredMatched250 = false; 6095 } 6096 rewind(_m250); 6097inputState.guessing--; 6098 } 6099 if ( synPredMatched250 ) { 6100 declaration(); 6101 astFactory.addASTChild(currentAST, returnAST); 6102 AST tmp130_AST = null; 6103 tmp130_AST = astFactory.create(LT(1)); 6104 astFactory.addASTChild(currentAST, tmp130_AST); 6105 match(SEMI); 6106 traditionalStatement_AST = (AST)currentAST.root; 6107 } 6108 else { 6109 boolean synPredMatched252 = false; 6110 if (((LA(1)==AT||LA(1)==LITERAL_record) && (_tokenSet_0.member(LA(2))))) { 6111 int _m252 = mark(); 6112 synPredMatched252 = true; 6113 inputState.guessing++; 6114 try { 6115 { 6116 annotations(); 6117 recordDefinition(null); 6118 } 6119 } 6120 catch (RecognitionException pe) { 6121 synPredMatched252 = false; 6122 } 6123 rewind(_m252); 6124inputState.guessing--; 6125 } 6126 if ( synPredMatched252 ) { 6127 { 6128 annotations(); 6129 a_AST = (AST)returnAST; 6130 if ( inputState.guessing==0 ) { 6131 6132 // We will change the annotations AST to be a modifier AST so that 6133 // if there are no annotations, we still have an empty modifier AST as we 6134 // do for classes without modifiers AND to reflect the structure of our 6135 // class def AST. 6136 a_AST.setType(MODIFIERS); 6137 a_AST.setText("MODIFIERS"); 6138 6139 } 6140 recordDefinition(a_AST); 6141 astFactory.addASTChild(currentAST, returnAST); 6142 } 6143 traditionalStatement_AST = (AST)currentAST.root; 6144 } 6145 else if ((LA(1)==LITERAL_switch) && (LA(2)==LPAREN)) { 6146 switchExpression(); 6147 astFactory.addASTChild(currentAST, returnAST); 6148 traditionalStatement_AST = (AST)currentAST.root; 6149 } 6150 else { 6151 boolean synPredMatched256 = false; 6152 if ((((_tokenSet_19.member(LA(1))) && (_tokenSet_69.member(LA(2))))&&(LA(2) != COLON))) { 6153 int _m256 = mark(); 6154 synPredMatched256 = true; 6155 inputState.guessing++; 6156 try { 6157 { 6158 if (!(LA(2) != COLON)) 6159 throw new SemanticException("LA(2) != COLON"); 6160 expression(); 6161 { 6162 if ((LA(1)==SEMI)) { 6163 match(SEMI); 6164 } 6165 else { 6166 } 6167 6168 } 6169 } 6170 } 6171 catch (RecognitionException pe) { 6172 synPredMatched256 = false; 6173 } 6174 rewind(_m256); 6175inputState.guessing--; 6176 } 6177 if ( synPredMatched256 ) { 6178 expression(); 6179 astFactory.addASTChild(currentAST, returnAST); 6180 { 6181 if ((LA(1)==SEMI) && (_tokenSet_65.member(LA(2)))) { 6182 AST tmp131_AST = null; 6183 tmp131_AST = astFactory.create(LT(1)); 6184 astFactory.addASTChild(currentAST, tmp131_AST); 6185 match(SEMI); 6186 } 6187 else if ((_tokenSet_65.member(LA(1))) && (_tokenSet_66.member(LA(2)))) { 6188 } 6189 else { 6190 throw new NoViableAltException(LT(1), getFilename()); 6191 } 6192 6193 } 6194 traditionalStatement_AST = (AST)currentAST.root; 6195 } 6196 else if ((_tokenSet_70.member(LA(1))) && (_tokenSet_71.member(LA(2)))) { 6197 modifiers(); 6198 m_AST = (AST)returnAST; 6199 classDefinition(m_AST); 6200 astFactory.addASTChild(currentAST, returnAST); 6201 traditionalStatement_AST = (AST)currentAST.root; 6202 } 6203 else if ((_tokenSet_0.member(LA(1))) && (LA(2)==COLON)) { 6204 id(); 6205 astFactory.addASTChild(currentAST, returnAST); 6206 c = LT(1); 6207 c_AST = astFactory.create(c); 6208 astFactory.makeASTRoot(currentAST, c_AST); 6209 match(COLON); 6210 if ( inputState.guessing==0 ) { 6211 c_AST.setType(LABELED_STAT); 6212 } 6213 statement(); 6214 astFactory.addASTChild(currentAST, returnAST); 6215 traditionalStatement_AST = (AST)currentAST.root; 6216 } 6217 else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) { 6218 AST tmp132_AST = null; 6219 tmp132_AST = astFactory.create(LT(1)); 6220 astFactory.makeASTRoot(currentAST, tmp132_AST); 6221 match(LITERAL_synchronized); 6222 AST tmp133_AST = null; 6223 tmp133_AST = astFactory.create(LT(1)); 6224 astFactory.addASTChild(currentAST, tmp133_AST); 6225 match(LPAREN); 6226 expression(); 6227 astFactory.addASTChild(currentAST, returnAST); 6228 AST tmp134_AST = null; 6229 tmp134_AST = astFactory.create(LT(1)); 6230 astFactory.addASTChild(currentAST, tmp134_AST); 6231 match(RPAREN); 6232 compoundStatement(); 6233 astFactory.addASTChild(currentAST, returnAST); 6234 traditionalStatement_AST = (AST)currentAST.root; 6235 } 6236 else { 6237 throw new NoViableAltException(LT(1), getFilename()); 6238 } 6239 }}}} 6240 returnAST = traditionalStatement_AST; 6241 } 6242 6243 public final void assertStatement() throws RecognitionException, TokenStreamException { 6244 6245 returnAST = null; 6246 ASTPair currentAST = new ASTPair(); 6247 AST assertStatement_AST = null; 6248 6249 AST tmp135_AST = null; 6250 tmp135_AST = astFactory.create(LT(1)); 6251 astFactory.makeASTRoot(currentAST, tmp135_AST); 6252 match(ASSERT); 6253 expression(); 6254 astFactory.addASTChild(currentAST, returnAST); 6255 { 6256 switch ( LA(1)) { 6257 case COLON: 6258 { 6259 AST tmp136_AST = null; 6260 tmp136_AST = astFactory.create(LT(1)); 6261 astFactory.addASTChild(currentAST, tmp136_AST); 6262 match(COLON); 6263 expression(); 6264 astFactory.addASTChild(currentAST, returnAST); 6265 break; 6266 } 6267 case SEMI: 6268 { 6269 break; 6270 } 6271 default: 6272 { 6273 throw new NoViableAltException(LT(1), getFilename()); 6274 } 6275 } 6276 } 6277 AST tmp137_AST = null; 6278 tmp137_AST = astFactory.create(LT(1)); 6279 astFactory.addASTChild(currentAST, tmp137_AST); 6280 match(SEMI); 6281 assertStatement_AST = (AST)currentAST.root; 6282 returnAST = assertStatement_AST; 6283 } 6284 6285 public final void yieldStatement() throws RecognitionException, TokenStreamException { 6286 6287 returnAST = null; 6288 ASTPair currentAST = new ASTPair(); 6289 AST yieldStatement_AST = null; 6290 Token l = null; 6291 AST l_AST = null; 6292 AST e_AST = null; 6293 Token s = null; 6294 AST s_AST = null; 6295 6296 l = LT(1); 6297 l_AST = astFactory.create(l); 6298 match(LITERAL_yield); 6299 expression(); 6300 e_AST = (AST)returnAST; 6301 s = LT(1); 6302 s_AST = astFactory.create(s); 6303 match(SEMI); 6304 if ( inputState.guessing==0 ) { 6305 yieldStatement_AST = (AST)currentAST.root; 6306 yieldStatement_AST = (AST)astFactory.make( (new ASTArray(3)).add(l_AST).add(e_AST).add(s_AST)); 6307 currentAST.root = yieldStatement_AST; 6308 currentAST.child = yieldStatement_AST!=null &&yieldStatement_AST.getFirstChild()!=null ? 6309 yieldStatement_AST.getFirstChild() : yieldStatement_AST; 6310 currentAST.advanceChildToEnd(); 6311 } 6312 returnAST = yieldStatement_AST; 6313 } 6314 6315 public final void switchExpression() throws RecognitionException, TokenStreamException { 6316 6317 returnAST = null; 6318 ASTPair currentAST = new ASTPair(); 6319 AST switchExpression_AST = null; 6320 6321 AST tmp138_AST = null; 6322 tmp138_AST = astFactory.create(LT(1)); 6323 astFactory.makeASTRoot(currentAST, tmp138_AST); 6324 match(LITERAL_switch); 6325 AST tmp139_AST = null; 6326 tmp139_AST = astFactory.create(LT(1)); 6327 astFactory.addASTChild(currentAST, tmp139_AST); 6328 match(LPAREN); 6329 expression(); 6330 astFactory.addASTChild(currentAST, returnAST); 6331 AST tmp140_AST = null; 6332 tmp140_AST = astFactory.create(LT(1)); 6333 astFactory.addASTChild(currentAST, tmp140_AST); 6334 match(RPAREN); 6335 switchBlock(); 6336 astFactory.addASTChild(currentAST, returnAST); 6337 switchExpression_AST = (AST)currentAST.root; 6338 returnAST = switchExpression_AST; 6339 } 6340 6341 public final void elseStatement() throws RecognitionException, TokenStreamException { 6342 6343 returnAST = null; 6344 ASTPair currentAST = new ASTPair(); 6345 AST elseStatement_AST = null; 6346 6347 AST tmp141_AST = null; 6348 tmp141_AST = astFactory.create(LT(1)); 6349 astFactory.makeASTRoot(currentAST, tmp141_AST); 6350 match(LITERAL_else); 6351 statement(); 6352 astFactory.addASTChild(currentAST, returnAST); 6353 elseStatement_AST = (AST)currentAST.root; 6354 returnAST = elseStatement_AST; 6355 } 6356 6357 public final void forStatement() throws RecognitionException, TokenStreamException { 6358 6359 returnAST = null; 6360 ASTPair currentAST = new ASTPair(); 6361 AST forStatement_AST = null; 6362 Token f = null; 6363 AST f_AST = null; 6364 6365 f = LT(1); 6366 f_AST = astFactory.create(f); 6367 astFactory.makeASTRoot(currentAST, f_AST); 6368 match(LITERAL_for); 6369 AST tmp142_AST = null; 6370 tmp142_AST = astFactory.create(LT(1)); 6371 astFactory.addASTChild(currentAST, tmp142_AST); 6372 match(LPAREN); 6373 { 6374 boolean synPredMatched266 = false; 6375 if (((_tokenSet_72.member(LA(1))) && (_tokenSet_73.member(LA(2))))) { 6376 int _m266 = mark(); 6377 synPredMatched266 = true; 6378 inputState.guessing++; 6379 try { 6380 { 6381 forInit(); 6382 match(SEMI); 6383 } 6384 } 6385 catch (RecognitionException pe) { 6386 synPredMatched266 = false; 6387 } 6388 rewind(_m266); 6389inputState.guessing--; 6390 } 6391 if ( synPredMatched266 ) { 6392 traditionalForClause(); 6393 astFactory.addASTChild(currentAST, returnAST); 6394 } 6395 else if ((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2)))) { 6396 forEachClause(); 6397 astFactory.addASTChild(currentAST, returnAST); 6398 } 6399 else { 6400 throw new NoViableAltException(LT(1), getFilename()); 6401 } 6402 6403 } 6404 AST tmp143_AST = null; 6405 tmp143_AST = astFactory.create(LT(1)); 6406 astFactory.addASTChild(currentAST, tmp143_AST); 6407 match(RPAREN); 6408 statement(); 6409 astFactory.addASTChild(currentAST, returnAST); 6410 forStatement_AST = (AST)currentAST.root; 6411 returnAST = forStatement_AST; 6412 } 6413 6414 public final void tryBlock() throws RecognitionException, TokenStreamException { 6415 6416 returnAST = null; 6417 ASTPair currentAST = new ASTPair(); 6418 AST tryBlock_AST = null; 6419 6420 AST tmp144_AST = null; 6421 tmp144_AST = astFactory.create(LT(1)); 6422 astFactory.makeASTRoot(currentAST, tmp144_AST); 6423 match(LITERAL_try); 6424 { 6425 switch ( LA(1)) { 6426 case LPAREN: 6427 { 6428 resourceSpecification(); 6429 astFactory.addASTChild(currentAST, returnAST); 6430 break; 6431 } 6432 case LCURLY: 6433 { 6434 break; 6435 } 6436 default: 6437 { 6438 throw new NoViableAltException(LT(1), getFilename()); 6439 } 6440 } 6441 } 6442 compoundStatement(); 6443 astFactory.addASTChild(currentAST, returnAST); 6444 { 6445 _loop324: 6446 do { 6447 if ((LA(1)==LITERAL_catch)) { 6448 handler(); 6449 astFactory.addASTChild(currentAST, returnAST); 6450 } 6451 else { 6452 break _loop324; 6453 } 6454 6455 } while (true); 6456 } 6457 { 6458 switch ( LA(1)) { 6459 case LITERAL_finally: 6460 { 6461 finallyHandler(); 6462 astFactory.addASTChild(currentAST, returnAST); 6463 break; 6464 } 6465 case FINAL: 6466 case ABSTRACT: 6467 case STRICTFP: 6468 case SEMI: 6469 case LITERAL_void: 6470 case LITERAL_boolean: 6471 case LITERAL_byte: 6472 case LITERAL_char: 6473 case LITERAL_short: 6474 case LITERAL_int: 6475 case LITERAL_float: 6476 case LITERAL_long: 6477 case LITERAL_double: 6478 case IDENT: 6479 case STAR: 6480 case LITERAL_private: 6481 case LITERAL_public: 6482 case LITERAL_protected: 6483 case LITERAL_static: 6484 case LITERAL_transient: 6485 case LITERAL_native: 6486 case LITERAL_synchronized: 6487 case LITERAL_volatile: 6488 case LITERAL_class: 6489 case LCURLY: 6490 case RCURLY: 6491 case LPAREN: 6492 case RPAREN: 6493 case LITERAL_this: 6494 case LITERAL_super: 6495 case COLON: 6496 case LITERAL_if: 6497 case LITERAL_while: 6498 case LITERAL_do: 6499 case LITERAL_break: 6500 case LITERAL_continue: 6501 case LITERAL_return: 6502 case LITERAL_switch: 6503 case LITERAL_throw: 6504 case LITERAL_for: 6505 case LITERAL_else: 6506 case LITERAL_case: 6507 case LITERAL_default: 6508 case LITERAL_try: 6509 case LT: 6510 case GT: 6511 case LE: 6512 case GE: 6513 case LITERAL_instanceof: 6514 case SL: 6515 case SR: 6516 case BSR: 6517 case PLUS: 6518 case MINUS: 6519 case DIV: 6520 case MOD: 6521 case INC: 6522 case DEC: 6523 case BNOT: 6524 case LNOT: 6525 case LITERAL_true: 6526 case LITERAL_false: 6527 case LITERAL_null: 6528 case LITERAL_new: 6529 case NUM_INT: 6530 case CHAR_LITERAL: 6531 case STRING_LITERAL: 6532 case NUM_FLOAT: 6533 case NUM_LONG: 6534 case NUM_DOUBLE: 6535 case ASSERT: 6536 case AT: 6537 case LITERAL_record: 6538 case TEXT_BLOCK_CONTENT: 6539 case LITERAL_yield: 6540 case LITERAL_sealed: 6541 case LITERAL_permits: 6542 case LITERAL_non: 6543 { 6544 break; 6545 } 6546 default: 6547 { 6548 throw new NoViableAltException(LT(1), getFilename()); 6549 } 6550 } 6551 } 6552 tryBlock_AST = (AST)currentAST.root; 6553 returnAST = tryBlock_AST; 6554 } 6555 6556 public final void throwStatement() throws RecognitionException, TokenStreamException { 6557 6558 returnAST = null; 6559 ASTPair currentAST = new ASTPair(); 6560 AST throwStatement_AST = null; 6561 6562 AST tmp145_AST = null; 6563 tmp145_AST = astFactory.create(LT(1)); 6564 astFactory.makeASTRoot(currentAST, tmp145_AST); 6565 match(LITERAL_throw); 6566 expression(); 6567 astFactory.addASTChild(currentAST, returnAST); 6568 AST tmp146_AST = null; 6569 tmp146_AST = astFactory.create(LT(1)); 6570 astFactory.addASTChild(currentAST, tmp146_AST); 6571 match(SEMI); 6572 throwStatement_AST = (AST)currentAST.root; 6573 returnAST = throwStatement_AST; 6574 } 6575 6576 public final void forInit() throws RecognitionException, TokenStreamException { 6577 6578 returnAST = null; 6579 ASTPair currentAST = new ASTPair(); 6580 AST forInit_AST = null; 6581 6582 { 6583 boolean synPredMatched316 = false; 6584 if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) { 6585 int _m316 = mark(); 6586 synPredMatched316 = true; 6587 inputState.guessing++; 6588 try { 6589 { 6590 declaration(); 6591 } 6592 } 6593 catch (RecognitionException pe) { 6594 synPredMatched316 = false; 6595 } 6596 rewind(_m316); 6597inputState.guessing--; 6598 } 6599 if ( synPredMatched316 ) { 6600 declaration(); 6601 astFactory.addASTChild(currentAST, returnAST); 6602 } 6603 else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_74.member(LA(2)))) { 6604 expressionList(); 6605 astFactory.addASTChild(currentAST, returnAST); 6606 } 6607 else if ((LA(1)==SEMI)) { 6608 } 6609 else { 6610 throw new NoViableAltException(LT(1), getFilename()); 6611 } 6612 6613 } 6614 if ( inputState.guessing==0 ) { 6615 forInit_AST = (AST)currentAST.root; 6616 forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_INIT,"FOR_INIT")).add(forInit_AST)); 6617 currentAST.root = forInit_AST; 6618 currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ? 6619 forInit_AST.getFirstChild() : forInit_AST; 6620 currentAST.advanceChildToEnd(); 6621 } 6622 forInit_AST = (AST)currentAST.root; 6623 returnAST = forInit_AST; 6624 } 6625 6626 public final void traditionalForClause() throws RecognitionException, TokenStreamException { 6627 6628 returnAST = null; 6629 ASTPair currentAST = new ASTPair(); 6630 AST traditionalForClause_AST = null; 6631 6632 forInit(); 6633 astFactory.addASTChild(currentAST, returnAST); 6634 AST tmp147_AST = null; 6635 tmp147_AST = astFactory.create(LT(1)); 6636 astFactory.addASTChild(currentAST, tmp147_AST); 6637 match(SEMI); 6638 forCond(); 6639 astFactory.addASTChild(currentAST, returnAST); 6640 AST tmp148_AST = null; 6641 tmp148_AST = astFactory.create(LT(1)); 6642 astFactory.addASTChild(currentAST, tmp148_AST); 6643 match(SEMI); 6644 forIter(); 6645 astFactory.addASTChild(currentAST, returnAST); 6646 traditionalForClause_AST = (AST)currentAST.root; 6647 returnAST = traditionalForClause_AST; 6648 } 6649 6650 public final void forEachClause() throws RecognitionException, TokenStreamException { 6651 6652 returnAST = null; 6653 ASTPair currentAST = new ASTPair(); 6654 AST forEachClause_AST = null; 6655 6656 forEachDeclarator(); 6657 astFactory.addASTChild(currentAST, returnAST); 6658 AST tmp149_AST = null; 6659 tmp149_AST = astFactory.create(LT(1)); 6660 astFactory.addASTChild(currentAST, tmp149_AST); 6661 match(COLON); 6662 expression(); 6663 astFactory.addASTChild(currentAST, returnAST); 6664 if ( inputState.guessing==0 ) { 6665 forEachClause_AST = (AST)currentAST.root; 6666 forEachClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE")).add(forEachClause_AST)); 6667 currentAST.root = forEachClause_AST; 6668 currentAST.child = forEachClause_AST!=null &&forEachClause_AST.getFirstChild()!=null ? 6669 forEachClause_AST.getFirstChild() : forEachClause_AST; 6670 currentAST.advanceChildToEnd(); 6671 } 6672 forEachClause_AST = (AST)currentAST.root; 6673 returnAST = forEachClause_AST; 6674 } 6675 6676 public final void forCond() throws RecognitionException, TokenStreamException { 6677 6678 returnAST = null; 6679 ASTPair currentAST = new ASTPair(); 6680 AST forCond_AST = null; 6681 6682 { 6683 switch ( LA(1)) { 6684 case LITERAL_void: 6685 case LITERAL_boolean: 6686 case LITERAL_byte: 6687 case LITERAL_char: 6688 case LITERAL_short: 6689 case LITERAL_int: 6690 case LITERAL_float: 6691 case LITERAL_long: 6692 case LITERAL_double: 6693 case IDENT: 6694 case LPAREN: 6695 case LITERAL_this: 6696 case LITERAL_super: 6697 case LITERAL_switch: 6698 case PLUS: 6699 case MINUS: 6700 case INC: 6701 case DEC: 6702 case BNOT: 6703 case LNOT: 6704 case LITERAL_true: 6705 case LITERAL_false: 6706 case LITERAL_null: 6707 case LITERAL_new: 6708 case NUM_INT: 6709 case CHAR_LITERAL: 6710 case STRING_LITERAL: 6711 case NUM_FLOAT: 6712 case NUM_LONG: 6713 case NUM_DOUBLE: 6714 case AT: 6715 case LITERAL_record: 6716 case TEXT_BLOCK_CONTENT: 6717 case LITERAL_yield: 6718 case LITERAL_sealed: 6719 case LITERAL_permits: 6720 case LITERAL_non: 6721 { 6722 expression(); 6723 astFactory.addASTChild(currentAST, returnAST); 6724 break; 6725 } 6726 case SEMI: 6727 { 6728 break; 6729 } 6730 default: 6731 { 6732 throw new NoViableAltException(LT(1), getFilename()); 6733 } 6734 } 6735 } 6736 if ( inputState.guessing==0 ) { 6737 forCond_AST = (AST)currentAST.root; 6738 forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).add(forCond_AST)); 6739 currentAST.root = forCond_AST; 6740 currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ? 6741 forCond_AST.getFirstChild() : forCond_AST; 6742 currentAST.advanceChildToEnd(); 6743 } 6744 forCond_AST = (AST)currentAST.root; 6745 returnAST = forCond_AST; 6746 } 6747 6748 public final void forIter() throws RecognitionException, TokenStreamException { 6749 6750 returnAST = null; 6751 ASTPair currentAST = new ASTPair(); 6752 AST forIter_AST = null; 6753 6754 { 6755 switch ( LA(1)) { 6756 case LITERAL_void: 6757 case LITERAL_boolean: 6758 case LITERAL_byte: 6759 case LITERAL_char: 6760 case LITERAL_short: 6761 case LITERAL_int: 6762 case LITERAL_float: 6763 case LITERAL_long: 6764 case LITERAL_double: 6765 case IDENT: 6766 case LPAREN: 6767 case LITERAL_this: 6768 case LITERAL_super: 6769 case LITERAL_switch: 6770 case PLUS: 6771 case MINUS: 6772 case INC: 6773 case DEC: 6774 case BNOT: 6775 case LNOT: 6776 case LITERAL_true: 6777 case LITERAL_false: 6778 case LITERAL_null: 6779 case LITERAL_new: 6780 case NUM_INT: 6781 case CHAR_LITERAL: 6782 case STRING_LITERAL: 6783 case NUM_FLOAT: 6784 case NUM_LONG: 6785 case NUM_DOUBLE: 6786 case AT: 6787 case LITERAL_record: 6788 case TEXT_BLOCK_CONTENT: 6789 case LITERAL_yield: 6790 case LITERAL_sealed: 6791 case LITERAL_permits: 6792 case LITERAL_non: 6793 { 6794 expressionList(); 6795 astFactory.addASTChild(currentAST, returnAST); 6796 break; 6797 } 6798 case RPAREN: 6799 { 6800 break; 6801 } 6802 default: 6803 { 6804 throw new NoViableAltException(LT(1), getFilename()); 6805 } 6806 } 6807 } 6808 if ( inputState.guessing==0 ) { 6809 forIter_AST = (AST)currentAST.root; 6810 forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).add(forIter_AST)); 6811 currentAST.root = forIter_AST; 6812 currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ? 6813 forIter_AST.getFirstChild() : forIter_AST; 6814 currentAST.advanceChildToEnd(); 6815 } 6816 forIter_AST = (AST)currentAST.root; 6817 returnAST = forIter_AST; 6818 } 6819 6820 public final void forEachDeclarator() throws RecognitionException, TokenStreamException { 6821 6822 returnAST = null; 6823 ASTPair currentAST = new ASTPair(); 6824 AST forEachDeclarator_AST = null; 6825 AST m_AST = null; 6826 AST t_AST = null; 6827 AST id_AST = null; 6828 AST d_AST = null; 6829 6830 modifiers(); 6831 m_AST = (AST)returnAST; 6832 typeSpec(false); 6833 t_AST = (AST)returnAST; 6834 id(); 6835 id_AST = (AST)returnAST; 6836 typeSpecBracketsAndAnnotationsNonGreedy(); 6837 d_AST = (AST)returnAST; 6838 if ( inputState.guessing==0 ) { 6839 forEachDeclarator_AST = (AST)currentAST.root; 6840 forEachDeclarator_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(m_AST).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t_AST).add(d_AST))).add(id_AST)); 6841 currentAST.root = forEachDeclarator_AST; 6842 currentAST.child = forEachDeclarator_AST!=null &&forEachDeclarator_AST.getFirstChild()!=null ? 6843 forEachDeclarator_AST.getFirstChild() : forEachDeclarator_AST; 6844 currentAST.advanceChildToEnd(); 6845 } 6846 returnAST = forEachDeclarator_AST; 6847 } 6848 6849 public final void switchBlock() throws RecognitionException, TokenStreamException { 6850 6851 returnAST = null; 6852 ASTPair currentAST = new ASTPair(); 6853 AST switchBlock_AST = null; 6854 6855 { 6856 switchBlockDepth++; 6857 AST tmp150_AST = null; 6858 tmp150_AST = astFactory.create(LT(1)); 6859 astFactory.addASTChild(currentAST, tmp150_AST); 6860 match(LCURLY); 6861 } 6862 { 6863 boolean synPredMatched277 = false; 6864 if (((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_75.member(LA(2))))) { 6865 int _m277 = mark(); 6866 synPredMatched277 = true; 6867 inputState.guessing++; 6868 try { 6869 { 6870 { 6871 int _cnt276=0; 6872 _loop276: 6873 do { 6874 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) { 6875 switchRule(); 6876 } 6877 else { 6878 if ( _cnt276>=1 ) { break _loop276; } else {throw new NoViableAltException(LT(1), getFilename());} 6879 } 6880 6881 _cnt276++; 6882 } while (true); 6883 } 6884 } 6885 } 6886 catch (RecognitionException pe) { 6887 synPredMatched277 = false; 6888 } 6889 rewind(_m277); 6890inputState.guessing--; 6891 } 6892 if ( synPredMatched277 ) { 6893 { 6894 { 6895 int _cnt280=0; 6896 _loop280: 6897 do { 6898 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) { 6899 switchRule(); 6900 astFactory.addASTChild(currentAST, returnAST); 6901 } 6902 else { 6903 if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltException(LT(1), getFilename());} 6904 } 6905 6906 _cnt280++; 6907 } while (true); 6908 } 6909 } 6910 } 6911 else { 6912 boolean synPredMatched284 = false; 6913 if (((_tokenSet_76.member(LA(1))) && (_tokenSet_77.member(LA(2))))) { 6914 int _m284 = mark(); 6915 synPredMatched284 = true; 6916 inputState.guessing++; 6917 try { 6918 { 6919 { 6920 _loop283: 6921 do { 6922 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) { 6923 casesGroup(); 6924 } 6925 else { 6926 break _loop283; 6927 } 6928 6929 } while (true); 6930 } 6931 } 6932 } 6933 catch (RecognitionException pe) { 6934 synPredMatched284 = false; 6935 } 6936 rewind(_m284); 6937inputState.guessing--; 6938 } 6939 if ( synPredMatched284 ) { 6940 { 6941 { 6942 _loop287: 6943 do { 6944 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) { 6945 casesGroup(); 6946 astFactory.addASTChild(currentAST, returnAST); 6947 } 6948 else { 6949 break _loop287; 6950 } 6951 6952 } while (true); 6953 } 6954 } 6955 } 6956 else { 6957 throw new NoViableAltException(LT(1), getFilename()); 6958 } 6959 } 6960 } 6961 { 6962 switchBlockDepth--; 6963 AST tmp151_AST = null; 6964 tmp151_AST = astFactory.create(LT(1)); 6965 astFactory.addASTChild(currentAST, tmp151_AST); 6966 match(RCURLY); 6967 } 6968 switchBlock_AST = (AST)currentAST.root; 6969 returnAST = switchBlock_AST; 6970 } 6971 6972 public final void switchRule() throws RecognitionException, TokenStreamException { 6973 6974 returnAST = null; 6975 ASTPair currentAST = new ASTPair(); 6976 AST switchRule_AST = null; 6977 AST se_AST = null; 6978 AST sb_AST = null; 6979 AST st_AST = null; 6980 6981 { 6982 boolean synPredMatched299 = false; 6983 if (((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_75.member(LA(2))))) { 6984 int _m299 = mark(); 6985 synPredMatched299 = true; 6986 inputState.guessing++; 6987 try { 6988 { 6989 switchLabeledExpression(); 6990 } 6991 } 6992 catch (RecognitionException pe) { 6993 synPredMatched299 = false; 6994 } 6995 rewind(_m299); 6996inputState.guessing--; 6997 } 6998 if ( synPredMatched299 ) { 6999 switchLabeledExpression(); 7000 se_AST = (AST)returnAST; 7001 astFactory.addASTChild(currentAST, returnAST); 7002 } 7003 else { 7004 boolean synPredMatched301 = false; 7005 if (((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_75.member(LA(2))))) { 7006 int _m301 = mark(); 7007 synPredMatched301 = true; 7008 inputState.guessing++; 7009 try { 7010 { 7011 switchLabeledBlock(); 7012 } 7013 } 7014 catch (RecognitionException pe) { 7015 synPredMatched301 = false; 7016 } 7017 rewind(_m301); 7018inputState.guessing--; 7019 } 7020 if ( synPredMatched301 ) { 7021 switchLabeledBlock(); 7022 sb_AST = (AST)returnAST; 7023 astFactory.addASTChild(currentAST, returnAST); 7024 } 7025 else { 7026 boolean synPredMatched303 = false; 7027 if (((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_75.member(LA(2))))) { 7028 int _m303 = mark(); 7029 synPredMatched303 = true; 7030 inputState.guessing++; 7031 try { 7032 { 7033 switchLabeledThrow(); 7034 } 7035 } 7036 catch (RecognitionException pe) { 7037 synPredMatched303 = false; 7038 } 7039 rewind(_m303); 7040inputState.guessing--; 7041 } 7042 if ( synPredMatched303 ) { 7043 switchLabeledThrow(); 7044 st_AST = (AST)returnAST; 7045 astFactory.addASTChild(currentAST, returnAST); 7046 } 7047 else { 7048 throw new NoViableAltException(LT(1), getFilename()); 7049 } 7050 }} 7051 } 7052 if ( inputState.guessing==0 ) { 7053 switchRule_AST = (AST)currentAST.root; 7054 switchRule_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(SWITCH_RULE,"SWITCH_RULE")).add(se_AST).add(sb_AST).add(st_AST)); 7055 currentAST.root = switchRule_AST; 7056 currentAST.child = switchRule_AST!=null &&switchRule_AST.getFirstChild()!=null ? 7057 switchRule_AST.getFirstChild() : switchRule_AST; 7058 currentAST.advanceChildToEnd(); 7059 } 7060 switchRule_AST = (AST)currentAST.root; 7061 returnAST = switchRule_AST; 7062 } 7063 7064 public final void casesGroup() throws RecognitionException, TokenStreamException { 7065 7066 returnAST = null; 7067 ASTPair currentAST = new ASTPair(); 7068 AST casesGroup_AST = null; 7069 7070 { 7071 int _cnt291=0; 7072 _loop291: 7073 do { 7074 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_78.member(LA(2)))) { 7075 switchLabel(); 7076 astFactory.addASTChild(currentAST, returnAST); 7077 } 7078 else { 7079 if ( _cnt291>=1 ) { break _loop291; } else {throw new NoViableAltException(LT(1), getFilename());} 7080 } 7081 7082 _cnt291++; 7083 } while (true); 7084 } 7085 { 7086 if ((_tokenSet_44.member(LA(1))) && (_tokenSet_79.member(LA(2)))) { 7087 caseSList(); 7088 astFactory.addASTChild(currentAST, returnAST); 7089 } 7090 else if ((_tokenSet_76.member(LA(1))) && (_tokenSet_77.member(LA(2)))) { 7091 } 7092 else { 7093 throw new NoViableAltException(LT(1), getFilename()); 7094 } 7095 7096 } 7097 if ( inputState.guessing==0 ) { 7098 casesGroup_AST = (AST)currentAST.root; 7099 casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST)); 7100 currentAST.root = casesGroup_AST; 7101 currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ? 7102 casesGroup_AST.getFirstChild() : casesGroup_AST; 7103 currentAST.advanceChildToEnd(); 7104 } 7105 casesGroup_AST = (AST)currentAST.root; 7106 returnAST = casesGroup_AST; 7107 } 7108 7109 public final void switchLabel() throws RecognitionException, TokenStreamException { 7110 7111 returnAST = null; 7112 ASTPair currentAST = new ASTPair(); 7113 AST switchLabel_AST = null; 7114 7115 { 7116 switch ( LA(1)) { 7117 case LITERAL_case: 7118 { 7119 AST tmp152_AST = null; 7120 tmp152_AST = astFactory.create(LT(1)); 7121 astFactory.makeASTRoot(currentAST, tmp152_AST); 7122 match(LITERAL_case); 7123 caseConstant(); 7124 astFactory.addASTChild(currentAST, returnAST); 7125 { 7126 _loop310: 7127 do { 7128 if ((LA(1)==COMMA)) { 7129 AST tmp153_AST = null; 7130 tmp153_AST = astFactory.create(LT(1)); 7131 astFactory.addASTChild(currentAST, tmp153_AST); 7132 match(COMMA); 7133 caseConstant(); 7134 astFactory.addASTChild(currentAST, returnAST); 7135 } 7136 else { 7137 break _loop310; 7138 } 7139 7140 } while (true); 7141 } 7142 break; 7143 } 7144 case LITERAL_default: 7145 { 7146 AST tmp154_AST = null; 7147 tmp154_AST = astFactory.create(LT(1)); 7148 astFactory.makeASTRoot(currentAST, tmp154_AST); 7149 match(LITERAL_default); 7150 break; 7151 } 7152 default: 7153 { 7154 throw new NoViableAltException(LT(1), getFilename()); 7155 } 7156 } 7157 } 7158 { 7159 switch ( LA(1)) { 7160 case COLON: 7161 { 7162 AST tmp155_AST = null; 7163 tmp155_AST = astFactory.create(LT(1)); 7164 astFactory.addASTChild(currentAST, tmp155_AST); 7165 match(COLON); 7166 break; 7167 } 7168 case FINAL: 7169 case ABSTRACT: 7170 case STRICTFP: 7171 case SEMI: 7172 case LITERAL_void: 7173 case LITERAL_boolean: 7174 case LITERAL_byte: 7175 case LITERAL_char: 7176 case LITERAL_short: 7177 case LITERAL_int: 7178 case LITERAL_float: 7179 case LITERAL_long: 7180 case LITERAL_double: 7181 case IDENT: 7182 case LITERAL_private: 7183 case LITERAL_public: 7184 case LITERAL_protected: 7185 case LITERAL_static: 7186 case LITERAL_transient: 7187 case LITERAL_native: 7188 case LITERAL_synchronized: 7189 case LITERAL_volatile: 7190 case LITERAL_class: 7191 case LCURLY: 7192 case RCURLY: 7193 case LPAREN: 7194 case LITERAL_this: 7195 case LITERAL_super: 7196 case LITERAL_if: 7197 case LITERAL_while: 7198 case LITERAL_do: 7199 case LITERAL_break: 7200 case LITERAL_continue: 7201 case LITERAL_return: 7202 case LITERAL_switch: 7203 case LITERAL_throw: 7204 case LITERAL_for: 7205 case LITERAL_case: 7206 case LITERAL_default: 7207 case LITERAL_try: 7208 case PLUS: 7209 case MINUS: 7210 case INC: 7211 case DEC: 7212 case BNOT: 7213 case LNOT: 7214 case LITERAL_true: 7215 case LITERAL_false: 7216 case LITERAL_null: 7217 case LITERAL_new: 7218 case NUM_INT: 7219 case CHAR_LITERAL: 7220 case STRING_LITERAL: 7221 case NUM_FLOAT: 7222 case NUM_LONG: 7223 case NUM_DOUBLE: 7224 case ASSERT: 7225 case AT: 7226 case LAMBDA: 7227 case LITERAL_record: 7228 case TEXT_BLOCK_CONTENT: 7229 case LITERAL_yield: 7230 case LITERAL_sealed: 7231 case LITERAL_permits: 7232 case LITERAL_non: 7233 { 7234 break; 7235 } 7236 default: 7237 { 7238 throw new NoViableAltException(LT(1), getFilename()); 7239 } 7240 } 7241 } 7242 switchLabel_AST = (AST)currentAST.root; 7243 returnAST = switchLabel_AST; 7244 } 7245 7246 public final void caseSList() throws RecognitionException, TokenStreamException { 7247 7248 returnAST = null; 7249 ASTPair currentAST = new ASTPair(); 7250 AST caseSList_AST = null; 7251 7252 { 7253 int _cnt295=0; 7254 _loop295: 7255 do { 7256 if (((_tokenSet_44.member(LA(1))) && (_tokenSet_79.member(LA(2))))&&(LA(1)!=LITERAL_default)) { 7257 statement(); 7258 astFactory.addASTChild(currentAST, returnAST); 7259 } 7260 else { 7261 if ( _cnt295>=1 ) { break _loop295; } else {throw new NoViableAltException(LT(1), getFilename());} 7262 } 7263 7264 _cnt295++; 7265 } while (true); 7266 } 7267 if ( inputState.guessing==0 ) { 7268 caseSList_AST = (AST)currentAST.root; 7269 caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).add(caseSList_AST)); 7270 currentAST.root = caseSList_AST; 7271 currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ? 7272 caseSList_AST.getFirstChild() : caseSList_AST; 7273 currentAST.advanceChildToEnd(); 7274 } 7275 caseSList_AST = (AST)currentAST.root; 7276 returnAST = caseSList_AST; 7277 } 7278 7279 public final void switchLabeledExpression() throws RecognitionException, TokenStreamException { 7280 7281 returnAST = null; 7282 ASTPair currentAST = new ASTPair(); 7283 AST switchLabeledExpression_AST = null; 7284 7285 switchLabel(); 7286 astFactory.addASTChild(currentAST, returnAST); 7287 AST tmp156_AST = null; 7288 tmp156_AST = astFactory.create(LT(1)); 7289 astFactory.addASTChild(currentAST, tmp156_AST); 7290 match(LAMBDA); 7291 expression(); 7292 astFactory.addASTChild(currentAST, returnAST); 7293 AST tmp157_AST = null; 7294 tmp157_AST = astFactory.create(LT(1)); 7295 astFactory.addASTChild(currentAST, tmp157_AST); 7296 match(SEMI); 7297 switchLabeledExpression_AST = (AST)currentAST.root; 7298 returnAST = switchLabeledExpression_AST; 7299 } 7300 7301 public final void switchLabeledBlock() throws RecognitionException, TokenStreamException { 7302 7303 returnAST = null; 7304 ASTPair currentAST = new ASTPair(); 7305 AST switchLabeledBlock_AST = null; 7306 7307 switchLabel(); 7308 astFactory.addASTChild(currentAST, returnAST); 7309 AST tmp158_AST = null; 7310 tmp158_AST = astFactory.create(LT(1)); 7311 astFactory.addASTChild(currentAST, tmp158_AST); 7312 match(LAMBDA); 7313 compoundStatement(); 7314 astFactory.addASTChild(currentAST, returnAST); 7315 switchLabeledBlock_AST = (AST)currentAST.root; 7316 returnAST = switchLabeledBlock_AST; 7317 } 7318 7319 public final void switchLabeledThrow() throws RecognitionException, TokenStreamException { 7320 7321 returnAST = null; 7322 ASTPair currentAST = new ASTPair(); 7323 AST switchLabeledThrow_AST = null; 7324 7325 switchLabel(); 7326 astFactory.addASTChild(currentAST, returnAST); 7327 AST tmp159_AST = null; 7328 tmp159_AST = astFactory.create(LT(1)); 7329 astFactory.addASTChild(currentAST, tmp159_AST); 7330 match(LAMBDA); 7331 throwStatement(); 7332 astFactory.addASTChild(currentAST, returnAST); 7333 switchLabeledThrow_AST = (AST)currentAST.root; 7334 returnAST = switchLabeledThrow_AST; 7335 } 7336 7337 public final void caseConstant() throws RecognitionException, TokenStreamException { 7338 7339 returnAST = null; 7340 ASTPair currentAST = new ASTPair(); 7341 AST caseConstant_AST = null; 7342 7343 conditionalExpression(); 7344 astFactory.addASTChild(currentAST, returnAST); 7345 if ( inputState.guessing==0 ) { 7346 caseConstant_AST = (AST)currentAST.root; 7347 caseConstant_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(caseConstant_AST)); 7348 currentAST.root = caseConstant_AST; 7349 currentAST.child = caseConstant_AST!=null &&caseConstant_AST.getFirstChild()!=null ? 7350 caseConstant_AST.getFirstChild() : caseConstant_AST; 7351 currentAST.advanceChildToEnd(); 7352 } 7353 caseConstant_AST = (AST)currentAST.root; 7354 returnAST = caseConstant_AST; 7355 } 7356 7357 public final void expressionList() throws RecognitionException, TokenStreamException { 7358 7359 returnAST = null; 7360 ASTPair currentAST = new ASTPair(); 7361 AST expressionList_AST = null; 7362 7363 expression(); 7364 astFactory.addASTChild(currentAST, returnAST); 7365 { 7366 _loop346: 7367 do { 7368 if ((LA(1)==COMMA)) { 7369 AST tmp160_AST = null; 7370 tmp160_AST = astFactory.create(LT(1)); 7371 astFactory.addASTChild(currentAST, tmp160_AST); 7372 match(COMMA); 7373 expression(); 7374 astFactory.addASTChild(currentAST, returnAST); 7375 } 7376 else { 7377 break _loop346; 7378 } 7379 7380 } while (true); 7381 } 7382 if ( inputState.guessing==0 ) { 7383 expressionList_AST = (AST)currentAST.root; 7384 expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).add(expressionList_AST)); 7385 currentAST.root = expressionList_AST; 7386 currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ? 7387 expressionList_AST.getFirstChild() : expressionList_AST; 7388 currentAST.advanceChildToEnd(); 7389 } 7390 expressionList_AST = (AST)currentAST.root; 7391 returnAST = expressionList_AST; 7392 } 7393 7394 public final void resourceSpecification() throws RecognitionException, TokenStreamException { 7395 7396 returnAST = null; 7397 ASTPair currentAST = new ASTPair(); 7398 AST resourceSpecification_AST = null; 7399 7400 AST tmp161_AST = null; 7401 tmp161_AST = astFactory.create(LT(1)); 7402 astFactory.addASTChild(currentAST, tmp161_AST); 7403 match(LPAREN); 7404 resources(); 7405 astFactory.addASTChild(currentAST, returnAST); 7406 { 7407 switch ( LA(1)) { 7408 case SEMI: 7409 { 7410 AST tmp162_AST = null; 7411 tmp162_AST = astFactory.create(LT(1)); 7412 astFactory.addASTChild(currentAST, tmp162_AST); 7413 match(SEMI); 7414 break; 7415 } 7416 case RPAREN: 7417 { 7418 break; 7419 } 7420 default: 7421 { 7422 throw new NoViableAltException(LT(1), getFilename()); 7423 } 7424 } 7425 } 7426 AST tmp163_AST = null; 7427 tmp163_AST = astFactory.create(LT(1)); 7428 astFactory.addASTChild(currentAST, tmp163_AST); 7429 match(RPAREN); 7430 if ( inputState.guessing==0 ) { 7431 resourceSpecification_AST = (AST)currentAST.root; 7432 resourceSpecification_AST = 7433 (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE_SPECIFICATION,"RESOURCE_SPECIFICATION")).add(resourceSpecification_AST)); 7434 currentAST.root = resourceSpecification_AST; 7435 currentAST.child = resourceSpecification_AST!=null &&resourceSpecification_AST.getFirstChild()!=null ? 7436 resourceSpecification_AST.getFirstChild() : resourceSpecification_AST; 7437 currentAST.advanceChildToEnd(); 7438 } 7439 resourceSpecification_AST = (AST)currentAST.root; 7440 returnAST = resourceSpecification_AST; 7441 } 7442 7443 public final void handler() throws RecognitionException, TokenStreamException { 7444 7445 returnAST = null; 7446 ASTPair currentAST = new ASTPair(); 7447 AST handler_AST = null; 7448 7449 AST tmp164_AST = null; 7450 tmp164_AST = astFactory.create(LT(1)); 7451 astFactory.makeASTRoot(currentAST, tmp164_AST); 7452 match(LITERAL_catch); 7453 AST tmp165_AST = null; 7454 tmp165_AST = astFactory.create(LT(1)); 7455 astFactory.addASTChild(currentAST, tmp165_AST); 7456 match(LPAREN); 7457 catchParameterDeclaration(); 7458 astFactory.addASTChild(currentAST, returnAST); 7459 AST tmp166_AST = null; 7460 tmp166_AST = astFactory.create(LT(1)); 7461 astFactory.addASTChild(currentAST, tmp166_AST); 7462 match(RPAREN); 7463 compoundStatement(); 7464 astFactory.addASTChild(currentAST, returnAST); 7465 handler_AST = (AST)currentAST.root; 7466 returnAST = handler_AST; 7467 } 7468 7469 public final void finallyHandler() throws RecognitionException, TokenStreamException { 7470 7471 returnAST = null; 7472 ASTPair currentAST = new ASTPair(); 7473 AST finallyHandler_AST = null; 7474 7475 AST tmp167_AST = null; 7476 tmp167_AST = astFactory.create(LT(1)); 7477 astFactory.makeASTRoot(currentAST, tmp167_AST); 7478 match(LITERAL_finally); 7479 compoundStatement(); 7480 astFactory.addASTChild(currentAST, returnAST); 7481 finallyHandler_AST = (AST)currentAST.root; 7482 returnAST = finallyHandler_AST; 7483 } 7484 7485 public final void resources() throws RecognitionException, TokenStreamException { 7486 7487 returnAST = null; 7488 ASTPair currentAST = new ASTPair(); 7489 AST resources_AST = null; 7490 7491 resource(); 7492 astFactory.addASTChild(currentAST, returnAST); 7493 { 7494 _loop331: 7495 do { 7496 if ((LA(1)==SEMI) && (_tokenSet_80.member(LA(2)))) { 7497 AST tmp168_AST = null; 7498 tmp168_AST = astFactory.create(LT(1)); 7499 astFactory.addASTChild(currentAST, tmp168_AST); 7500 match(SEMI); 7501 resource(); 7502 astFactory.addASTChild(currentAST, returnAST); 7503 } 7504 else { 7505 break _loop331; 7506 } 7507 7508 } while (true); 7509 } 7510 if ( inputState.guessing==0 ) { 7511 resources_AST = (AST)currentAST.root; 7512 resources_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCES,"RESOURCES")).add(resources_AST)); 7513 currentAST.root = resources_AST; 7514 currentAST.child = resources_AST!=null &&resources_AST.getFirstChild()!=null ? 7515 resources_AST.getFirstChild() : resources_AST; 7516 currentAST.advanceChildToEnd(); 7517 } 7518 resources_AST = (AST)currentAST.root; 7519 returnAST = resources_AST; 7520 } 7521 7522 public final void resource() throws RecognitionException, TokenStreamException { 7523 7524 returnAST = null; 7525 ASTPair currentAST = new ASTPair(); 7526 AST resource_AST = null; 7527 7528 boolean synPredMatched334 = false; 7529 if (((_tokenSet_50.member(LA(1))) && (_tokenSet_81.member(LA(2))))) { 7530 int _m334 = mark(); 7531 synPredMatched334 = true; 7532 inputState.guessing++; 7533 try { 7534 { 7535 tryResourceDeclaration(); 7536 } 7537 } 7538 catch (RecognitionException pe) { 7539 synPredMatched334 = false; 7540 } 7541 rewind(_m334); 7542inputState.guessing--; 7543 } 7544 if ( synPredMatched334 ) { 7545 tryResourceDeclaration(); 7546 astFactory.addASTChild(currentAST, returnAST); 7547 resource_AST = (AST)currentAST.root; 7548 } 7549 else if ((_tokenSet_56.member(LA(1))) && (_tokenSet_82.member(LA(2)))) { 7550 { 7551 _loop336: 7552 do { 7553 if ((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2)))) { 7554 primaryExpression(); 7555 astFactory.addASTChild(currentAST, returnAST); 7556 AST tmp169_AST = null; 7557 tmp169_AST = astFactory.create(LT(1)); 7558 astFactory.makeASTRoot(currentAST, tmp169_AST); 7559 match(DOT); 7560 } 7561 else { 7562 break _loop336; 7563 } 7564 7565 } while (true); 7566 } 7567 id(); 7568 astFactory.addASTChild(currentAST, returnAST); 7569 if ( inputState.guessing==0 ) { 7570 resource_AST = (AST)currentAST.root; 7571 resource_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE,"RESOURCE")).add(resource_AST)); 7572 currentAST.root = resource_AST; 7573 currentAST.child = resource_AST!=null &&resource_AST.getFirstChild()!=null ? 7574 resource_AST.getFirstChild() : resource_AST; 7575 currentAST.advanceChildToEnd(); 7576 } 7577 resource_AST = (AST)currentAST.root; 7578 } 7579 else { 7580 throw new NoViableAltException(LT(1), getFilename()); 7581 } 7582 7583 returnAST = resource_AST; 7584 } 7585 7586 public final void tryResourceDeclaration() throws RecognitionException, TokenStreamException { 7587 7588 returnAST = null; 7589 ASTPair currentAST = new ASTPair(); 7590 AST tryResourceDeclaration_AST = null; 7591 AST m_AST = null; 7592 AST t_AST = null; 7593 AST v_AST = null; 7594 7595 parameterModifier(); 7596 m_AST = (AST)returnAST; 7597 typeSpec(false); 7598 t_AST = (AST)returnAST; 7599 tryResourceDeclarator((AST) getASTFactory().dupTree(m_AST), 7600 //dupList as this also copies siblings (like TYPE_ARGUMENTS) 7601 (AST) getASTFactory().dupList(t_AST)); 7602 v_AST = (AST)returnAST; 7603 if ( inputState.guessing==0 ) { 7604 tryResourceDeclaration_AST = (AST)currentAST.root; 7605 tryResourceDeclaration_AST = v_AST; 7606 currentAST.root = tryResourceDeclaration_AST; 7607 currentAST.child = tryResourceDeclaration_AST!=null &&tryResourceDeclaration_AST.getFirstChild()!=null ? 7608 tryResourceDeclaration_AST.getFirstChild() : tryResourceDeclaration_AST; 7609 currentAST.advanceChildToEnd(); 7610 } 7611 returnAST = tryResourceDeclaration_AST; 7612 } 7613 7614 public final void tryResourceDeclarator( 7615 AST mods, AST t 7616 ) throws RecognitionException, TokenStreamException { 7617 7618 returnAST = null; 7619 ASTPair currentAST = new ASTPair(); 7620 AST tryResourceDeclarator_AST = null; 7621 AST id_AST = null; 7622 AST d_AST = null; 7623 AST v_AST = null; 7624 7625 id(); 7626 id_AST = (AST)returnAST; 7627 typeSpecBracketsAndAnnotationsNonGreedy(); 7628 d_AST = (AST)returnAST; 7629 varInitializer(); 7630 v_AST = (AST)returnAST; 7631 if ( inputState.guessing==0 ) { 7632 tryResourceDeclarator_AST = (AST)currentAST.root; 7633 tryResourceDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(RESOURCE,"RESOURCE")).add(mods).add((AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TYPE,"TYPE")).add(t).add(d_AST))).add(id_AST).add(v_AST)); 7634 currentAST.root = tryResourceDeclarator_AST; 7635 currentAST.child = tryResourceDeclarator_AST!=null &&tryResourceDeclarator_AST.getFirstChild()!=null ? 7636 tryResourceDeclarator_AST.getFirstChild() : tryResourceDeclarator_AST; 7637 currentAST.advanceChildToEnd(); 7638 } 7639 returnAST = tryResourceDeclarator_AST; 7640 } 7641 7642 public final void lambdaExpression() throws RecognitionException, TokenStreamException { 7643 7644 returnAST = null; 7645 ASTPair currentAST = new ASTPair(); 7646 AST lambdaExpression_AST = null; 7647 7648 lambdaParameters(); 7649 astFactory.addASTChild(currentAST, returnAST); 7650 AST tmp170_AST = null; 7651 tmp170_AST = astFactory.create(LT(1)); 7652 astFactory.makeASTRoot(currentAST, tmp170_AST); 7653 match(LAMBDA); 7654 lambdaBody(); 7655 astFactory.addASTChild(currentAST, returnAST); 7656 lambdaExpression_AST = (AST)currentAST.root; 7657 returnAST = lambdaExpression_AST; 7658 } 7659 7660 public final void assignmentExpression() throws RecognitionException, TokenStreamException { 7661 7662 returnAST = null; 7663 ASTPair currentAST = new ASTPair(); 7664 AST assignmentExpression_AST = null; 7665 7666 conditionalExpression(); 7667 astFactory.addASTChild(currentAST, returnAST); 7668 { 7669 switch ( LA(1)) { 7670 case ASSIGN: 7671 case PLUS_ASSIGN: 7672 case MINUS_ASSIGN: 7673 case STAR_ASSIGN: 7674 case DIV_ASSIGN: 7675 case MOD_ASSIGN: 7676 case SR_ASSIGN: 7677 case BSR_ASSIGN: 7678 case SL_ASSIGN: 7679 case BAND_ASSIGN: 7680 case BXOR_ASSIGN: 7681 case BOR_ASSIGN: 7682 { 7683 { 7684 switch ( LA(1)) { 7685 case ASSIGN: 7686 { 7687 AST tmp171_AST = null; 7688 tmp171_AST = astFactory.create(LT(1)); 7689 astFactory.makeASTRoot(currentAST, tmp171_AST); 7690 match(ASSIGN); 7691 break; 7692 } 7693 case PLUS_ASSIGN: 7694 { 7695 AST tmp172_AST = null; 7696 tmp172_AST = astFactory.create(LT(1)); 7697 astFactory.makeASTRoot(currentAST, tmp172_AST); 7698 match(PLUS_ASSIGN); 7699 break; 7700 } 7701 case MINUS_ASSIGN: 7702 { 7703 AST tmp173_AST = null; 7704 tmp173_AST = astFactory.create(LT(1)); 7705 astFactory.makeASTRoot(currentAST, tmp173_AST); 7706 match(MINUS_ASSIGN); 7707 break; 7708 } 7709 case STAR_ASSIGN: 7710 { 7711 AST tmp174_AST = null; 7712 tmp174_AST = astFactory.create(LT(1)); 7713 astFactory.makeASTRoot(currentAST, tmp174_AST); 7714 match(STAR_ASSIGN); 7715 break; 7716 } 7717 case DIV_ASSIGN: 7718 { 7719 AST tmp175_AST = null; 7720 tmp175_AST = astFactory.create(LT(1)); 7721 astFactory.makeASTRoot(currentAST, tmp175_AST); 7722 match(DIV_ASSIGN); 7723 break; 7724 } 7725 case MOD_ASSIGN: 7726 { 7727 AST tmp176_AST = null; 7728 tmp176_AST = astFactory.create(LT(1)); 7729 astFactory.makeASTRoot(currentAST, tmp176_AST); 7730 match(MOD_ASSIGN); 7731 break; 7732 } 7733 case SR_ASSIGN: 7734 { 7735 AST tmp177_AST = null; 7736 tmp177_AST = astFactory.create(LT(1)); 7737 astFactory.makeASTRoot(currentAST, tmp177_AST); 7738 match(SR_ASSIGN); 7739 break; 7740 } 7741 case BSR_ASSIGN: 7742 { 7743 AST tmp178_AST = null; 7744 tmp178_AST = astFactory.create(LT(1)); 7745 astFactory.makeASTRoot(currentAST, tmp178_AST); 7746 match(BSR_ASSIGN); 7747 break; 7748 } 7749 case SL_ASSIGN: 7750 { 7751 AST tmp179_AST = null; 7752 tmp179_AST = astFactory.create(LT(1)); 7753 astFactory.makeASTRoot(currentAST, tmp179_AST); 7754 match(SL_ASSIGN); 7755 break; 7756 } 7757 case BAND_ASSIGN: 7758 { 7759 AST tmp180_AST = null; 7760 tmp180_AST = astFactory.create(LT(1)); 7761 astFactory.makeASTRoot(currentAST, tmp180_AST); 7762 match(BAND_ASSIGN); 7763 break; 7764 } 7765 case BXOR_ASSIGN: 7766 { 7767 AST tmp181_AST = null; 7768 tmp181_AST = astFactory.create(LT(1)); 7769 astFactory.makeASTRoot(currentAST, tmp181_AST); 7770 match(BXOR_ASSIGN); 7771 break; 7772 } 7773 case BOR_ASSIGN: 7774 { 7775 AST tmp182_AST = null; 7776 tmp182_AST = astFactory.create(LT(1)); 7777 astFactory.makeASTRoot(currentAST, tmp182_AST); 7778 match(BOR_ASSIGN); 7779 break; 7780 } 7781 default: 7782 { 7783 throw new NoViableAltException(LT(1), getFilename()); 7784 } 7785 } 7786 } 7787 { 7788 boolean synPredMatched352 = false; 7789 if (((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2))))) { 7790 int _m352 = mark(); 7791 synPredMatched352 = true; 7792 inputState.guessing++; 7793 try { 7794 { 7795 lambdaExpression(); 7796 } 7797 } 7798 catch (RecognitionException pe) { 7799 synPredMatched352 = false; 7800 } 7801 rewind(_m352); 7802inputState.guessing--; 7803 } 7804 if ( synPredMatched352 ) { 7805 lambdaExpression(); 7806 astFactory.addASTChild(currentAST, returnAST); 7807 } 7808 else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_61.member(LA(2)))) { 7809 assignmentExpression(); 7810 astFactory.addASTChild(currentAST, returnAST); 7811 } 7812 else { 7813 throw new NoViableAltException(LT(1), getFilename()); 7814 } 7815 7816 } 7817 break; 7818 } 7819 case FINAL: 7820 case ABSTRACT: 7821 case STRICTFP: 7822 case SEMI: 7823 case RBRACK: 7824 case LITERAL_void: 7825 case LITERAL_boolean: 7826 case LITERAL_byte: 7827 case LITERAL_char: 7828 case LITERAL_short: 7829 case LITERAL_int: 7830 case LITERAL_float: 7831 case LITERAL_long: 7832 case LITERAL_double: 7833 case IDENT: 7834 case STAR: 7835 case LITERAL_private: 7836 case LITERAL_public: 7837 case LITERAL_protected: 7838 case LITERAL_static: 7839 case LITERAL_transient: 7840 case LITERAL_native: 7841 case LITERAL_synchronized: 7842 case LITERAL_volatile: 7843 case LITERAL_class: 7844 case LITERAL_interface: 7845 case LCURLY: 7846 case RCURLY: 7847 case COMMA: 7848 case LPAREN: 7849 case RPAREN: 7850 case LITERAL_this: 7851 case LITERAL_super: 7852 case COLON: 7853 case LITERAL_if: 7854 case LITERAL_while: 7855 case LITERAL_do: 7856 case LITERAL_break: 7857 case LITERAL_continue: 7858 case LITERAL_return: 7859 case LITERAL_switch: 7860 case LITERAL_throw: 7861 case LITERAL_for: 7862 case LITERAL_else: 7863 case LITERAL_case: 7864 case LITERAL_default: 7865 case LITERAL_try: 7866 case LT: 7867 case GT: 7868 case LE: 7869 case GE: 7870 case LITERAL_instanceof: 7871 case SL: 7872 case SR: 7873 case BSR: 7874 case PLUS: 7875 case MINUS: 7876 case DIV: 7877 case MOD: 7878 case INC: 7879 case DEC: 7880 case BNOT: 7881 case LNOT: 7882 case LITERAL_true: 7883 case LITERAL_false: 7884 case LITERAL_null: 7885 case LITERAL_new: 7886 case NUM_INT: 7887 case CHAR_LITERAL: 7888 case STRING_LITERAL: 7889 case NUM_FLOAT: 7890 case NUM_LONG: 7891 case NUM_DOUBLE: 7892 case ASSERT: 7893 case ENUM: 7894 case AT: 7895 case LITERAL_record: 7896 case TEXT_BLOCK_CONTENT: 7897 case LITERAL_yield: 7898 case LITERAL_sealed: 7899 case LITERAL_permits: 7900 case LITERAL_non: 7901 { 7902 break; 7903 } 7904 default: 7905 { 7906 throw new NoViableAltException(LT(1), getFilename()); 7907 } 7908 } 7909 } 7910 assignmentExpression_AST = (AST)currentAST.root; 7911 returnAST = assignmentExpression_AST; 7912 } 7913 7914 public final void logicalOrExpression() throws RecognitionException, TokenStreamException { 7915 7916 returnAST = null; 7917 ASTPair currentAST = new ASTPair(); 7918 AST logicalOrExpression_AST = null; 7919 7920 logicalAndExpression(); 7921 astFactory.addASTChild(currentAST, returnAST); 7922 { 7923 _loop363: 7924 do { 7925 if ((LA(1)==LOR)) { 7926 AST tmp183_AST = null; 7927 tmp183_AST = astFactory.create(LT(1)); 7928 astFactory.makeASTRoot(currentAST, tmp183_AST); 7929 match(LOR); 7930 logicalAndExpression(); 7931 astFactory.addASTChild(currentAST, returnAST); 7932 } 7933 else { 7934 break _loop363; 7935 } 7936 7937 } while (true); 7938 } 7939 logicalOrExpression_AST = (AST)currentAST.root; 7940 returnAST = logicalOrExpression_AST; 7941 } 7942 7943 public final void logicalAndExpression() throws RecognitionException, TokenStreamException { 7944 7945 returnAST = null; 7946 ASTPair currentAST = new ASTPair(); 7947 AST logicalAndExpression_AST = null; 7948 7949 inclusiveOrExpression(); 7950 astFactory.addASTChild(currentAST, returnAST); 7951 { 7952 _loop366: 7953 do { 7954 if ((LA(1)==LAND)) { 7955 AST tmp184_AST = null; 7956 tmp184_AST = astFactory.create(LT(1)); 7957 astFactory.makeASTRoot(currentAST, tmp184_AST); 7958 match(LAND); 7959 inclusiveOrExpression(); 7960 astFactory.addASTChild(currentAST, returnAST); 7961 } 7962 else { 7963 break _loop366; 7964 } 7965 7966 } while (true); 7967 } 7968 logicalAndExpression_AST = (AST)currentAST.root; 7969 returnAST = logicalAndExpression_AST; 7970 } 7971 7972 public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException { 7973 7974 returnAST = null; 7975 ASTPair currentAST = new ASTPair(); 7976 AST inclusiveOrExpression_AST = null; 7977 7978 exclusiveOrExpression(); 7979 astFactory.addASTChild(currentAST, returnAST); 7980 { 7981 _loop369: 7982 do { 7983 if ((LA(1)==BOR)) { 7984 AST tmp185_AST = null; 7985 tmp185_AST = astFactory.create(LT(1)); 7986 astFactory.makeASTRoot(currentAST, tmp185_AST); 7987 match(BOR); 7988 exclusiveOrExpression(); 7989 astFactory.addASTChild(currentAST, returnAST); 7990 } 7991 else { 7992 break _loop369; 7993 } 7994 7995 } while (true); 7996 } 7997 inclusiveOrExpression_AST = (AST)currentAST.root; 7998 returnAST = inclusiveOrExpression_AST; 7999 } 8000 8001 public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException { 8002 8003 returnAST = null; 8004 ASTPair currentAST = new ASTPair(); 8005 AST exclusiveOrExpression_AST = null; 8006 8007 andExpression(); 8008 astFactory.addASTChild(currentAST, returnAST); 8009 { 8010 _loop372: 8011 do { 8012 if ((LA(1)==BXOR)) { 8013 AST tmp186_AST = null; 8014 tmp186_AST = astFactory.create(LT(1)); 8015 astFactory.makeASTRoot(currentAST, tmp186_AST); 8016 match(BXOR); 8017 andExpression(); 8018 astFactory.addASTChild(currentAST, returnAST); 8019 } 8020 else { 8021 break _loop372; 8022 } 8023 8024 } while (true); 8025 } 8026 exclusiveOrExpression_AST = (AST)currentAST.root; 8027 returnAST = exclusiveOrExpression_AST; 8028 } 8029 8030 public final void andExpression() throws RecognitionException, TokenStreamException { 8031 8032 returnAST = null; 8033 ASTPair currentAST = new ASTPair(); 8034 AST andExpression_AST = null; 8035 8036 equalityExpression(); 8037 astFactory.addASTChild(currentAST, returnAST); 8038 { 8039 _loop375: 8040 do { 8041 if ((LA(1)==BAND)) { 8042 AST tmp187_AST = null; 8043 tmp187_AST = astFactory.create(LT(1)); 8044 astFactory.makeASTRoot(currentAST, tmp187_AST); 8045 match(BAND); 8046 equalityExpression(); 8047 astFactory.addASTChild(currentAST, returnAST); 8048 } 8049 else { 8050 break _loop375; 8051 } 8052 8053 } while (true); 8054 } 8055 andExpression_AST = (AST)currentAST.root; 8056 returnAST = andExpression_AST; 8057 } 8058 8059 public final void equalityExpression() throws RecognitionException, TokenStreamException { 8060 8061 returnAST = null; 8062 ASTPair currentAST = new ASTPair(); 8063 AST equalityExpression_AST = null; 8064 8065 relationalExpression(); 8066 astFactory.addASTChild(currentAST, returnAST); 8067 { 8068 _loop379: 8069 do { 8070 if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) { 8071 { 8072 switch ( LA(1)) { 8073 case NOT_EQUAL: 8074 { 8075 AST tmp188_AST = null; 8076 tmp188_AST = astFactory.create(LT(1)); 8077 astFactory.makeASTRoot(currentAST, tmp188_AST); 8078 match(NOT_EQUAL); 8079 break; 8080 } 8081 case EQUAL: 8082 { 8083 AST tmp189_AST = null; 8084 tmp189_AST = astFactory.create(LT(1)); 8085 astFactory.makeASTRoot(currentAST, tmp189_AST); 8086 match(EQUAL); 8087 break; 8088 } 8089 default: 8090 { 8091 throw new NoViableAltException(LT(1), getFilename()); 8092 } 8093 } 8094 } 8095 relationalExpression(); 8096 astFactory.addASTChild(currentAST, returnAST); 8097 } 8098 else { 8099 break _loop379; 8100 } 8101 8102 } while (true); 8103 } 8104 equalityExpression_AST = (AST)currentAST.root; 8105 returnAST = equalityExpression_AST; 8106 } 8107 8108 public final void relationalExpression() throws RecognitionException, TokenStreamException { 8109 8110 returnAST = null; 8111 ASTPair currentAST = new ASTPair(); 8112 AST relationalExpression_AST = null; 8113 8114 shiftExpression(); 8115 astFactory.addASTChild(currentAST, returnAST); 8116 { 8117 if ((LA(1)==LITERAL_instanceof) && (_tokenSet_67.member(LA(2)))) { 8118 AST tmp190_AST = null; 8119 tmp190_AST = astFactory.create(LT(1)); 8120 astFactory.makeASTRoot(currentAST, tmp190_AST); 8121 match(LITERAL_instanceof); 8122 { 8123 boolean synPredMatched384 = false; 8124 if (((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2))))) { 8125 int _m384 = mark(); 8126 synPredMatched384 = true; 8127 inputState.guessing++; 8128 try { 8129 { 8130 modifiers(); 8131 typeSpec(true); 8132 match(IDENT); 8133 } 8134 } 8135 catch (RecognitionException pe) { 8136 synPredMatched384 = false; 8137 } 8138 rewind(_m384); 8139inputState.guessing--; 8140 } 8141 if ( synPredMatched384 ) { 8142 patternDefinition(); 8143 astFactory.addASTChild(currentAST, returnAST); 8144 } 8145 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_83.member(LA(2)))) { 8146 instanceofTypeSpec(); 8147 astFactory.addASTChild(currentAST, returnAST); 8148 } 8149 else { 8150 throw new NoViableAltException(LT(1), getFilename()); 8151 } 8152 8153 } 8154 } 8155 else if ((_tokenSet_77.member(LA(1))) && (_tokenSet_60.member(LA(2)))) { 8156 } 8157 else { 8158 throw new NoViableAltException(LT(1), getFilename()); 8159 } 8160 8161 } 8162 { 8163 { 8164 _loop388: 8165 do { 8166 if (((LA(1) >= LT && LA(1) <= GE)) && (_tokenSet_19.member(LA(2)))) { 8167 { 8168 switch ( LA(1)) { 8169 case LT: 8170 { 8171 AST tmp191_AST = null; 8172 tmp191_AST = astFactory.create(LT(1)); 8173 astFactory.makeASTRoot(currentAST, tmp191_AST); 8174 match(LT); 8175 break; 8176 } 8177 case GT: 8178 { 8179 AST tmp192_AST = null; 8180 tmp192_AST = astFactory.create(LT(1)); 8181 astFactory.makeASTRoot(currentAST, tmp192_AST); 8182 match(GT); 8183 break; 8184 } 8185 case LE: 8186 { 8187 AST tmp193_AST = null; 8188 tmp193_AST = astFactory.create(LT(1)); 8189 astFactory.makeASTRoot(currentAST, tmp193_AST); 8190 match(LE); 8191 break; 8192 } 8193 case GE: 8194 { 8195 AST tmp194_AST = null; 8196 tmp194_AST = astFactory.create(LT(1)); 8197 astFactory.makeASTRoot(currentAST, tmp194_AST); 8198 match(GE); 8199 break; 8200 } 8201 default: 8202 { 8203 throw new NoViableAltException(LT(1), getFilename()); 8204 } 8205 } 8206 } 8207 shiftExpression(); 8208 astFactory.addASTChild(currentAST, returnAST); 8209 } 8210 else { 8211 break _loop388; 8212 } 8213 8214 } while (true); 8215 } 8216 } 8217 relationalExpression_AST = (AST)currentAST.root; 8218 returnAST = relationalExpression_AST; 8219 } 8220 8221 public final void shiftExpression() throws RecognitionException, TokenStreamException { 8222 8223 returnAST = null; 8224 ASTPair currentAST = new ASTPair(); 8225 AST shiftExpression_AST = null; 8226 8227 additiveExpression(); 8228 astFactory.addASTChild(currentAST, returnAST); 8229 { 8230 _loop395: 8231 do { 8232 if (((LA(1) >= SL && LA(1) <= BSR)) && (_tokenSet_19.member(LA(2)))) { 8233 { 8234 switch ( LA(1)) { 8235 case SL: 8236 { 8237 AST tmp195_AST = null; 8238 tmp195_AST = astFactory.create(LT(1)); 8239 astFactory.makeASTRoot(currentAST, tmp195_AST); 8240 match(SL); 8241 break; 8242 } 8243 case SR: 8244 { 8245 AST tmp196_AST = null; 8246 tmp196_AST = astFactory.create(LT(1)); 8247 astFactory.makeASTRoot(currentAST, tmp196_AST); 8248 match(SR); 8249 break; 8250 } 8251 case BSR: 8252 { 8253 AST tmp197_AST = null; 8254 tmp197_AST = astFactory.create(LT(1)); 8255 astFactory.makeASTRoot(currentAST, tmp197_AST); 8256 match(BSR); 8257 break; 8258 } 8259 default: 8260 { 8261 throw new NoViableAltException(LT(1), getFilename()); 8262 } 8263 } 8264 } 8265 additiveExpression(); 8266 astFactory.addASTChild(currentAST, returnAST); 8267 } 8268 else { 8269 break _loop395; 8270 } 8271 8272 } while (true); 8273 } 8274 shiftExpression_AST = (AST)currentAST.root; 8275 returnAST = shiftExpression_AST; 8276 } 8277 8278 public final void patternDefinition() throws RecognitionException, TokenStreamException { 8279 8280 returnAST = null; 8281 ASTPair currentAST = new ASTPair(); 8282 AST patternDefinition_AST = null; 8283 AST v_AST = null; 8284 8285 patternVariableDefinition(); 8286 v_AST = (AST)returnAST; 8287 if ( inputState.guessing==0 ) { 8288 patternDefinition_AST = (AST)currentAST.root; 8289 patternDefinition_AST = v_AST; 8290 currentAST.root = patternDefinition_AST; 8291 currentAST.child = patternDefinition_AST!=null &&patternDefinition_AST.getFirstChild()!=null ? 8292 patternDefinition_AST.getFirstChild() : patternDefinition_AST; 8293 currentAST.advanceChildToEnd(); 8294 } 8295 returnAST = patternDefinition_AST; 8296 } 8297 8298 public final void instanceofTypeSpec() throws RecognitionException, TokenStreamException { 8299 8300 returnAST = null; 8301 ASTPair currentAST = new ASTPair(); 8302 AST instanceofTypeSpec_AST = null; 8303 AST t_AST = null; 8304 8305 typeSpec(true); 8306 t_AST = (AST)returnAST; 8307 if ( inputState.guessing==0 ) { 8308 instanceofTypeSpec_AST = (AST)currentAST.root; 8309 instanceofTypeSpec_AST = t_AST; 8310 currentAST.root = instanceofTypeSpec_AST; 8311 currentAST.child = instanceofTypeSpec_AST!=null &&instanceofTypeSpec_AST.getFirstChild()!=null ? 8312 instanceofTypeSpec_AST.getFirstChild() : instanceofTypeSpec_AST; 8313 currentAST.advanceChildToEnd(); 8314 } 8315 returnAST = instanceofTypeSpec_AST; 8316 } 8317 8318 public final void patternVariableDefinition() throws RecognitionException, TokenStreamException { 8319 8320 returnAST = null; 8321 ASTPair currentAST = new ASTPair(); 8322 AST patternVariableDefinition_AST = null; 8323 AST m_AST = null; 8324 AST t_AST = null; 8325 Token i = null; 8326 AST i_AST = null; 8327 8328 modifiers(); 8329 m_AST = (AST)returnAST; 8330 typeSpec(true); 8331 t_AST = (AST)returnAST; 8332 i = LT(1); 8333 i_AST = astFactory.create(i); 8334 match(IDENT); 8335 if ( inputState.guessing==0 ) { 8336 patternVariableDefinition_AST = (AST)currentAST.root; 8337 patternVariableDefinition_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PATTERN_VARIABLE_DEF,"PATTERN_VARIABLE_DEF")).add(m_AST).add(t_AST).add(i_AST)); 8338 currentAST.root = patternVariableDefinition_AST; 8339 currentAST.child = patternVariableDefinition_AST!=null &&patternVariableDefinition_AST.getFirstChild()!=null ? 8340 patternVariableDefinition_AST.getFirstChild() : patternVariableDefinition_AST; 8341 currentAST.advanceChildToEnd(); 8342 } 8343 returnAST = patternVariableDefinition_AST; 8344 } 8345 8346 public final void additiveExpression() throws RecognitionException, TokenStreamException { 8347 8348 returnAST = null; 8349 ASTPair currentAST = new ASTPair(); 8350 AST additiveExpression_AST = null; 8351 8352 multiplicativeExpression(); 8353 astFactory.addASTChild(currentAST, returnAST); 8354 { 8355 _loop399: 8356 do { 8357 if ((LA(1)==PLUS||LA(1)==MINUS) && (_tokenSet_19.member(LA(2)))) { 8358 { 8359 switch ( LA(1)) { 8360 case PLUS: 8361 { 8362 AST tmp198_AST = null; 8363 tmp198_AST = astFactory.create(LT(1)); 8364 astFactory.makeASTRoot(currentAST, tmp198_AST); 8365 match(PLUS); 8366 break; 8367 } 8368 case MINUS: 8369 { 8370 AST tmp199_AST = null; 8371 tmp199_AST = astFactory.create(LT(1)); 8372 astFactory.makeASTRoot(currentAST, tmp199_AST); 8373 match(MINUS); 8374 break; 8375 } 8376 default: 8377 { 8378 throw new NoViableAltException(LT(1), getFilename()); 8379 } 8380 } 8381 } 8382 multiplicativeExpression(); 8383 astFactory.addASTChild(currentAST, returnAST); 8384 } 8385 else { 8386 break _loop399; 8387 } 8388 8389 } while (true); 8390 } 8391 additiveExpression_AST = (AST)currentAST.root; 8392 returnAST = additiveExpression_AST; 8393 } 8394 8395 public final void multiplicativeExpression() throws RecognitionException, TokenStreamException { 8396 8397 returnAST = null; 8398 ASTPair currentAST = new ASTPair(); 8399 AST multiplicativeExpression_AST = null; 8400 8401 unaryExpression(); 8402 astFactory.addASTChild(currentAST, returnAST); 8403 { 8404 _loop403: 8405 do { 8406 if ((_tokenSet_84.member(LA(1))) && (_tokenSet_19.member(LA(2)))) { 8407 { 8408 switch ( LA(1)) { 8409 case STAR: 8410 { 8411 AST tmp200_AST = null; 8412 tmp200_AST = astFactory.create(LT(1)); 8413 astFactory.makeASTRoot(currentAST, tmp200_AST); 8414 match(STAR); 8415 break; 8416 } 8417 case DIV: 8418 { 8419 AST tmp201_AST = null; 8420 tmp201_AST = astFactory.create(LT(1)); 8421 astFactory.makeASTRoot(currentAST, tmp201_AST); 8422 match(DIV); 8423 break; 8424 } 8425 case MOD: 8426 { 8427 AST tmp202_AST = null; 8428 tmp202_AST = astFactory.create(LT(1)); 8429 astFactory.makeASTRoot(currentAST, tmp202_AST); 8430 match(MOD); 8431 break; 8432 } 8433 default: 8434 { 8435 throw new NoViableAltException(LT(1), getFilename()); 8436 } 8437 } 8438 } 8439 unaryExpression(); 8440 astFactory.addASTChild(currentAST, returnAST); 8441 } 8442 else { 8443 break _loop403; 8444 } 8445 8446 } while (true); 8447 } 8448 multiplicativeExpression_AST = (AST)currentAST.root; 8449 returnAST = multiplicativeExpression_AST; 8450 } 8451 8452 public final void unaryExpression() throws RecognitionException, TokenStreamException { 8453 8454 returnAST = null; 8455 ASTPair currentAST = new ASTPair(); 8456 AST unaryExpression_AST = null; 8457 8458 switch ( LA(1)) { 8459 case INC: 8460 { 8461 AST tmp203_AST = null; 8462 tmp203_AST = astFactory.create(LT(1)); 8463 astFactory.makeASTRoot(currentAST, tmp203_AST); 8464 match(INC); 8465 unaryExpression(); 8466 astFactory.addASTChild(currentAST, returnAST); 8467 unaryExpression_AST = (AST)currentAST.root; 8468 break; 8469 } 8470 case DEC: 8471 { 8472 AST tmp204_AST = null; 8473 tmp204_AST = astFactory.create(LT(1)); 8474 astFactory.makeASTRoot(currentAST, tmp204_AST); 8475 match(DEC); 8476 unaryExpression(); 8477 astFactory.addASTChild(currentAST, returnAST); 8478 unaryExpression_AST = (AST)currentAST.root; 8479 break; 8480 } 8481 case MINUS: 8482 { 8483 AST tmp205_AST = null; 8484 tmp205_AST = astFactory.create(LT(1)); 8485 astFactory.makeASTRoot(currentAST, tmp205_AST); 8486 match(MINUS); 8487 if ( inputState.guessing==0 ) { 8488 tmp205_AST.setType(UNARY_MINUS); 8489 } 8490 unaryExpression(); 8491 astFactory.addASTChild(currentAST, returnAST); 8492 unaryExpression_AST = (AST)currentAST.root; 8493 break; 8494 } 8495 case PLUS: 8496 { 8497 AST tmp206_AST = null; 8498 tmp206_AST = astFactory.create(LT(1)); 8499 astFactory.makeASTRoot(currentAST, tmp206_AST); 8500 match(PLUS); 8501 if ( inputState.guessing==0 ) { 8502 tmp206_AST.setType(UNARY_PLUS); 8503 } 8504 unaryExpression(); 8505 astFactory.addASTChild(currentAST, returnAST); 8506 unaryExpression_AST = (AST)currentAST.root; 8507 break; 8508 } 8509 case LITERAL_void: 8510 case LITERAL_boolean: 8511 case LITERAL_byte: 8512 case LITERAL_char: 8513 case LITERAL_short: 8514 case LITERAL_int: 8515 case LITERAL_float: 8516 case LITERAL_long: 8517 case LITERAL_double: 8518 case IDENT: 8519 case LPAREN: 8520 case LITERAL_this: 8521 case LITERAL_super: 8522 case LITERAL_switch: 8523 case BNOT: 8524 case LNOT: 8525 case LITERAL_true: 8526 case LITERAL_false: 8527 case LITERAL_null: 8528 case LITERAL_new: 8529 case NUM_INT: 8530 case CHAR_LITERAL: 8531 case STRING_LITERAL: 8532 case NUM_FLOAT: 8533 case NUM_LONG: 8534 case NUM_DOUBLE: 8535 case AT: 8536 case LITERAL_record: 8537 case TEXT_BLOCK_CONTENT: 8538 case LITERAL_yield: 8539 case LITERAL_sealed: 8540 case LITERAL_permits: 8541 case LITERAL_non: 8542 { 8543 unaryExpressionNotPlusMinus(); 8544 astFactory.addASTChild(currentAST, returnAST); 8545 unaryExpression_AST = (AST)currentAST.root; 8546 break; 8547 } 8548 default: 8549 { 8550 throw new NoViableAltException(LT(1), getFilename()); 8551 } 8552 } 8553 returnAST = unaryExpression_AST; 8554 } 8555 8556 public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException { 8557 8558 returnAST = null; 8559 ASTPair currentAST = new ASTPair(); 8560 AST unaryExpressionNotPlusMinus_AST = null; 8561 8562 switch ( LA(1)) { 8563 case BNOT: 8564 { 8565 AST tmp207_AST = null; 8566 tmp207_AST = astFactory.create(LT(1)); 8567 astFactory.makeASTRoot(currentAST, tmp207_AST); 8568 match(BNOT); 8569 unaryExpression(); 8570 astFactory.addASTChild(currentAST, returnAST); 8571 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 8572 break; 8573 } 8574 case LNOT: 8575 { 8576 AST tmp208_AST = null; 8577 tmp208_AST = astFactory.create(LT(1)); 8578 astFactory.makeASTRoot(currentAST, tmp208_AST); 8579 match(LNOT); 8580 unaryExpression(); 8581 astFactory.addASTChild(currentAST, returnAST); 8582 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 8583 break; 8584 } 8585 case LITERAL_void: 8586 case LITERAL_boolean: 8587 case LITERAL_byte: 8588 case LITERAL_char: 8589 case LITERAL_short: 8590 case LITERAL_int: 8591 case LITERAL_float: 8592 case LITERAL_long: 8593 case LITERAL_double: 8594 case IDENT: 8595 case LPAREN: 8596 case LITERAL_this: 8597 case LITERAL_super: 8598 case LITERAL_true: 8599 case LITERAL_false: 8600 case LITERAL_null: 8601 case LITERAL_new: 8602 case NUM_INT: 8603 case CHAR_LITERAL: 8604 case STRING_LITERAL: 8605 case NUM_FLOAT: 8606 case NUM_LONG: 8607 case NUM_DOUBLE: 8608 case AT: 8609 case LITERAL_record: 8610 case TEXT_BLOCK_CONTENT: 8611 case LITERAL_yield: 8612 case LITERAL_sealed: 8613 case LITERAL_permits: 8614 case LITERAL_non: 8615 { 8616 castExpression(); 8617 astFactory.addASTChild(currentAST, returnAST); 8618 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 8619 break; 8620 } 8621 case LITERAL_switch: 8622 { 8623 switchExpression(); 8624 astFactory.addASTChild(currentAST, returnAST); 8625 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 8626 break; 8627 } 8628 default: 8629 { 8630 throw new NoViableAltException(LT(1), getFilename()); 8631 } 8632 } 8633 returnAST = unaryExpressionNotPlusMinus_AST; 8634 } 8635 8636 public final void castExpression() throws RecognitionException, TokenStreamException { 8637 8638 returnAST = null; 8639 ASTPair currentAST = new ASTPair(); 8640 AST castExpression_AST = null; 8641 Token lpb = null; 8642 AST lpb_AST = null; 8643 Token lpl = null; 8644 AST lpl_AST = null; 8645 Token lp = null; 8646 AST lp_AST = null; 8647 8648 { 8649 boolean synPredMatched409 = false; 8650 if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) { 8651 int _m409 = mark(); 8652 synPredMatched409 = true; 8653 inputState.guessing++; 8654 try { 8655 { 8656 match(LPAREN); 8657 builtInTypeSpec(true); 8658 match(RPAREN); 8659 unaryExpression(); 8660 } 8661 } 8662 catch (RecognitionException pe) { 8663 synPredMatched409 = false; 8664 } 8665 rewind(_m409); 8666inputState.guessing--; 8667 } 8668 if ( synPredMatched409 ) { 8669 lpb = LT(1); 8670 lpb_AST = astFactory.create(lpb); 8671 astFactory.makeASTRoot(currentAST, lpb_AST); 8672 match(LPAREN); 8673 if ( inputState.guessing==0 ) { 8674 lpb_AST.setType(TYPECAST); 8675 } 8676 builtInTypeSpec(true); 8677 astFactory.addASTChild(currentAST, returnAST); 8678 AST tmp209_AST = null; 8679 tmp209_AST = astFactory.create(LT(1)); 8680 astFactory.addASTChild(currentAST, tmp209_AST); 8681 match(RPAREN); 8682 unaryExpression(); 8683 astFactory.addASTChild(currentAST, returnAST); 8684 } 8685 else { 8686 boolean synPredMatched411 = false; 8687 if (((LA(1)==LPAREN) && (_tokenSet_10.member(LA(2))))) { 8688 int _m411 = mark(); 8689 synPredMatched411 = true; 8690 inputState.guessing++; 8691 try { 8692 { 8693 match(LPAREN); 8694 typeCastParameters(); 8695 match(RPAREN); 8696 lambdaExpression(); 8697 } 8698 } 8699 catch (RecognitionException pe) { 8700 synPredMatched411 = false; 8701 } 8702 rewind(_m411); 8703inputState.guessing--; 8704 } 8705 if ( synPredMatched411 ) { 8706 lpl = LT(1); 8707 lpl_AST = astFactory.create(lpl); 8708 astFactory.makeASTRoot(currentAST, lpl_AST); 8709 match(LPAREN); 8710 if ( inputState.guessing==0 ) { 8711 lpl_AST.setType(TYPECAST); 8712 } 8713 typeCastParameters(); 8714 astFactory.addASTChild(currentAST, returnAST); 8715 AST tmp210_AST = null; 8716 tmp210_AST = astFactory.create(LT(1)); 8717 astFactory.addASTChild(currentAST, tmp210_AST); 8718 match(RPAREN); 8719 lambdaExpression(); 8720 astFactory.addASTChild(currentAST, returnAST); 8721 } 8722 else { 8723 boolean synPredMatched413 = false; 8724 if (((LA(1)==LPAREN) && (_tokenSet_10.member(LA(2))))) { 8725 int _m413 = mark(); 8726 synPredMatched413 = true; 8727 inputState.guessing++; 8728 try { 8729 { 8730 match(LPAREN); 8731 typeCastParameters(); 8732 match(RPAREN); 8733 unaryExpressionNotPlusMinus(); 8734 } 8735 } 8736 catch (RecognitionException pe) { 8737 synPredMatched413 = false; 8738 } 8739 rewind(_m413); 8740inputState.guessing--; 8741 } 8742 if ( synPredMatched413 ) { 8743 lp = LT(1); 8744 lp_AST = astFactory.create(lp); 8745 astFactory.makeASTRoot(currentAST, lp_AST); 8746 match(LPAREN); 8747 if ( inputState.guessing==0 ) { 8748 lp_AST.setType(TYPECAST); 8749 } 8750 typeCastParameters(); 8751 astFactory.addASTChild(currentAST, returnAST); 8752 AST tmp211_AST = null; 8753 tmp211_AST = astFactory.create(LT(1)); 8754 astFactory.addASTChild(currentAST, tmp211_AST); 8755 match(RPAREN); 8756 unaryExpressionNotPlusMinus(); 8757 astFactory.addASTChild(currentAST, returnAST); 8758 } 8759 else if ((_tokenSet_56.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { 8760 postfixExpression(); 8761 astFactory.addASTChild(currentAST, returnAST); 8762 } 8763 else { 8764 throw new NoViableAltException(LT(1), getFilename()); 8765 } 8766 }} 8767 } 8768 castExpression_AST = (AST)currentAST.root; 8769 returnAST = castExpression_AST; 8770 } 8771 8772 public final void typeCastParameters() throws RecognitionException, TokenStreamException { 8773 8774 returnAST = null; 8775 ASTPair currentAST = new ASTPair(); 8776 AST typeCastParameters_AST = null; 8777 Token b = null; 8778 AST b_AST = null; 8779 8780 classTypeSpec(true); 8781 astFactory.addASTChild(currentAST, returnAST); 8782 { 8783 _loop417: 8784 do { 8785 if ((LA(1)==BAND)) { 8786 b = LT(1); 8787 b_AST = astFactory.create(b); 8788 astFactory.addASTChild(currentAST, b_AST); 8789 match(BAND); 8790 if ( inputState.guessing==0 ) { 8791 b_AST.setType(TYPE_EXTENSION_AND); 8792 } 8793 classTypeSpec(true); 8794 astFactory.addASTChild(currentAST, returnAST); 8795 } 8796 else { 8797 break _loop417; 8798 } 8799 8800 } while (true); 8801 } 8802 typeCastParameters_AST = (AST)currentAST.root; 8803 returnAST = typeCastParameters_AST; 8804 } 8805 8806 public final void postfixExpression() throws RecognitionException, TokenStreamException { 8807 8808 returnAST = null; 8809 ASTPair currentAST = new ASTPair(); 8810 AST postfixExpression_AST = null; 8811 Token dc = null; 8812 AST dc_AST = null; 8813 Token lb = null; 8814 AST lb_AST = null; 8815 Token lp = null; 8816 AST lp_AST = null; 8817 Token in = null; 8818 AST in_AST = null; 8819 Token de = null; 8820 AST de_AST = null; 8821 8822 primaryExpression(); 8823 astFactory.addASTChild(currentAST, returnAST); 8824 { 8825 _loop429: 8826 do { 8827 switch ( LA(1)) { 8828 case DOT: 8829 { 8830 AST tmp212_AST = null; 8831 tmp212_AST = astFactory.create(LT(1)); 8832 astFactory.makeASTRoot(currentAST, tmp212_AST); 8833 match(DOT); 8834 { 8835 switch ( LA(1)) { 8836 case IDENT: 8837 case LITERAL_this: 8838 case LITERAL_super: 8839 case LT: 8840 case LITERAL_record: 8841 case LITERAL_yield: 8842 case LITERAL_sealed: 8843 case LITERAL_permits: 8844 case LITERAL_non: 8845 { 8846 { 8847 switch ( LA(1)) { 8848 case LT: 8849 { 8850 typeArguments(false); 8851 astFactory.addASTChild(currentAST, returnAST); 8852 break; 8853 } 8854 case IDENT: 8855 case LITERAL_this: 8856 case LITERAL_super: 8857 case LITERAL_record: 8858 case LITERAL_yield: 8859 case LITERAL_sealed: 8860 case LITERAL_permits: 8861 case LITERAL_non: 8862 { 8863 break; 8864 } 8865 default: 8866 { 8867 throw new NoViableAltException(LT(1), getFilename()); 8868 } 8869 } 8870 } 8871 { 8872 switch ( LA(1)) { 8873 case IDENT: 8874 case LITERAL_record: 8875 case LITERAL_yield: 8876 case LITERAL_sealed: 8877 case LITERAL_permits: 8878 case LITERAL_non: 8879 { 8880 id(); 8881 astFactory.addASTChild(currentAST, returnAST); 8882 break; 8883 } 8884 case LITERAL_this: 8885 { 8886 AST tmp213_AST = null; 8887 tmp213_AST = astFactory.create(LT(1)); 8888 astFactory.addASTChild(currentAST, tmp213_AST); 8889 match(LITERAL_this); 8890 break; 8891 } 8892 case LITERAL_super: 8893 { 8894 AST tmp214_AST = null; 8895 tmp214_AST = astFactory.create(LT(1)); 8896 astFactory.addASTChild(currentAST, tmp214_AST); 8897 match(LITERAL_super); 8898 break; 8899 } 8900 default: 8901 { 8902 throw new NoViableAltException(LT(1), getFilename()); 8903 } 8904 } 8905 } 8906 break; 8907 } 8908 case LITERAL_class: 8909 { 8910 AST tmp215_AST = null; 8911 tmp215_AST = astFactory.create(LT(1)); 8912 astFactory.addASTChild(currentAST, tmp215_AST); 8913 match(LITERAL_class); 8914 break; 8915 } 8916 case LITERAL_new: 8917 { 8918 newExpression(); 8919 astFactory.addASTChild(currentAST, returnAST); 8920 break; 8921 } 8922 default: 8923 { 8924 throw new NoViableAltException(LT(1), getFilename()); 8925 } 8926 } 8927 } 8928 break; 8929 } 8930 case DOUBLE_COLON: 8931 { 8932 dc = LT(1); 8933 dc_AST = astFactory.create(dc); 8934 astFactory.makeASTRoot(currentAST, dc_AST); 8935 match(DOUBLE_COLON); 8936 if ( inputState.guessing==0 ) { 8937 dc_AST.setType(METHOD_REF); 8938 } 8939 { 8940 { 8941 switch ( LA(1)) { 8942 case LT: 8943 { 8944 typeArguments(false); 8945 astFactory.addASTChild(currentAST, returnAST); 8946 break; 8947 } 8948 case IDENT: 8949 case LITERAL_new: 8950 case LITERAL_record: 8951 case LITERAL_yield: 8952 case LITERAL_sealed: 8953 case LITERAL_permits: 8954 case LITERAL_non: 8955 { 8956 break; 8957 } 8958 default: 8959 { 8960 throw new NoViableAltException(LT(1), getFilename()); 8961 } 8962 } 8963 } 8964 { 8965 switch ( LA(1)) { 8966 case IDENT: 8967 case LITERAL_record: 8968 case LITERAL_yield: 8969 case LITERAL_sealed: 8970 case LITERAL_permits: 8971 case LITERAL_non: 8972 { 8973 id(); 8974 astFactory.addASTChild(currentAST, returnAST); 8975 break; 8976 } 8977 case LITERAL_new: 8978 { 8979 AST tmp216_AST = null; 8980 tmp216_AST = astFactory.create(LT(1)); 8981 astFactory.addASTChild(currentAST, tmp216_AST); 8982 match(LITERAL_new); 8983 break; 8984 } 8985 default: 8986 { 8987 throw new NoViableAltException(LT(1), getFilename()); 8988 } 8989 } 8990 } 8991 } 8992 break; 8993 } 8994 default: 8995 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 8996 { 8997 int _cnt427=0; 8998 _loop427: 8999 do { 9000 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 9001 brackets(); 9002 astFactory.addASTChild(currentAST, returnAST); 9003 } 9004 else { 9005 if ( _cnt427>=1 ) { break _loop427; } else {throw new NoViableAltException(LT(1), getFilename());} 9006 } 9007 9008 _cnt427++; 9009 } while (true); 9010 } 9011 { 9012 if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) { 9013 AST tmp217_AST = null; 9014 tmp217_AST = astFactory.create(LT(1)); 9015 astFactory.makeASTRoot(currentAST, tmp217_AST); 9016 match(DOT); 9017 AST tmp218_AST = null; 9018 tmp218_AST = astFactory.create(LT(1)); 9019 astFactory.addASTChild(currentAST, tmp218_AST); 9020 match(LITERAL_class); 9021 } 9022 else if ((_tokenSet_59.member(LA(1))) && (_tokenSet_60.member(LA(2)))) { 9023 } 9024 else { 9025 throw new NoViableAltException(LT(1), getFilename()); 9026 } 9027 9028 } 9029 } 9030 else if ((LA(1)==LBRACK) && (_tokenSet_19.member(LA(2)))) { 9031 lb = LT(1); 9032 lb_AST = astFactory.create(lb); 9033 astFactory.makeASTRoot(currentAST, lb_AST); 9034 match(LBRACK); 9035 if ( inputState.guessing==0 ) { 9036 lb_AST.setType(INDEX_OP); 9037 } 9038 expression(); 9039 astFactory.addASTChild(currentAST, returnAST); 9040 AST tmp219_AST = null; 9041 tmp219_AST = astFactory.create(LT(1)); 9042 astFactory.addASTChild(currentAST, tmp219_AST); 9043 match(RBRACK); 9044 } 9045 else if ((LA(1)==LPAREN) && (_tokenSet_85.member(LA(2)))) { 9046 lp = LT(1); 9047 lp_AST = astFactory.create(lp); 9048 astFactory.makeASTRoot(currentAST, lp_AST); 9049 match(LPAREN); 9050 if ( inputState.guessing==0 ) { 9051 lp_AST.setType(METHOD_CALL); 9052 } 9053 argList(); 9054 astFactory.addASTChild(currentAST, returnAST); 9055 AST tmp220_AST = null; 9056 tmp220_AST = astFactory.create(LT(1)); 9057 astFactory.addASTChild(currentAST, tmp220_AST); 9058 match(RPAREN); 9059 } 9060 else { 9061 break _loop429; 9062 } 9063 } 9064 } while (true); 9065 } 9066 { 9067 if ((LA(1)==INC) && (_tokenSet_77.member(LA(2)))) { 9068 in = LT(1); 9069 in_AST = astFactory.create(in); 9070 astFactory.makeASTRoot(currentAST, in_AST); 9071 match(INC); 9072 if ( inputState.guessing==0 ) { 9073 in_AST.setType(POST_INC); 9074 } 9075 } 9076 else if ((LA(1)==DEC) && (_tokenSet_77.member(LA(2)))) { 9077 de = LT(1); 9078 de_AST = astFactory.create(de); 9079 astFactory.makeASTRoot(currentAST, de_AST); 9080 match(DEC); 9081 if ( inputState.guessing==0 ) { 9082 de_AST.setType(POST_DEC); 9083 } 9084 } 9085 else if ((_tokenSet_77.member(LA(1))) && (_tokenSet_60.member(LA(2)))) { 9086 } 9087 else { 9088 throw new NoViableAltException(LT(1), getFilename()); 9089 } 9090 9091 } 9092 postfixExpression_AST = (AST)currentAST.root; 9093 returnAST = postfixExpression_AST; 9094 } 9095 9096/** object instantiation. 9097 * Trees are built as illustrated by the following input/tree pairs: 9098 * 9099 * new T() 9100 * 9101 * new 9102 * | 9103 * T -- ELIST 9104 * | 9105 * arg1 -- arg2 -- .. -- argn 9106 * 9107 * new int[] 9108 * 9109 * new 9110 * | 9111 * int -- ARRAY_DECLARATOR 9112 * 9113 * new int[] {1,2} 9114 * 9115 * new 9116 * | 9117 * int -- ARRAY_DECLARATOR -- ARRAY_INIT 9118 * | 9119 * EXPR -- EXPR 9120 * | | 9121 * 1 2 9122 * 9123 * new int[3] 9124 * new 9125 * | 9126 * int -- ARRAY_DECLARATOR 9127 * | 9128 * EXPR 9129 * | 9130 * 3 9131 * 9132 * new int[1][2] 9133 * 9134 * new 9135 * | 9136 * int -- ARRAY_DECLARATOR 9137 * | 9138 * ARRAY_DECLARATOR -- EXPR 9139 * | | 9140 * EXPR 1 9141 * | 9142 * 2 9143 * 9144 * 9145 * @throws RecognitionException if recognition problem occurs. 9146 * @throws TokenStreamException if problem occurs while generating a stream of tokens. 9147 */ 9148 public final void newExpression() throws RecognitionException, TokenStreamException { 9149 9150 returnAST = null; 9151 ASTPair currentAST = new ASTPair(); 9152 AST newExpression_AST = null; 9153 9154 AST tmp221_AST = null; 9155 tmp221_AST = astFactory.create(LT(1)); 9156 astFactory.makeASTRoot(currentAST, tmp221_AST); 9157 match(LITERAL_new); 9158 { 9159 switch ( LA(1)) { 9160 case LT: 9161 { 9162 typeArguments(false); 9163 astFactory.addASTChild(currentAST, returnAST); 9164 break; 9165 } 9166 case LITERAL_void: 9167 case LITERAL_boolean: 9168 case LITERAL_byte: 9169 case LITERAL_char: 9170 case LITERAL_short: 9171 case LITERAL_int: 9172 case LITERAL_float: 9173 case LITERAL_long: 9174 case LITERAL_double: 9175 case IDENT: 9176 case AT: 9177 case LITERAL_record: 9178 case LITERAL_yield: 9179 case LITERAL_sealed: 9180 case LITERAL_permits: 9181 case LITERAL_non: 9182 { 9183 break; 9184 } 9185 default: 9186 { 9187 throw new NoViableAltException(LT(1), getFilename()); 9188 } 9189 } 9190 } 9191 type(); 9192 astFactory.addASTChild(currentAST, returnAST); 9193 { 9194 switch ( LA(1)) { 9195 case LPAREN: 9196 { 9197 AST tmp222_AST = null; 9198 tmp222_AST = astFactory.create(LT(1)); 9199 astFactory.addASTChild(currentAST, tmp222_AST); 9200 match(LPAREN); 9201 argList(); 9202 astFactory.addASTChild(currentAST, returnAST); 9203 AST tmp223_AST = null; 9204 tmp223_AST = astFactory.create(LT(1)); 9205 astFactory.addASTChild(currentAST, tmp223_AST); 9206 match(RPAREN); 9207 { 9208 if ((LA(1)==LCURLY) && (_tokenSet_38.member(LA(2)))) { 9209 classBlock(); 9210 astFactory.addASTChild(currentAST, returnAST); 9211 } 9212 else if ((_tokenSet_59.member(LA(1))) && (_tokenSet_60.member(LA(2)))) { 9213 } 9214 else { 9215 throw new NoViableAltException(LT(1), getFilename()); 9216 } 9217 9218 } 9219 break; 9220 } 9221 case LBRACK: 9222 case AT: 9223 { 9224 newArrayDeclarator(); 9225 astFactory.addASTChild(currentAST, returnAST); 9226 { 9227 if ((LA(1)==LCURLY) && (_tokenSet_86.member(LA(2)))) { 9228 arrayInitializer(); 9229 astFactory.addASTChild(currentAST, returnAST); 9230 } 9231 else if ((_tokenSet_59.member(LA(1))) && (_tokenSet_60.member(LA(2)))) { 9232 } 9233 else { 9234 throw new NoViableAltException(LT(1), getFilename()); 9235 } 9236 9237 } 9238 break; 9239 } 9240 default: 9241 { 9242 throw new NoViableAltException(LT(1), getFilename()); 9243 } 9244 } 9245 } 9246 newExpression_AST = (AST)currentAST.root; 9247 returnAST = newExpression_AST; 9248 } 9249 9250 public final void constant() throws RecognitionException, TokenStreamException { 9251 9252 returnAST = null; 9253 ASTPair currentAST = new ASTPair(); 9254 AST constant_AST = null; 9255 9256 switch ( LA(1)) { 9257 case NUM_INT: 9258 { 9259 AST tmp224_AST = null; 9260 tmp224_AST = astFactory.create(LT(1)); 9261 astFactory.addASTChild(currentAST, tmp224_AST); 9262 match(NUM_INT); 9263 constant_AST = (AST)currentAST.root; 9264 break; 9265 } 9266 case NUM_LONG: 9267 { 9268 AST tmp225_AST = null; 9269 tmp225_AST = astFactory.create(LT(1)); 9270 astFactory.addASTChild(currentAST, tmp225_AST); 9271 match(NUM_LONG); 9272 constant_AST = (AST)currentAST.root; 9273 break; 9274 } 9275 case NUM_FLOAT: 9276 { 9277 AST tmp226_AST = null; 9278 tmp226_AST = astFactory.create(LT(1)); 9279 astFactory.addASTChild(currentAST, tmp226_AST); 9280 match(NUM_FLOAT); 9281 constant_AST = (AST)currentAST.root; 9282 break; 9283 } 9284 case NUM_DOUBLE: 9285 { 9286 AST tmp227_AST = null; 9287 tmp227_AST = astFactory.create(LT(1)); 9288 astFactory.addASTChild(currentAST, tmp227_AST); 9289 match(NUM_DOUBLE); 9290 constant_AST = (AST)currentAST.root; 9291 break; 9292 } 9293 case CHAR_LITERAL: 9294 { 9295 AST tmp228_AST = null; 9296 tmp228_AST = astFactory.create(LT(1)); 9297 astFactory.addASTChild(currentAST, tmp228_AST); 9298 match(CHAR_LITERAL); 9299 constant_AST = (AST)currentAST.root; 9300 break; 9301 } 9302 case STRING_LITERAL: 9303 { 9304 AST tmp229_AST = null; 9305 tmp229_AST = astFactory.create(LT(1)); 9306 astFactory.addASTChild(currentAST, tmp229_AST); 9307 match(STRING_LITERAL); 9308 constant_AST = (AST)currentAST.root; 9309 break; 9310 } 9311 case TEXT_BLOCK_CONTENT: 9312 { 9313 textBlock(); 9314 astFactory.addASTChild(currentAST, returnAST); 9315 constant_AST = (AST)currentAST.root; 9316 break; 9317 } 9318 default: 9319 { 9320 throw new NoViableAltException(LT(1), getFilename()); 9321 } 9322 } 9323 returnAST = constant_AST; 9324 } 9325 9326 public final void newArrayDeclarator() throws RecognitionException, TokenStreamException { 9327 9328 returnAST = null; 9329 ASTPair currentAST = new ASTPair(); 9330 AST newArrayDeclarator_AST = null; 9331 9332 { 9333 int _cnt450=0; 9334 _loop450: 9335 do { 9336 if ((LA(1)==LBRACK||LA(1)==AT) && (_tokenSet_87.member(LA(2)))) { 9337 { 9338 if (((LA(1)==LBRACK||LA(1)==AT) && (_tokenSet_87.member(LA(2))))&&(LA(1) == AT)) { 9339 annotations(); 9340 astFactory.addASTChild(currentAST, returnAST); 9341 } 9342 else if ((LA(1)==LBRACK) && (_tokenSet_87.member(LA(2)))) { 9343 } 9344 else { 9345 throw new NoViableAltException(LT(1), getFilename()); 9346 } 9347 9348 } 9349 bracketsWithExpr(); 9350 astFactory.addASTChild(currentAST, returnAST); 9351 } 9352 else { 9353 if ( _cnt450>=1 ) { break _loop450; } else {throw new NoViableAltException(LT(1), getFilename());} 9354 } 9355 9356 _cnt450++; 9357 } while (true); 9358 } 9359 newArrayDeclarator_AST = (AST)currentAST.root; 9360 returnAST = newArrayDeclarator_AST; 9361 } 9362 9363 public final void bracketsWithExpr() throws RecognitionException, TokenStreamException { 9364 9365 returnAST = null; 9366 ASTPair currentAST = new ASTPair(); 9367 AST bracketsWithExpr_AST = null; 9368 Token lb = null; 9369 AST lb_AST = null; 9370 9371 lb = LT(1); 9372 lb_AST = astFactory.create(lb); 9373 astFactory.makeASTRoot(currentAST, lb_AST); 9374 match(LBRACK); 9375 if ( inputState.guessing==0 ) { 9376 lb_AST.setType(ARRAY_DECLARATOR); 9377 } 9378 { 9379 switch ( LA(1)) { 9380 case LITERAL_void: 9381 case LITERAL_boolean: 9382 case LITERAL_byte: 9383 case LITERAL_char: 9384 case LITERAL_short: 9385 case LITERAL_int: 9386 case LITERAL_float: 9387 case LITERAL_long: 9388 case LITERAL_double: 9389 case IDENT: 9390 case LPAREN: 9391 case LITERAL_this: 9392 case LITERAL_super: 9393 case LITERAL_switch: 9394 case PLUS: 9395 case MINUS: 9396 case INC: 9397 case DEC: 9398 case BNOT: 9399 case LNOT: 9400 case LITERAL_true: 9401 case LITERAL_false: 9402 case LITERAL_null: 9403 case LITERAL_new: 9404 case NUM_INT: 9405 case CHAR_LITERAL: 9406 case STRING_LITERAL: 9407 case NUM_FLOAT: 9408 case NUM_LONG: 9409 case NUM_DOUBLE: 9410 case AT: 9411 case LITERAL_record: 9412 case TEXT_BLOCK_CONTENT: 9413 case LITERAL_yield: 9414 case LITERAL_sealed: 9415 case LITERAL_permits: 9416 case LITERAL_non: 9417 { 9418 expression(); 9419 astFactory.addASTChild(currentAST, returnAST); 9420 break; 9421 } 9422 case RBRACK: 9423 { 9424 break; 9425 } 9426 default: 9427 { 9428 throw new NoViableAltException(LT(1), getFilename()); 9429 } 9430 } 9431 } 9432 AST tmp230_AST = null; 9433 tmp230_AST = astFactory.create(LT(1)); 9434 astFactory.addASTChild(currentAST, tmp230_AST); 9435 match(RBRACK); 9436 bracketsWithExpr_AST = (AST)currentAST.root; 9437 returnAST = bracketsWithExpr_AST; 9438 } 9439 9440 public final void textBlock() throws RecognitionException, TokenStreamException { 9441 9442 returnAST = null; 9443 ASTPair currentAST = new ASTPair(); 9444 AST textBlock_AST = null; 9445 Token c = null; 9446 AST c_AST = null; 9447 9448 c = LT(1); 9449 c_AST = astFactory.create(c); 9450 match(TEXT_BLOCK_CONTENT); 9451 AST tmp231_AST = null; 9452 tmp231_AST = astFactory.create(LT(1)); 9453 match(TEXT_BLOCK_LITERAL_END); 9454 AST tmp232_AST = null; 9455 tmp232_AST = astFactory.create(LT(1)); 9456 match(TEXT_BLOCK_LITERAL_BEGIN); 9457 if ( inputState.guessing==0 ) { 9458 textBlock_AST = (AST)currentAST.root; 9459 textBlock_AST=(AST)astFactory.make( (new ASTArray(3)).add(tmp232_AST).add(c_AST).add(tmp231_AST)); 9460 currentAST.root = textBlock_AST; 9461 currentAST.child = textBlock_AST!=null &&textBlock_AST.getFirstChild()!=null ? 9462 textBlock_AST.getFirstChild() : textBlock_AST; 9463 currentAST.advanceChildToEnd(); 9464 } 9465 returnAST = textBlock_AST; 9466 } 9467 9468 public final void lambdaParameters() throws RecognitionException, TokenStreamException { 9469 9470 returnAST = null; 9471 ASTPair currentAST = new ASTPair(); 9472 AST lambdaParameters_AST = null; 9473 9474 switch ( LA(1)) { 9475 case IDENT: 9476 case LITERAL_record: 9477 case LITERAL_yield: 9478 case LITERAL_sealed: 9479 case LITERAL_permits: 9480 case LITERAL_non: 9481 { 9482 id(); 9483 astFactory.addASTChild(currentAST, returnAST); 9484 lambdaParameters_AST = (AST)currentAST.root; 9485 break; 9486 } 9487 case LPAREN: 9488 { 9489 AST tmp233_AST = null; 9490 tmp233_AST = astFactory.create(LT(1)); 9491 astFactory.addASTChild(currentAST, tmp233_AST); 9492 match(LPAREN); 9493 { 9494 if ((_tokenSet_88.member(LA(1))) && (_tokenSet_89.member(LA(2)))) { 9495 parameterDeclarationList(); 9496 astFactory.addASTChild(currentAST, returnAST); 9497 } 9498 else if ((LA(1)==RPAREN) && (LA(2)==LAMBDA)) { 9499 } 9500 else { 9501 throw new NoViableAltException(LT(1), getFilename()); 9502 } 9503 9504 } 9505 AST tmp234_AST = null; 9506 tmp234_AST = astFactory.create(LT(1)); 9507 astFactory.addASTChild(currentAST, tmp234_AST); 9508 match(RPAREN); 9509 lambdaParameters_AST = (AST)currentAST.root; 9510 break; 9511 } 9512 default: 9513 { 9514 throw new NoViableAltException(LT(1), getFilename()); 9515 } 9516 } 9517 returnAST = lambdaParameters_AST; 9518 } 9519 9520 public final void lambdaBody() throws RecognitionException, TokenStreamException { 9521 9522 returnAST = null; 9523 ASTPair currentAST = new ASTPair(); 9524 AST lambdaBody_AST = null; 9525 9526 { 9527 if ((_tokenSet_19.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { 9528 expression(); 9529 astFactory.addASTChild(currentAST, returnAST); 9530 } 9531 else if ((_tokenSet_44.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { 9532 statement(); 9533 astFactory.addASTChild(currentAST, returnAST); 9534 } 9535 else { 9536 throw new NoViableAltException(LT(1), getFilename()); 9537 } 9538 9539 } 9540 lambdaBody_AST = (AST)currentAST.root; 9541 returnAST = lambdaBody_AST; 9542 } 9543 9544 public final void recordKey() throws RecognitionException, TokenStreamException { 9545 9546 returnAST = null; 9547 ASTPair currentAST = new ASTPair(); 9548 AST recordKey_AST = null; 9549 9550 AST tmp235_AST = null; 9551 tmp235_AST = astFactory.create(LT(1)); 9552 astFactory.addASTChild(currentAST, tmp235_AST); 9553 match(LITERAL_record); 9554 if ( inputState.guessing==0 ) { 9555 recordKey_AST = (AST)currentAST.root; 9556 recordKey_AST.setType(IDENT); 9557 } 9558 recordKey_AST = (AST)currentAST.root; 9559 returnAST = recordKey_AST; 9560 } 9561 9562 public final void yieldKey() throws RecognitionException, TokenStreamException { 9563 9564 returnAST = null; 9565 ASTPair currentAST = new ASTPair(); 9566 AST yieldKey_AST = null; 9567 9568 AST tmp236_AST = null; 9569 tmp236_AST = astFactory.create(LT(1)); 9570 astFactory.addASTChild(currentAST, tmp236_AST); 9571 match(LITERAL_yield); 9572 if ( inputState.guessing==0 ) { 9573 yieldKey_AST = (AST)currentAST.root; 9574 yieldKey_AST.setType(IDENT); 9575 } 9576 yieldKey_AST = (AST)currentAST.root; 9577 returnAST = yieldKey_AST; 9578 } 9579 9580 public final void nonKey() throws RecognitionException, TokenStreamException { 9581 9582 returnAST = null; 9583 ASTPair currentAST = new ASTPair(); 9584 AST nonKey_AST = null; 9585 9586 AST tmp237_AST = null; 9587 tmp237_AST = astFactory.create(LT(1)); 9588 astFactory.addASTChild(currentAST, tmp237_AST); 9589 match(LITERAL_non); 9590 if ( inputState.guessing==0 ) { 9591 nonKey_AST = (AST)currentAST.root; 9592 nonKey_AST.setType(IDENT); 9593 } 9594 nonKey_AST = (AST)currentAST.root; 9595 returnAST = nonKey_AST; 9596 } 9597 9598 public final void sealedKey() throws RecognitionException, TokenStreamException { 9599 9600 returnAST = null; 9601 ASTPair currentAST = new ASTPair(); 9602 AST sealedKey_AST = null; 9603 9604 AST tmp238_AST = null; 9605 tmp238_AST = astFactory.create(LT(1)); 9606 astFactory.addASTChild(currentAST, tmp238_AST); 9607 match(LITERAL_sealed); 9608 if ( inputState.guessing==0 ) { 9609 sealedKey_AST = (AST)currentAST.root; 9610 sealedKey_AST.setType(IDENT); 9611 } 9612 sealedKey_AST = (AST)currentAST.root; 9613 returnAST = sealedKey_AST; 9614 } 9615 9616 public final void permitsKey() throws RecognitionException, TokenStreamException { 9617 9618 returnAST = null; 9619 ASTPair currentAST = new ASTPair(); 9620 AST permitsKey_AST = null; 9621 9622 AST tmp239_AST = null; 9623 tmp239_AST = astFactory.create(LT(1)); 9624 astFactory.addASTChild(currentAST, tmp239_AST); 9625 match(LITERAL_permits); 9626 if ( inputState.guessing==0 ) { 9627 permitsKey_AST = (AST)currentAST.root; 9628 permitsKey_AST.setType(IDENT); 9629 } 9630 permitsKey_AST = (AST)currentAST.root; 9631 returnAST = permitsKey_AST; 9632 } 9633 9634 9635 public static final String[] _tokenNames = { 9636 "<0>", 9637 "EOF", 9638 "<2>", 9639 "NULL_TREE_LOOKAHEAD", 9640 "BLOCK", 9641 "MODIFIERS", 9642 "OBJBLOCK", 9643 "SLIST", 9644 "CTOR_DEF", 9645 "METHOD_DEF", 9646 "VARIABLE_DEF", 9647 "INSTANCE_INIT", 9648 "STATIC_INIT", 9649 "TYPE", 9650 "CLASS_DEF", 9651 "INTERFACE_DEF", 9652 "PACKAGE_DEF", 9653 "ARRAY_DECLARATOR", 9654 "EXTENDS_CLAUSE", 9655 "IMPLEMENTS_CLAUSE", 9656 "PARAMETERS", 9657 "PARAMETER_DEF", 9658 "LABELED_STAT", 9659 "TYPECAST", 9660 "INDEX_OP", 9661 "POST_INC", 9662 "POST_DEC", 9663 "METHOD_CALL", 9664 "EXPR", 9665 "ARRAY_INIT", 9666 "IMPORT", 9667 "UNARY_MINUS", 9668 "UNARY_PLUS", 9669 "CASE_GROUP", 9670 "ELIST", 9671 "FOR_INIT", 9672 "FOR_CONDITION", 9673 "FOR_ITERATOR", 9674 "EMPTY_STAT", 9675 "\"final\"", 9676 "\"abstract\"", 9677 "\"strictfp\"", 9678 "SUPER_CTOR_CALL", 9679 "CTOR_CALL", 9680 "\"package\"", 9681 "SEMI", 9682 "\"import\"", 9683 "LBRACK", 9684 "RBRACK", 9685 "\"void\"", 9686 "\"boolean\"", 9687 "\"byte\"", 9688 "\"char\"", 9689 "\"short\"", 9690 "\"int\"", 9691 "\"float\"", 9692 "\"long\"", 9693 "\"double\"", 9694 "IDENT", 9695 "DOT", 9696 "STAR", 9697 "\"private\"", 9698 "\"public\"", 9699 "\"protected\"", 9700 "\"static\"", 9701 "\"transient\"", 9702 "\"native\"", 9703 "\"synchronized\"", 9704 "\"volatile\"", 9705 "\"class\"", 9706 "\"extends\"", 9707 "\"interface\"", 9708 "LCURLY", 9709 "RCURLY", 9710 "COMMA", 9711 "\"implements\"", 9712 "LPAREN", 9713 "RPAREN", 9714 "\"this\"", 9715 "\"super\"", 9716 "ASSIGN", 9717 "\"throws\"", 9718 "COLON", 9719 "\"if\"", 9720 "\"while\"", 9721 "\"do\"", 9722 "\"break\"", 9723 "\"continue\"", 9724 "\"return\"", 9725 "\"switch\"", 9726 "\"throw\"", 9727 "\"for\"", 9728 "\"else\"", 9729 "\"case\"", 9730 "\"default\"", 9731 "\"try\"", 9732 "\"catch\"", 9733 "\"finally\"", 9734 "PLUS_ASSIGN", 9735 "MINUS_ASSIGN", 9736 "STAR_ASSIGN", 9737 "DIV_ASSIGN", 9738 "MOD_ASSIGN", 9739 "SR_ASSIGN", 9740 "BSR_ASSIGN", 9741 "SL_ASSIGN", 9742 "BAND_ASSIGN", 9743 "BXOR_ASSIGN", 9744 "BOR_ASSIGN", 9745 "QUESTION", 9746 "LOR", 9747 "LAND", 9748 "BOR", 9749 "BXOR", 9750 "BAND", 9751 "NOT_EQUAL", 9752 "EQUAL", 9753 "LT", 9754 "GT", 9755 "LE", 9756 "GE", 9757 "\"instanceof\"", 9758 "SL", 9759 "SR", 9760 "BSR", 9761 "PLUS", 9762 "MINUS", 9763 "DIV", 9764 "MOD", 9765 "INC", 9766 "DEC", 9767 "BNOT", 9768 "LNOT", 9769 "\"true\"", 9770 "\"false\"", 9771 "\"null\"", 9772 "\"new\"", 9773 "NUM_INT", 9774 "CHAR_LITERAL", 9775 "STRING_LITERAL", 9776 "NUM_FLOAT", 9777 "NUM_LONG", 9778 "NUM_DOUBLE", 9779 "WS", 9780 "SINGLE_LINE_COMMENT", 9781 "BLOCK_COMMENT_BEGIN", 9782 "ESC", 9783 "HEX_DIGIT", 9784 "VOCAB", 9785 "EXPONENT", 9786 "FLOAT_SUFFIX", 9787 "ASSERT", 9788 "STATIC_IMPORT", 9789 "ENUM", 9790 "ENUM_DEF", 9791 "ENUM_CONSTANT_DEF", 9792 "FOR_EACH_CLAUSE", 9793 "ANNOTATION_DEF", 9794 "ANNOTATIONS", 9795 "ANNOTATION", 9796 "ANNOTATION_MEMBER_VALUE_PAIR", 9797 "ANNOTATION_FIELD_DEF", 9798 "ANNOTATION_ARRAY_INIT", 9799 "TYPE_ARGUMENTS", 9800 "TYPE_ARGUMENT", 9801 "TYPE_PARAMETERS", 9802 "TYPE_PARAMETER", 9803 "WILDCARD_TYPE", 9804 "TYPE_UPPER_BOUNDS", 9805 "TYPE_LOWER_BOUNDS", 9806 "AT", 9807 "ELLIPSIS", 9808 "GENERIC_START", 9809 "GENERIC_END", 9810 "TYPE_EXTENSION_AND", 9811 "DO_WHILE", 9812 "RESOURCE_SPECIFICATION", 9813 "RESOURCES", 9814 "RESOURCE", 9815 "DOUBLE_COLON", 9816 "METHOD_REF", 9817 "LAMBDA", 9818 "BLOCK_COMMENT_END", 9819 "COMMENT_CONTENT", 9820 "SINGLE_LINE_COMMENT_CONTENT", 9821 "BLOCK_COMMENT_CONTENT", 9822 "STD_ESC", 9823 "BINARY_DIGIT", 9824 "ID_START", 9825 "ID_PART", 9826 "INT_LITERAL", 9827 "LONG_LITERAL", 9828 "FLOAT_LITERAL", 9829 "DOUBLE_LITERAL", 9830 "HEX_FLOAT_LITERAL", 9831 "HEX_DOUBLE_LITERAL", 9832 "SIGNED_INTEGER", 9833 "BINARY_EXPONENT", 9834 "PATTERN_VARIABLE_DEF", 9835 "RECORD_DEF", 9836 "\"record\"", 9837 "RECORD_COMPONENTS", 9838 "RECORD_COMPONENT_DEF", 9839 "COMPACT_CTOR_DEF", 9840 "TEXT_BLOCK_LITERAL_BEGIN", 9841 "TEXT_BLOCK_CONTENT", 9842 "TEXT_BLOCK_LITERAL_END", 9843 "\"yield\"", 9844 "SWITCH_RULE", 9845 "\"non-sealed\"", 9846 "\"sealed\"", 9847 "\"permits\"", 9848 "PERMITS_CLAUSE", 9849 "\"non\"" 9850 }; 9851 9852 protected void buildTokenTypeASTClassMap() { 9853 tokenTypeToASTClassMap=null; 9854 }; 9855 9856 private static final long[] mk_tokenSet_0() { 9857 long[] data = new long[8]; 9858 data[0]=288230376151711744L; 9859 data[3]=2916608L; 9860 return data; 9861 } 9862 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); 9863 private static final long[] mk_tokenSet_1() { 9864 long[] data = new long[8]; 9865 data[0]=-2305733607806730238L; 9866 data[1]=1073742015L; 9867 data[2]=4398080065536L; 9868 data[3]=2359552L; 9869 return data; 9870 } 9871 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); 9872 private static final long[] mk_tokenSet_2() { 9873 long[] data = new long[8]; 9874 data[0]=-2017503231655018494L; 9875 data[1]=4611686019501129919L; 9876 data[2]=4398080065536L; 9877 data[3]=2916608L; 9878 return data; 9879 } 9880 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); 9881 private static final long[] mk_tokenSet_3() { 9882 long[] data = new long[8]; 9883 data[0]=-2017503231655018494L; 9884 data[1]=1073742015L; 9885 data[2]=4398080065536L; 9886 data[3]=2916608L; 9887 return data; 9888 } 9889 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); 9890 private static final long[] mk_tokenSet_4() { 9891 long[] data = new long[8]; 9892 data[0]=-2305803976550907904L; 9893 data[1]=1073742015L; 9894 data[2]=4398080065536L; 9895 data[3]=2359552L; 9896 return data; 9897 } 9898 public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); 9899 private static final long[] mk_tokenSet_5() { 9900 long[] data = new long[8]; 9901 data[0]=-2305803976550907902L; 9902 data[1]=1073742015L; 9903 data[2]=4398080065536L; 9904 data[3]=2359552L; 9905 return data; 9906 } 9907 public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5()); 9908 private static final long[] mk_tokenSet_6() { 9909 long[] data = new long[8]; 9910 data[0]=-2305839160922996736L; 9911 data[1]=1073741855L; 9912 data[3]=2359296L; 9913 return data; 9914 } 9915 public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6()); 9916 private static final long[] mk_tokenSet_7() { 9917 long[] data = new long[8]; 9918 data[0]=-1729941358572994560L; 9919 data[1]=4620693218755870911L; 9920 data[2]=4398080065536L; 9921 data[3]=2916608L; 9922 return data; 9923 } 9924 public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7()); 9925 private static final long[] mk_tokenSet_8() { 9926 long[] data = { 140737488355328L, 0L, 13194139533312L, 0L, 0L, 0L}; 9927 return data; 9928 } 9929 public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8()); 9930 private static final long[] mk_tokenSet_9() { 9931 long[] data = new long[8]; 9932 data[0]=288511851128422400L; 9933 data[3]=2916608L; 9934 return data; 9935 } 9936 public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9()); 9937 private static final long[] mk_tokenSet_10() { 9938 long[] data = new long[8]; 9939 data[0]=288230376151711744L; 9940 data[2]=4398046511104L; 9941 data[3]=2916608L; 9942 return data; 9943 } 9944 public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10()); 9945 private static final long[] mk_tokenSet_11() { 9946 long[] data = new long[8]; 9947 data[0]=-101704825569280L; 9948 data[1]=-12885032961L; 9949 data[2]=11272193249935359L; 9950 data[3]=2924800L; 9951 return data; 9952 } 9953 public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11()); 9954 private static final long[] mk_tokenSet_12() { 9955 long[] data = new long[8]; 9956 data[0]=-84112639524862L; 9957 data[1]=-131073L; 9958 data[2]=11272193249935359L; 9959 data[3]=2941184L; 9960 return data; 9961 } 9962 public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12()); 9963 private static final long[] mk_tokenSet_13() { 9964 long[] data = new long[8]; 9965 data[0]=575897802350002176L; 9966 data[1]=35184372088832L; 9967 data[2]=4398046511104L; 9968 data[3]=2916608L; 9969 return data; 9970 } 9971 public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13()); 9972 private static final long[] mk_tokenSet_14() { 9973 long[] data = { 0L, 1747396655419752448L, 0L, 0L}; 9974 return data; 9975 } 9976 public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14()); 9977 private static final long[] mk_tokenSet_15() { 9978 long[] data = new long[8]; 9979 data[0]=575897802350002176L; 9980 data[2]=4398046511104L; 9981 data[3]=2916608L; 9982 return data; 9983 } 9984 public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15()); 9985 private static final long[] mk_tokenSet_16() { 9986 long[] data = new long[8]; 9987 data[0]=864831865943490560L; 9988 data[1]=9007199254745088L; 9989 data[2]=4398046511104L; 9990 data[3]=2916608L; 9991 return data; 9992 } 9993 public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16()); 9994 private static final long[] mk_tokenSet_17() { 9995 long[] data = new long[8]; 9996 data[0]=575897802350002176L; 9997 data[1]=6917529027674689792L; 9998 data[2]=4398046543870L; 9999 data[3]=2924800L; 10000 return data; 10001 } 10002 public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17()); 10003 private static final long[] mk_tokenSet_18() { 10004 long[] data = new long[8]; 10005 data[0]=2305420796748627968L; 10006 data[1]=-35184338472448L; 10007 data[2]=2256197860229119L; 10008 data[3]=2941184L; 10009 return data; 10010 } 10011 public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18()); 10012 private static final long[] mk_tokenSet_19() { 10013 long[] data = new long[8]; 10014 data[0]=575897802350002176L; 10015 data[1]=6917529027674689536L; 10016 data[2]=4398046543870L; 10017 data[3]=2924800L; 10018 return data; 10019 } 10020 public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19()); 10021 private static final long[] mk_tokenSet_20() { 10022 long[] data = new long[8]; 10023 data[0]=2305455981120716800L; 10024 data[1]=-35184338471936L; 10025 data[2]=2256197860229119L; 10026 data[3]=2941184L; 10027 return data; 10028 } 10029 public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20()); 10030 private static final long[] mk_tokenSet_21() { 10031 long[] data = new long[8]; 10032 data[0]=2305420796748627968L; 10033 data[1]=-35184338479616L; 10034 data[2]=2256197860229119L; 10035 data[3]=2941184L; 10036 return data; 10037 } 10038 public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21()); 10039 private static final long[] mk_tokenSet_22() { 10040 long[] data = new long[8]; 10041 data[0]=288230376151711744L; 10042 data[1]=4096L; 10043 data[3]=2916608L; 10044 return data; 10045 } 10046 public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22()); 10047 private static final long[] mk_tokenSet_23() { 10048 long[] data = new long[8]; 10049 data[0]=575898352105816064L; 10050 data[1]=24576L; 10051 data[2]=9011597301252096L; 10052 data[3]=2916608L; 10053 return data; 10054 } 10055 public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23()); 10056 private static final long[] mk_tokenSet_24() { 10057 long[] data = new long[8]; 10058 data[0]=2305420796748627968L; 10059 data[1]=-17145933824L; 10060 data[2]=2256197860229119L; 10061 data[3]=2941184L; 10062 return data; 10063 } 10064 public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24()); 10065 private static final long[] mk_tokenSet_25() { 10066 long[] data = new long[8]; 10067 data[0]=-101704825569280L; 10068 data[1]=-12885035073L; 10069 data[2]=11263397156913151L; 10070 data[3]=2941184L; 10071 return data; 10072 } 10073 public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25()); 10074 private static final long[] mk_tokenSet_26() { 10075 long[] data = new long[8]; 10076 data[0]=-2017608784771284992L; 10077 data[1]=1073741855L; 10078 data[2]=4398046511104L; 10079 data[3]=2916608L; 10080 return data; 10081 } 10082 public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26()); 10083 private static final long[] mk_tokenSet_27() { 10084 long[] data = new long[8]; 10085 data[0]=-2017608784771284992L; 10086 data[1]=4611686019501130015L; 10087 data[2]=4398046511104L; 10088 data[3]=2916608L; 10089 return data; 10090 } 10091 public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27()); 10092 private static final long[] mk_tokenSet_28() { 10093 long[] data = new long[8]; 10094 data[0]=-1729941358572994560L; 10095 data[1]=9007200328483263L; 10096 data[2]=4398080065536L; 10097 data[3]=2916608L; 10098 return data; 10099 } 10100 public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28()); 10101 private static final long[] mk_tokenSet_29() { 10102 long[] data = new long[8]; 10103 data[0]=-1153304684409126912L; 10104 data[1]=6926536230385013695L; 10105 data[2]=4398088486910L; 10106 data[3]=2924800L; 10107 return data; 10108 } 10109 public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29()); 10110 private static final long[] mk_tokenSet_30() { 10111 long[] data = new long[8]; 10112 data[0]=864831865943490560L; 10113 data[1]=9007199254740992L; 10114 data[2]=4398046511104L; 10115 data[3]=2916608L; 10116 return data; 10117 } 10118 public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30()); 10119 private static final long[] mk_tokenSet_31() { 10120 long[] data = new long[8]; 10121 data[0]=864831865943490560L; 10122 data[1]=9007199254740992L; 10123 data[2]=13194139533312L; 10124 data[3]=2916608L; 10125 return data; 10126 } 10127 public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31()); 10128 private static final long[] mk_tokenSet_32() { 10129 long[] data = new long[8]; 10130 data[0]=-1729941358572994560L; 10131 data[1]=9007200328483007L; 10132 data[2]=4398080065536L; 10133 data[3]=2916608L; 10134 return data; 10135 } 10136 public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32()); 10137 private static final long[] mk_tokenSet_33() { 10138 long[] data = new long[8]; 10139 data[0]=-1153339868781215744L; 10140 data[1]=4620693218755875007L; 10141 data[2]=4398080065536L; 10142 data[3]=2916608L; 10143 return data; 10144 } 10145 public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33()); 10146 private static final long[] mk_tokenSet_34() { 10147 long[] data = new long[8]; 10148 data[1]=160L; 10149 data[2]=4398080065536L; 10150 data[3]=256L; 10151 return data; 10152 } 10153 public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34()); 10154 private static final long[] mk_tokenSet_35() { 10155 long[] data = new long[8]; 10156 data[0]=288230376151711744L; 10157 data[1]=128L; 10158 data[3]=2916608L; 10159 return data; 10160 } 10161 public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35()); 10162 private static final long[] mk_tokenSet_36() { 10163 long[] data = new long[8]; 10164 data[0]=575897802350002176L; 10165 data[1]=9007199254740992L; 10166 data[2]=4398046511104L; 10167 data[3]=2916608L; 10168 return data; 10169 } 10170 public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36()); 10171 private static final long[] mk_tokenSet_37() { 10172 long[] data = new long[8]; 10173 data[0]=-1729765436712550400L; 10174 data[1]=9007200328550335L; 10175 data[2]=4398080065536L; 10176 data[3]=2916608L; 10177 return data; 10178 } 10179 public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37()); 10180 private static final long[] mk_tokenSet_38() { 10181 long[] data = new long[8]; 10182 data[0]=-1729906174200905728L; 10183 data[1]=9007200328483775L; 10184 data[2]=4398080065536L; 10185 data[3]=2916608L; 10186 return data; 10187 } 10188 public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38()); 10189 private static final long[] mk_tokenSet_39() { 10190 long[] data = new long[8]; 10191 data[0]=-101704825569278L; 10192 data[1]=-12885035073L; 10193 data[2]=11263397156913151L; 10194 data[3]=2924800L; 10195 return data; 10196 } 10197 public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39()); 10198 private static final long[] mk_tokenSet_40() { 10199 long[] data = new long[8]; 10200 data[0]=575897802350002176L; 10201 data[1]=9007199254794240L; 10202 data[2]=4398046543840L; 10203 data[3]=2924800L; 10204 return data; 10205 } 10206 public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40()); 10207 private static final long[] mk_tokenSet_41() { 10208 long[] data = new long[8]; 10209 data[0]=1152499292141780992L; 10210 data[1]=8673968066721271808L; 10211 data[2]=4398046543870L; 10212 data[3]=2941184L; 10213 return data; 10214 } 10215 public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41()); 10216 private static final long[] mk_tokenSet_42() { 10217 long[] data = new long[8]; 10218 data[0]=-1729906174200905728L; 10219 data[1]=6917529031130272575L; 10220 data[2]=4398054932478L; 10221 data[3]=2924800L; 10222 return data; 10223 } 10224 public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42()); 10225 private static final long[] mk_tokenSet_43() { 10226 long[] data = new long[8]; 10227 data[0]=-383179802279936L; 10228 data[1]=-13690342465L; 10229 data[2]=11263397156913151L; 10230 data[3]=2941184L; 10231 return data; 10232 } 10233 public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43()); 10234 private static final long[] mk_tokenSet_44() { 10235 long[] data = new long[8]; 10236 data[0]=-1729906174200905728L; 10237 data[1]=6917529031130272063L; 10238 data[2]=4398054932478L; 10239 data[3]=2924800L; 10240 return data; 10241 } 10242 public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44()); 10243 private static final long[] mk_tokenSet_45() { 10244 long[] data = new long[8]; 10245 data[0]=575897802350002176L; 10246 data[1]=1747396655419759936L; 10247 data[2]=4398046511104L; 10248 data[3]=2916608L; 10249 return data; 10250 } 10251 public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45()); 10252 private static final long[] mk_tokenSet_46() { 10253 long[] data = new long[8]; 10254 data[0]=-1153304684409126912L; 10255 data[1]=9007200328498175L; 10256 data[2]=4398080065536L; 10257 data[3]=2916608L; 10258 return data; 10259 } 10260 public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46()); 10261 private static final long[] mk_tokenSet_47() { 10262 long[] data = { 175921860444160L, 66560L, 4398046511104L, 0L, 0L, 0L}; 10263 return data; 10264 } 10265 public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47()); 10266 private static final long[] mk_tokenSet_48() { 10267 long[] data = new long[8]; 10268 data[0]=575898352105816064L; 10269 data[1]=16384L; 10270 data[2]=4398046511104L; 10271 data[3]=2916608L; 10272 return data; 10273 } 10274 public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48()); 10275 private static final long[] mk_tokenSet_49() { 10276 long[] data = new long[8]; 10277 data[0]=1152499292141780992L; 10278 data[1]=9007199254766592L; 10279 data[2]=4398046511104L; 10280 data[3]=2916608L; 10281 return data; 10282 } 10283 public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49()); 10284 private static final long[] mk_tokenSet_50() { 10285 long[] data = new long[8]; 10286 data[0]=575898352105816064L; 10287 data[2]=4398046511104L; 10288 data[3]=2916608L; 10289 return data; 10290 } 10291 public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50()); 10292 private static final long[] mk_tokenSet_51() { 10293 long[] data = new long[8]; 10294 data[0]=1152499292141780992L; 10295 data[1]=9007199254740992L; 10296 data[2]=13194139533312L; 10297 data[3]=2916608L; 10298 return data; 10299 } 10300 public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51()); 10301 private static final long[] mk_tokenSet_52() { 10302 long[] data = new long[8]; 10303 data[0]=864726312827224064L; 10304 data[1]=1280L; 10305 data[3]=2916608L; 10306 return data; 10307 } 10308 public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52()); 10309 private static final long[] mk_tokenSet_53() { 10310 long[] data = { 576495936675512320L, 1280L, 0L, 0L}; 10311 return data; 10312 } 10313 public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53()); 10314 private static final long[] mk_tokenSet_54() { 10315 long[] data = { 0L, 9007199254790144L, 0L, 0L}; 10316 return data; 10317 } 10318 public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54()); 10319 private static final long[] mk_tokenSet_55() { 10320 long[] data = new long[8]; 10321 data[0]=575897802350002176L; 10322 data[1]=1747431839791894528L; 10323 data[2]=4398046511104L; 10324 data[3]=2916608L; 10325 return data; 10326 } 10327 public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55()); 10328 private static final long[] mk_tokenSet_56() { 10329 long[] data = new long[8]; 10330 data[0]=575897802350002176L; 10331 data[1]=53248L; 10332 data[2]=4398046543840L; 10333 data[3]=2924800L; 10334 return data; 10335 } 10336 public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56()); 10337 private static final long[] mk_tokenSet_57() { 10338 long[] data = new long[8]; 10339 data[0]=1152499292141780992L; 10340 data[1]=6926536226929430528L; 10341 data[2]=4398046543870L; 10342 data[3]=2941184L; 10343 return data; 10344 } 10345 public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57()); 10346 private static final long[] mk_tokenSet_58() { 10347 long[] data = new long[8]; 10348 data[0]=2305420796748627968L; 10349 data[1]=-17146187776L; 10350 data[2]=2256197860229119L; 10351 data[3]=2941184L; 10352 return data; 10353 } 10354 public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58()); 10355 private static final long[] mk_tokenSet_59() { 10356 long[] data = new long[8]; 10357 data[0]=-101704825569280L; 10358 data[1]=-12885035073L; 10359 data[2]=11263397156913151L; 10360 data[3]=2924800L; 10361 return data; 10362 } 10363 public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59()); 10364 private static final long[] mk_tokenSet_60() { 10365 long[] data = new long[8]; 10366 data[0]=-84112639524862L; 10367 data[1]=-133185L; 10368 data[2]=11272193249935359L; 10369 data[3]=2941184L; 10370 return data; 10371 } 10372 public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60()); 10373 private static final long[] mk_tokenSet_61() { 10374 long[] data = new long[8]; 10375 data[0]=-101704825569280L; 10376 data[1]=-12885035073L; 10377 data[2]=2256197902172159L; 10378 data[3]=2941184L; 10379 return data; 10380 } 10381 public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61()); 10382 private static final long[] mk_tokenSet_62() { 10383 long[] data = new long[8]; 10384 data[0]=864831865943490560L; 10385 data[1]=9007199254757376L; 10386 data[2]=4398046511104L; 10387 data[3]=2916608L; 10388 return data; 10389 } 10390 public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62()); 10391 private static final long[] mk_tokenSet_63() { 10392 long[] data = new long[8]; 10393 data[0]=288230376151711744L; 10394 data[1]=16384L; 10395 data[3]=2916608L; 10396 return data; 10397 } 10398 public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63()); 10399 private static final long[] mk_tokenSet_64() { 10400 long[] data = { 576601489791778816L, 9216L, 4398046511104L, 0L, 0L, 0L}; 10401 return data; 10402 } 10403 public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64()); 10404 private static final long[] mk_tokenSet_65() { 10405 long[] data = new long[8]; 10406 data[0]=-576984669594058752L; 10407 data[1]=-9007194959973569L; 10408 data[2]=4398054932479L; 10409 data[3]=2924800L; 10410 return data; 10411 } 10412 public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65()); 10413 private static final long[] mk_tokenSet_66() { 10414 long[] data = new long[8]; 10415 data[0]=-101704825569280L; 10416 data[1]=-133185L; 10417 data[2]=11263397156913151L; 10418 data[3]=2941184L; 10419 return data; 10420 } 10421 public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66()); 10422 private static final long[] mk_tokenSet_67() { 10423 long[] data = new long[8]; 10424 data[0]=-1729941358572994560L; 10425 data[1]=1073741855L; 10426 data[2]=4398046511104L; 10427 data[3]=2916608L; 10428 return data; 10429 } 10430 public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67()); 10431 private static final long[] mk_tokenSet_68() { 10432 long[] data = new long[8]; 10433 data[0]=-1153339868781215744L; 10434 data[1]=4620693218755870751L; 10435 data[2]=4398046511104L; 10436 data[3]=2916608L; 10437 return data; 10438 } 10439 public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68()); 10440 private static final long[] mk_tokenSet_69() { 10441 long[] data = new long[8]; 10442 data[0]=-383179802279936L; 10443 data[1]=-12885036225L; 10444 data[2]=11263397123358719L; 10445 data[3]=2941184L; 10446 return data; 10447 } 10448 public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69()); 10449 private static final long[] mk_tokenSet_70() { 10450 long[] data = new long[8]; 10451 data[0]=-2305839160922996736L; 10452 data[1]=1073741887L; 10453 data[2]=4398046511104L; 10454 data[3]=2359296L; 10455 return data; 10456 } 10457 public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70()); 10458 private static final long[] mk_tokenSet_71() { 10459 long[] data = new long[8]; 10460 data[0]=-2017608784771284992L; 10461 data[1]=4611686019501129791L; 10462 data[2]=4398046511104L; 10463 data[3]=2916608L; 10464 return data; 10465 } 10466 public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71()); 10467 private static final long[] mk_tokenSet_72() { 10468 long[] data = new long[8]; 10469 data[0]=-1729906174200905728L; 10470 data[1]=6917529028748431391L; 10471 data[2]=4398046543870L; 10472 data[3]=2924800L; 10473 return data; 10474 } 10475 public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72()); 10476 private static final long[] mk_tokenSet_73() { 10477 long[] data = new long[8]; 10478 data[0]=-383179802279936L; 10479 data[1]=-16072444897L; 10480 data[2]=11263397114970111L; 10481 data[3]=2941184L; 10482 return data; 10483 } 10484 public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73()); 10485 private static final long[] mk_tokenSet_74() { 10486 long[] data = new long[8]; 10487 data[0]=2305456530876530688L; 10488 data[1]=-17146186752L; 10489 data[2]=11263397114970111L; 10490 data[3]=2941184L; 10491 return data; 10492 } 10493 public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74()); 10494 private static final long[] mk_tokenSet_75() { 10495 long[] data = new long[8]; 10496 data[0]=575897802350002176L; 10497 data[1]=6917529027674951680L; 10498 data[2]=9011597301284862L; 10499 data[3]=2924800L; 10500 return data; 10501 } 10502 public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75()); 10503 private static final long[] mk_tokenSet_76() { 10504 long[] data = { 0L, 1610613248L, 0L, 0L}; 10505 return data; 10506 } 10507 public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76()); 10508 private static final long[] mk_tokenSet_77() { 10509 long[] data = new long[8]; 10510 data[0]=-576703194617348096L; 10511 data[1]=-12885035073L; 10512 data[2]=9011597343227903L; 10513 data[3]=2924800L; 10514 return data; 10515 } 10516 public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77()); 10517 private static final long[] mk_tokenSet_78() { 10518 long[] data = new long[8]; 10519 data[0]=-1729906174200905728L; 10520 data[1]=6917529031667405631L; 10521 data[2]=4398054932478L; 10522 data[3]=2924800L; 10523 return data; 10524 } 10525 public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78()); 10526 private static final long[] mk_tokenSet_79() { 10527 long[] data = new long[8]; 10528 data[0]=-383179802279936L; 10529 data[1]=-13153471681L; 10530 data[2]=11263397123358719L; 10531 data[3]=2941184L; 10532 return data; 10533 } 10534 public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79()); 10535 private static final long[] mk_tokenSet_80() { 10536 long[] data = new long[8]; 10537 data[0]=575898352105816064L; 10538 data[1]=53248L; 10539 data[2]=4398046543840L; 10540 data[3]=2924800L; 10541 return data; 10542 } 10543 public static final BitSet _tokenSet_80 = new BitSet(mk_tokenSet_80()); 10544 private static final long[] mk_tokenSet_81() { 10545 long[] data = new long[8]; 10546 data[0]=1152499292141780992L; 10547 data[1]=9007199254740992L; 10548 data[2]=4398046511104L; 10549 data[3]=2916608L; 10550 return data; 10551 } 10552 public static final BitSet _tokenSet_81 = new BitSet(mk_tokenSet_81()); 10553 private static final long[] mk_tokenSet_82() { 10554 long[] data = new long[8]; 10555 data[0]=1152534476513869824L; 10556 data[1]=6926536226929438720L; 10557 data[2]=4398046543870L; 10558 data[3]=2941184L; 10559 return data; 10560 } 10561 public static final BitSet _tokenSet_82 = new BitSet(mk_tokenSet_82()); 10562 private static final long[] mk_tokenSet_83() { 10563 long[] data = new long[8]; 10564 data[0]=-101704825569280L; 10565 data[1]=-12885035073L; 10566 data[2]=9011597343227903L; 10567 data[3]=2924800L; 10568 return data; 10569 } 10570 public static final BitSet _tokenSet_83 = new BitSet(mk_tokenSet_83()); 10571 private static final long[] mk_tokenSet_84() { 10572 long[] data = { 1152921504606846976L, -9223372036854775808L, 1L, 0L, 0L, 0L}; 10573 return data; 10574 } 10575 public static final BitSet _tokenSet_84 = new BitSet(mk_tokenSet_84()); 10576 private static final long[] mk_tokenSet_85() { 10577 long[] data = new long[8]; 10578 data[0]=575897802350002176L; 10579 data[1]=6917529027674697728L; 10580 data[2]=4398046543870L; 10581 data[3]=2924800L; 10582 return data; 10583 } 10584 public static final BitSet _tokenSet_85 = new BitSet(mk_tokenSet_85()); 10585 private static final long[] mk_tokenSet_86() { 10586 long[] data = new long[8]; 10587 data[0]=575897802350002176L; 10588 data[1]=6917529027674691328L; 10589 data[2]=4398046543870L; 10590 data[3]=2924800L; 10591 return data; 10592 } 10593 public static final BitSet _tokenSet_86 = new BitSet(mk_tokenSet_86()); 10594 private static final long[] mk_tokenSet_87() { 10595 long[] data = new long[8]; 10596 data[0]=576179277326712832L; 10597 data[1]=6917529027674689536L; 10598 data[2]=4398046543870L; 10599 data[3]=2924800L; 10600 return data; 10601 } 10602 public static final BitSet _tokenSet_87 = new BitSet(mk_tokenSet_87()); 10603 private static final long[] mk_tokenSet_88() { 10604 long[] data = new long[8]; 10605 data[0]=575898352105816064L; 10606 data[1]=24576L; 10607 data[2]=4398046511104L; 10608 data[3]=2916608L; 10609 return data; 10610 } 10611 public static final BitSet _tokenSet_88 = new BitSet(mk_tokenSet_88()); 10612 private static final long[] mk_tokenSet_89() { 10613 long[] data = new long[8]; 10614 data[0]=1152499292141780992L; 10615 data[1]=9007199254766592L; 10616 data[2]=9020393394274304L; 10617 data[3]=2916608L; 10618 return data; 10619 } 10620 public static final BitSet _tokenSet_89 = new BitSet(mk_tokenSet_89()); 10621 10622 }