001// $ANTLR 2.7.7 (20141010): "java.g" -> "GeneratedJavaRecognizer.java"$ 002 003package com.puppycrawl.tools.checkstyle.grammars; 004 005import com.puppycrawl.tools.checkstyle.api.DetailAST; 006import java.text.MessageFormat; 007import antlr.CommonToken; 008 009import antlr.TokenBuffer; 010import antlr.TokenStreamException; 011import antlr.TokenStreamIOException; 012import antlr.ANTLRException; 013import antlr.LLkParser; 014import antlr.Token; 015import antlr.TokenStream; 016import antlr.RecognitionException; 017import antlr.NoViableAltException; 018import antlr.MismatchedTokenException; 019import antlr.SemanticException; 020import antlr.ParserSharedInputState; 021import antlr.collections.impl.BitSet; 022import antlr.collections.AST; 023import java.util.Hashtable; 024import antlr.ASTFactory; 025import antlr.ASTPair; 026import antlr.collections.impl.ASTArray; 027 028/** Java 1.5 Recognizer 029 * 030 * This grammar is in the PUBLIC DOMAIN 031 */ 032public class GeneratedJavaRecognizer extends antlr.LLkParser implements GeneratedJavaTokenTypes 033 { 034 035 /** 036 * Counts the number of LT seen in the typeArguments production. 037 * It is used in semantic predicates to ensure we have seen 038 * enough closing '>' characters; which actually may have been 039 * either GT, SR or BSR tokens. 040 */ 041 private int ltCounter = 0; 042 043 /** 044 * Counts the number of '>' characters that have been seen but 045 * have not yet been associated with the end of a typeParameters or 046 * typeArguments production. This is necessary because SR and BSR 047 * tokens have significance (the extra '>' characters) not only for the production 048 * that sees them but also productions higher in the stack (possibly right up to an outer-most 049 * typeParameters production). As the stack of the typeArguments/typeParameters productions unwind, 050 * any '>' characters seen prematurely through SRs or BSRs are reconciled. 051 */ 052 private int gtToReconcile = 0; 053 054 /** 055 * The most recently seen gt sequence (GT, SR or BSR) 056 * encountered in any type argument or type parameter production. 057 * We retain this so we can keep manage the synthetic GT tokens/ 058 * AST nodes we emit to have '<' & '>' balanced trees when encountering 059 * SR and BSR tokens. 060 */ 061 private DetailAST currentGtSequence = null; 062 063 /** 064 * Consume a sequence of '>' characters (GT, SR or BSR) 065 * and match these against the '<' characters seen. 066 */ 067 private void consumeCurrentGtSequence(DetailAST gtSequence) 068 { 069 currentGtSequence = gtSequence; 070 gtToReconcile += currentGtSequence.getText().length(); 071 ltCounter -= currentGtSequence.getText().length(); 072 } 073 074 /** 075 * Emits a single GT AST node with the line and column correctly 076 * set to its position in the source file. This must only 077 * ever be called when a typeParameters or typeArguments production 078 * is ending and there is at least one GT character to be emitted. 079 * 080 * @see #areThereGtsToEmit 081 */ 082 private DetailAST emitSingleGt() 083 { 084 gtToReconcile -= 1; 085 CommonToken gtToken = new CommonToken(GENERIC_END, ">"); 086 gtToken.setLine(currentGtSequence.getLineNo()); 087 gtToken.setColumn(currentGtSequence.getColumnNo() + (currentGtSequence.getText().length() - gtToReconcile)); 088 return (DetailAST)astFactory.create(gtToken); 089 } 090 091 /** 092 * @return true if there is at least one '>' seen but 093 * not reconciled with the end of a typeParameters or 094 * typeArguments production; returns false otherwise 095 */ 096 private boolean areThereGtsToEmit() 097 { 098 return (gtToReconcile > 0); 099 } 100 101 /** 102 * @return true if there is exactly one '>' seen but 103 * not reconciled with the end of a typeParameters 104 * production; returns false otherwise 105 */ 106 private boolean isThereASingleGtToEmit() 107 { 108 return (gtToReconcile == 1); 109 } 110 111 /** 112 * @return true if the '<' and '>' are evenly matched 113 * at the current typeParameters/typeArguments nested depth 114 */ 115 private boolean areLtsAndGtsBalanced(int currentLtLevel) 116 { 117 return ((currentLtLevel != 0) || ltCounter == currentLtLevel); 118 } 119 120protected GeneratedJavaRecognizer(TokenBuffer tokenBuf, int k) { 121 super(tokenBuf,k); 122 tokenNames = _tokenNames; 123 buildTokenTypeASTClassMap(); 124 astFactory = new ASTFactory(getTokenTypeToASTClassMap()); 125} 126 127public GeneratedJavaRecognizer(TokenBuffer tokenBuf) { 128 this(tokenBuf,2); 129} 130 131protected GeneratedJavaRecognizer(TokenStream lexer, int k) { 132 super(lexer,k); 133 tokenNames = _tokenNames; 134 buildTokenTypeASTClassMap(); 135 astFactory = new ASTFactory(getTokenTypeToASTClassMap()); 136} 137 138public GeneratedJavaRecognizer(TokenStream lexer) { 139 this(lexer,2); 140} 141 142public GeneratedJavaRecognizer(ParserSharedInputState state) { 143 super(state,2); 144 tokenNames = _tokenNames; 145 buildTokenTypeASTClassMap(); 146 astFactory = new ASTFactory(getTokenTypeToASTClassMap()); 147} 148 149 public final void compilationUnit() throws RecognitionException, TokenStreamException { 150 151 returnAST = null; 152 ASTPair currentAST = new ASTPair(); 153 AST compilationUnit_AST = null; 154 155 { 156 boolean synPredMatched4 = false; 157 if (((LA(1)==LITERAL_package||LA(1)==AT) && (LA(2)==IDENT))) { 158 int _m4 = mark(); 159 synPredMatched4 = true; 160 inputState.guessing++; 161 try { 162 { 163 annotations(); 164 match(LITERAL_package); 165 } 166 } 167 catch (RecognitionException pe) { 168 synPredMatched4 = false; 169 } 170 rewind(_m4); 171inputState.guessing--; 172 } 173 if ( synPredMatched4 ) { 174 packageDefinition(); 175 astFactory.addASTChild(currentAST, returnAST); 176 } 177 else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) { 178 } 179 else { 180 throw new NoViableAltException(LT(1), getFilename()); 181 } 182 183 } 184 { 185 _loop6: 186 do { 187 if ((LA(1)==SEMI||LA(1)==LITERAL_import) && (_tokenSet_1.member(LA(2)))) { 188 importDefinition(); 189 astFactory.addASTChild(currentAST, returnAST); 190 } 191 else { 192 break _loop6; 193 } 194 195 } while (true); 196 } 197 { 198 _loop8: 199 do { 200 if ((_tokenSet_2.member(LA(1)))) { 201 typeDefinition(); 202 astFactory.addASTChild(currentAST, returnAST); 203 } 204 else { 205 break _loop8; 206 } 207 208 } while (true); 209 } 210 match(Token.EOF_TYPE); 211 compilationUnit_AST = (AST)currentAST.root; 212 returnAST = compilationUnit_AST; 213 } 214 215 public final void annotations() throws RecognitionException, TokenStreamException { 216 217 returnAST = null; 218 ASTPair currentAST = new ASTPair(); 219 AST annotations_AST = null; 220 221 { 222 _loop67: 223 do { 224 if ((LA(1)==AT) && (LA(2)==IDENT)) { 225 annotation(); 226 astFactory.addASTChild(currentAST, returnAST); 227 } 228 else { 229 break _loop67; 230 } 231 232 } while (true); 233 } 234 if ( inputState.guessing==0 ) { 235 annotations_AST = (AST)currentAST.root; 236 annotations_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ANNOTATIONS,"ANNOTATIONS")).add(annotations_AST)); 237 currentAST.root = annotations_AST; 238 currentAST.child = annotations_AST!=null &&annotations_AST.getFirstChild()!=null ? 239 annotations_AST.getFirstChild() : annotations_AST; 240 currentAST.advanceChildToEnd(); 241 } 242 annotations_AST = (AST)currentAST.root; 243 returnAST = annotations_AST; 244 } 245 246 public final void packageDefinition() throws RecognitionException, TokenStreamException { 247 248 returnAST = null; 249 ASTPair currentAST = new ASTPair(); 250 AST packageDefinition_AST = null; 251 Token p = null; 252 AST p_AST = null; 253 254 try { // for error handling 255 annotations(); 256 astFactory.addASTChild(currentAST, returnAST); 257 p = LT(1); 258 p_AST = astFactory.create(p); 259 astFactory.makeASTRoot(currentAST, p_AST); 260 match(LITERAL_package); 261 if ( inputState.guessing==0 ) { 262 p_AST.setType(PACKAGE_DEF); 263 } 264 identifier(); 265 astFactory.addASTChild(currentAST, returnAST); 266 AST tmp2_AST = null; 267 tmp2_AST = astFactory.create(LT(1)); 268 astFactory.addASTChild(currentAST, tmp2_AST); 269 match(SEMI); 270 packageDefinition_AST = (AST)currentAST.root; 271 } 272 catch (RecognitionException ex) { 273 if (inputState.guessing==0) { 274 reportError(ex); 275 recover(ex,_tokenSet_0); 276 } else { 277 throw ex; 278 } 279 } 280 returnAST = packageDefinition_AST; 281 } 282 283 public final void importDefinition() throws RecognitionException, TokenStreamException { 284 285 returnAST = null; 286 ASTPair currentAST = new ASTPair(); 287 AST importDefinition_AST = null; 288 Token i = null; 289 AST i_AST = null; 290 291 try { // for error handling 292 switch ( LA(1)) { 293 case LITERAL_import: 294 { 295 i = LT(1); 296 i_AST = astFactory.create(i); 297 astFactory.makeASTRoot(currentAST, i_AST); 298 match(LITERAL_import); 299 if ( inputState.guessing==0 ) { 300 i_AST.setType(IMPORT); 301 } 302 { 303 switch ( LA(1)) { 304 case LITERAL_static: 305 { 306 AST tmp3_AST = null; 307 tmp3_AST = astFactory.create(LT(1)); 308 astFactory.addASTChild(currentAST, tmp3_AST); 309 match(LITERAL_static); 310 if ( inputState.guessing==0 ) { 311 i_AST.setType(STATIC_IMPORT); 312 } 313 break; 314 } 315 case IDENT: 316 { 317 break; 318 } 319 default: 320 { 321 throw new NoViableAltException(LT(1), getFilename()); 322 } 323 } 324 } 325 identifierStar(); 326 astFactory.addASTChild(currentAST, returnAST); 327 AST tmp4_AST = null; 328 tmp4_AST = astFactory.create(LT(1)); 329 astFactory.addASTChild(currentAST, tmp4_AST); 330 match(SEMI); 331 importDefinition_AST = (AST)currentAST.root; 332 break; 333 } 334 case SEMI: 335 { 336 AST tmp5_AST = null; 337 tmp5_AST = astFactory.create(LT(1)); 338 astFactory.addASTChild(currentAST, tmp5_AST); 339 match(SEMI); 340 importDefinition_AST = (AST)currentAST.root; 341 break; 342 } 343 default: 344 { 345 throw new NoViableAltException(LT(1), getFilename()); 346 } 347 } 348 } 349 catch (RecognitionException ex) { 350 if (inputState.guessing==0) { 351 reportError(ex); 352 recover(ex,_tokenSet_0); 353 } else { 354 throw ex; 355 } 356 } 357 returnAST = importDefinition_AST; 358 } 359 360 public final void typeDefinition() throws RecognitionException, TokenStreamException { 361 362 returnAST = null; 363 ASTPair currentAST = new ASTPair(); 364 AST typeDefinition_AST = null; 365 AST m_AST = null; 366 367 try { // for error handling 368 switch ( LA(1)) { 369 case FINAL: 370 case ABSTRACT: 371 case STRICTFP: 372 case LITERAL_private: 373 case LITERAL_public: 374 case LITERAL_protected: 375 case LITERAL_static: 376 case LITERAL_transient: 377 case LITERAL_native: 378 case LITERAL_synchronized: 379 case LITERAL_volatile: 380 case LITERAL_class: 381 case LITERAL_interface: 382 case LITERAL_default: 383 case ENUM: 384 case AT: 385 { 386 modifiers(); 387 m_AST = (AST)returnAST; 388 typeDefinitionInternal(m_AST); 389 astFactory.addASTChild(currentAST, returnAST); 390 typeDefinition_AST = (AST)currentAST.root; 391 break; 392 } 393 case SEMI: 394 { 395 AST tmp6_AST = null; 396 tmp6_AST = astFactory.create(LT(1)); 397 astFactory.addASTChild(currentAST, tmp6_AST); 398 match(SEMI); 399 typeDefinition_AST = (AST)currentAST.root; 400 break; 401 } 402 default: 403 { 404 throw new NoViableAltException(LT(1), getFilename()); 405 } 406 } 407 } 408 catch (RecognitionException ex) { 409 if (inputState.guessing==0) { 410 reportError(ex); 411 recover(ex,_tokenSet_3); 412 } else { 413 throw ex; 414 } 415 } 416 returnAST = typeDefinition_AST; 417 } 418 419 public final void identifier() throws RecognitionException, TokenStreamException { 420 421 returnAST = null; 422 ASTPair currentAST = new ASTPair(); 423 AST identifier_AST = null; 424 425 AST tmp7_AST = null; 426 tmp7_AST = astFactory.create(LT(1)); 427 astFactory.addASTChild(currentAST, tmp7_AST); 428 match(IDENT); 429 { 430 _loop53: 431 do { 432 if ((LA(1)==DOT) && (LA(2)==IDENT)) { 433 AST tmp8_AST = null; 434 tmp8_AST = astFactory.create(LT(1)); 435 astFactory.makeASTRoot(currentAST, tmp8_AST); 436 match(DOT); 437 AST tmp9_AST = null; 438 tmp9_AST = astFactory.create(LT(1)); 439 astFactory.addASTChild(currentAST, tmp9_AST); 440 match(IDENT); 441 } 442 else { 443 break _loop53; 444 } 445 446 } while (true); 447 } 448 identifier_AST = (AST)currentAST.root; 449 returnAST = identifier_AST; 450 } 451 452 public final void identifierStar() throws RecognitionException, TokenStreamException { 453 454 returnAST = null; 455 ASTPair currentAST = new ASTPair(); 456 AST identifierStar_AST = null; 457 458 AST tmp10_AST = null; 459 tmp10_AST = astFactory.create(LT(1)); 460 astFactory.addASTChild(currentAST, tmp10_AST); 461 match(IDENT); 462 { 463 _loop56: 464 do { 465 if ((LA(1)==DOT) && (LA(2)==IDENT)) { 466 AST tmp11_AST = null; 467 tmp11_AST = astFactory.create(LT(1)); 468 astFactory.makeASTRoot(currentAST, tmp11_AST); 469 match(DOT); 470 AST tmp12_AST = null; 471 tmp12_AST = astFactory.create(LT(1)); 472 astFactory.addASTChild(currentAST, tmp12_AST); 473 match(IDENT); 474 } 475 else { 476 break _loop56; 477 } 478 479 } while (true); 480 } 481 { 482 switch ( LA(1)) { 483 case DOT: 484 { 485 AST tmp13_AST = null; 486 tmp13_AST = astFactory.create(LT(1)); 487 astFactory.makeASTRoot(currentAST, tmp13_AST); 488 match(DOT); 489 AST tmp14_AST = null; 490 tmp14_AST = astFactory.create(LT(1)); 491 astFactory.addASTChild(currentAST, tmp14_AST); 492 match(STAR); 493 break; 494 } 495 case SEMI: 496 { 497 break; 498 } 499 default: 500 { 501 throw new NoViableAltException(LT(1), getFilename()); 502 } 503 } 504 } 505 identifierStar_AST = (AST)currentAST.root; 506 returnAST = identifierStar_AST; 507 } 508 509 public final void modifiers() throws RecognitionException, TokenStreamException { 510 511 returnAST = null; 512 ASTPair currentAST = new ASTPair(); 513 AST modifiers_AST = null; 514 515 { 516 _loop60: 517 do { 518 if ((_tokenSet_4.member(LA(1)))) { 519 modifier(); 520 astFactory.addASTChild(currentAST, returnAST); 521 } 522 else if (((LA(1)==AT) && (LA(2)==IDENT))&&(LA(1)==AT && !LT(2).getText().equals("interface"))) { 523 annotation(); 524 astFactory.addASTChild(currentAST, returnAST); 525 } 526 else { 527 break _loop60; 528 } 529 530 } while (true); 531 } 532 if ( inputState.guessing==0 ) { 533 modifiers_AST = (AST)currentAST.root; 534 modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST)); 535 currentAST.root = modifiers_AST; 536 currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ? 537 modifiers_AST.getFirstChild() : modifiers_AST; 538 currentAST.advanceChildToEnd(); 539 } 540 modifiers_AST = (AST)currentAST.root; 541 returnAST = modifiers_AST; 542 } 543 544 protected final void typeDefinitionInternal( 545 AST modifiers 546 ) throws RecognitionException, TokenStreamException { 547 548 returnAST = null; 549 ASTPair currentAST = new ASTPair(); 550 AST typeDefinitionInternal_AST = null; 551 552 switch ( LA(1)) { 553 case LITERAL_class: 554 { 555 classDefinition(modifiers); 556 astFactory.addASTChild(currentAST, returnAST); 557 typeDefinitionInternal_AST = (AST)currentAST.root; 558 break; 559 } 560 case LITERAL_interface: 561 { 562 interfaceDefinition(modifiers); 563 astFactory.addASTChild(currentAST, returnAST); 564 typeDefinitionInternal_AST = (AST)currentAST.root; 565 break; 566 } 567 case ENUM: 568 { 569 enumDefinition(modifiers); 570 astFactory.addASTChild(currentAST, returnAST); 571 typeDefinitionInternal_AST = (AST)currentAST.root; 572 break; 573 } 574 case AT: 575 { 576 annotationDefinition(modifiers); 577 astFactory.addASTChild(currentAST, returnAST); 578 typeDefinitionInternal_AST = (AST)currentAST.root; 579 break; 580 } 581 default: 582 { 583 throw new NoViableAltException(LT(1), getFilename()); 584 } 585 } 586 returnAST = typeDefinitionInternal_AST; 587 } 588 589 public final void classDefinition( 590 AST modifiers 591 ) throws RecognitionException, TokenStreamException { 592 593 returnAST = null; 594 ASTPair currentAST = new ASTPair(); 595 AST classDefinition_AST = null; 596 Token c = null; 597 AST c_AST = null; 598 AST tp_AST = null; 599 AST sc_AST = null; 600 AST ic_AST = null; 601 AST cb_AST = null; 602 603 c = LT(1); 604 c_AST = astFactory.create(c); 605 match(LITERAL_class); 606 AST tmp15_AST = null; 607 tmp15_AST = astFactory.create(LT(1)); 608 match(IDENT); 609 { 610 switch ( LA(1)) { 611 case LT: 612 { 613 typeParameters(); 614 tp_AST = (AST)returnAST; 615 break; 616 } 617 case LITERAL_extends: 618 case LCURLY: 619 case LITERAL_implements: 620 { 621 break; 622 } 623 default: 624 { 625 throw new NoViableAltException(LT(1), getFilename()); 626 } 627 } 628 } 629 superClassClause(); 630 sc_AST = (AST)returnAST; 631 implementsClause(); 632 ic_AST = (AST)returnAST; 633 classBlock(); 634 cb_AST = (AST)returnAST; 635 if ( inputState.guessing==0 ) { 636 classDefinition_AST = (AST)currentAST.root; 637 classDefinition_AST = (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(c_AST).add(tmp15_AST).add(tp_AST).add(sc_AST).add(ic_AST).add(cb_AST)); 638 currentAST.root = classDefinition_AST; 639 currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ? 640 classDefinition_AST.getFirstChild() : classDefinition_AST; 641 currentAST.advanceChildToEnd(); 642 } 643 returnAST = classDefinition_AST; 644 } 645 646 public final void interfaceDefinition( 647 AST modifiers 648 ) throws RecognitionException, TokenStreamException { 649 650 returnAST = null; 651 ASTPair currentAST = new ASTPair(); 652 AST interfaceDefinition_AST = null; 653 Token i = null; 654 AST i_AST = null; 655 AST tp_AST = null; 656 AST ie_AST = null; 657 AST cb_AST = null; 658 659 i = LT(1); 660 i_AST = astFactory.create(i); 661 match(LITERAL_interface); 662 AST tmp16_AST = null; 663 tmp16_AST = astFactory.create(LT(1)); 664 match(IDENT); 665 { 666 switch ( LA(1)) { 667 case LT: 668 { 669 typeParameters(); 670 tp_AST = (AST)returnAST; 671 break; 672 } 673 case LITERAL_extends: 674 case LCURLY: 675 { 676 break; 677 } 678 default: 679 { 680 throw new NoViableAltException(LT(1), getFilename()); 681 } 682 } 683 } 684 interfaceExtends(); 685 ie_AST = (AST)returnAST; 686 classBlock(); 687 cb_AST = (AST)returnAST; 688 if ( inputState.guessing==0 ) { 689 interfaceDefinition_AST = (AST)currentAST.root; 690 interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(i_AST).add(tmp16_AST).add(tp_AST).add(ie_AST).add(cb_AST)); 691 currentAST.root = interfaceDefinition_AST; 692 currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ? 693 interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST; 694 currentAST.advanceChildToEnd(); 695 } 696 returnAST = interfaceDefinition_AST; 697 } 698 699 public final void enumDefinition( 700 AST modifiers 701 ) throws RecognitionException, TokenStreamException { 702 703 returnAST = null; 704 ASTPair currentAST = new ASTPair(); 705 AST enumDefinition_AST = null; 706 Token e = null; 707 AST e_AST = null; 708 AST ic_AST = null; 709 AST eb_AST = null; 710 711 e = LT(1); 712 e_AST = astFactory.create(e); 713 match(ENUM); 714 AST tmp17_AST = null; 715 tmp17_AST = astFactory.create(LT(1)); 716 match(IDENT); 717 implementsClause(); 718 ic_AST = (AST)returnAST; 719 enumBlock(); 720 eb_AST = (AST)returnAST; 721 if ( inputState.guessing==0 ) { 722 enumDefinition_AST = (AST)currentAST.root; 723 enumDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ENUM_DEF,"ENUM_DEF")).add(modifiers).add(e_AST).add(tmp17_AST).add(ic_AST).add(eb_AST)); 724 currentAST.root = enumDefinition_AST; 725 currentAST.child = enumDefinition_AST!=null &&enumDefinition_AST.getFirstChild()!=null ? 726 enumDefinition_AST.getFirstChild() : enumDefinition_AST; 727 currentAST.advanceChildToEnd(); 728 } 729 returnAST = enumDefinition_AST; 730 } 731 732 public final void annotationDefinition( 733 AST modifiers 734 ) throws RecognitionException, TokenStreamException { 735 736 returnAST = null; 737 ASTPair currentAST = new ASTPair(); 738 AST annotationDefinition_AST = null; 739 Token a = null; 740 AST a_AST = null; 741 Token i = null; 742 AST i_AST = null; 743 AST ab_AST = null; 744 745 a = LT(1); 746 a_AST = astFactory.create(a); 747 match(AT); 748 i = LT(1); 749 i_AST = astFactory.create(i); 750 match(LITERAL_interface); 751 AST tmp18_AST = null; 752 tmp18_AST = astFactory.create(LT(1)); 753 match(IDENT); 754 annotationBlock(); 755 ab_AST = (AST)returnAST; 756 if ( inputState.guessing==0 ) { 757 annotationDefinition_AST = (AST)currentAST.root; 758 annotationDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION_DEF,"ANNOTATION_DEF")).add(modifiers).add(a_AST).add(i_AST).add(tmp18_AST).add(ab_AST)); 759 currentAST.root = annotationDefinition_AST; 760 currentAST.child = annotationDefinition_AST!=null &&annotationDefinition_AST.getFirstChild()!=null ? 761 annotationDefinition_AST.getFirstChild() : annotationDefinition_AST; 762 currentAST.advanceChildToEnd(); 763 } 764 returnAST = annotationDefinition_AST; 765 } 766 767 public final void typeSpec( 768 boolean addImagNode 769 ) throws RecognitionException, TokenStreamException { 770 771 returnAST = null; 772 ASTPair currentAST = new ASTPair(); 773 AST typeSpec_AST = null; 774 775 switch ( LA(1)) { 776 case IDENT: 777 case AT: 778 { 779 classTypeSpec(addImagNode); 780 astFactory.addASTChild(currentAST, returnAST); 781 typeSpec_AST = (AST)currentAST.root; 782 break; 783 } 784 case LITERAL_void: 785 case LITERAL_boolean: 786 case LITERAL_byte: 787 case LITERAL_char: 788 case LITERAL_short: 789 case LITERAL_int: 790 case LITERAL_float: 791 case LITERAL_long: 792 case LITERAL_double: 793 { 794 builtInTypeSpec(addImagNode); 795 astFactory.addASTChild(currentAST, returnAST); 796 typeSpec_AST = (AST)currentAST.root; 797 break; 798 } 799 default: 800 { 801 throw new NoViableAltException(LT(1), getFilename()); 802 } 803 } 804 returnAST = typeSpec_AST; 805 } 806 807 public final void classTypeSpec( 808 boolean addImagNode 809 ) throws RecognitionException, TokenStreamException { 810 811 returnAST = null; 812 ASTPair currentAST = new ASTPair(); 813 AST classTypeSpec_AST = null; 814 Token lb = null; 815 AST lb_AST = null; 816 817 classOrInterfaceType(addImagNode); 818 astFactory.addASTChild(currentAST, returnAST); 819 { 820 _loop17: 821 do { 822 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 823 lb = LT(1); 824 lb_AST = astFactory.create(lb); 825 astFactory.makeASTRoot(currentAST, lb_AST); 826 match(LBRACK); 827 if ( inputState.guessing==0 ) { 828 lb_AST.setType(ARRAY_DECLARATOR); 829 } 830 AST tmp19_AST = null; 831 tmp19_AST = astFactory.create(LT(1)); 832 astFactory.addASTChild(currentAST, tmp19_AST); 833 match(RBRACK); 834 } 835 else { 836 break _loop17; 837 } 838 839 } while (true); 840 } 841 if ( inputState.guessing==0 ) { 842 classTypeSpec_AST = (AST)currentAST.root; 843 844 if ( addImagNode ) { 845 classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST)); 846 } 847 848 currentAST.root = classTypeSpec_AST; 849 currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ? 850 classTypeSpec_AST.getFirstChild() : classTypeSpec_AST; 851 currentAST.advanceChildToEnd(); 852 } 853 classTypeSpec_AST = (AST)currentAST.root; 854 returnAST = classTypeSpec_AST; 855 } 856 857 public final void builtInTypeSpec( 858 boolean addImagNode 859 ) throws RecognitionException, TokenStreamException { 860 861 returnAST = null; 862 ASTPair currentAST = new ASTPair(); 863 AST builtInTypeSpec_AST = null; 864 Token lb = null; 865 AST lb_AST = null; 866 867 builtInType(); 868 astFactory.addASTChild(currentAST, returnAST); 869 { 870 _loop47: 871 do { 872 if ((LA(1)==LBRACK)) { 873 lb = LT(1); 874 lb_AST = astFactory.create(lb); 875 astFactory.makeASTRoot(currentAST, lb_AST); 876 match(LBRACK); 877 if ( inputState.guessing==0 ) { 878 lb_AST.setType(ARRAY_DECLARATOR); 879 } 880 AST tmp20_AST = null; 881 tmp20_AST = astFactory.create(LT(1)); 882 astFactory.addASTChild(currentAST, tmp20_AST); 883 match(RBRACK); 884 } 885 else { 886 break _loop47; 887 } 888 889 } while (true); 890 } 891 if ( inputState.guessing==0 ) { 892 builtInTypeSpec_AST = (AST)currentAST.root; 893 894 if ( addImagNode ) { 895 builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST)); 896 } 897 898 currentAST.root = builtInTypeSpec_AST; 899 currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ? 900 builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST; 901 currentAST.advanceChildToEnd(); 902 } 903 builtInTypeSpec_AST = (AST)currentAST.root; 904 returnAST = builtInTypeSpec_AST; 905 } 906 907 public final void classOrInterfaceType( 908 boolean addImagNode 909 ) throws RecognitionException, TokenStreamException { 910 911 returnAST = null; 912 ASTPair currentAST = new ASTPair(); 913 AST classOrInterfaceType_AST = null; 914 915 { 916 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) { 917 annotations(); 918 astFactory.addASTChild(currentAST, returnAST); 919 } 920 else if ((LA(1)==IDENT) && (_tokenSet_5.member(LA(2)))) { 921 } 922 else { 923 throw new NoViableAltException(LT(1), getFilename()); 924 } 925 926 } 927 AST tmp21_AST = null; 928 tmp21_AST = astFactory.create(LT(1)); 929 astFactory.addASTChild(currentAST, tmp21_AST); 930 match(IDENT); 931 { 932 if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) { 933 typeArguments(addImagNode); 934 astFactory.addASTChild(currentAST, returnAST); 935 } 936 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 937 } 938 else { 939 throw new NoViableAltException(LT(1), getFilename()); 940 } 941 942 } 943 { 944 _loop23: 945 do { 946 if ((LA(1)==DOT) && (LA(2)==IDENT)) { 947 AST tmp22_AST = null; 948 tmp22_AST = astFactory.create(LT(1)); 949 astFactory.makeASTRoot(currentAST, tmp22_AST); 950 match(DOT); 951 AST tmp23_AST = null; 952 tmp23_AST = astFactory.create(LT(1)); 953 astFactory.addASTChild(currentAST, tmp23_AST); 954 match(IDENT); 955 { 956 if ((LA(1)==LT) && (_tokenSet_5.member(LA(2)))) { 957 typeArguments(addImagNode); 958 astFactory.addASTChild(currentAST, returnAST); 959 } 960 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 961 } 962 else { 963 throw new NoViableAltException(LT(1), getFilename()); 964 } 965 966 } 967 } 968 else { 969 break _loop23; 970 } 971 972 } while (true); 973 } 974 classOrInterfaceType_AST = (AST)currentAST.root; 975 returnAST = classOrInterfaceType_AST; 976 } 977 978 public final void typeArguments( 979 boolean addImagNode 980 ) throws RecognitionException, TokenStreamException { 981 982 returnAST = null; 983 ASTPair currentAST = new ASTPair(); 984 AST typeArguments_AST = null; 985 Token lt = null; 986 AST lt_AST = null; 987 int currentLtLevel = 0; 988 989 if ( inputState.guessing==0 ) { 990 currentLtLevel = ltCounter; 991 } 992 lt = LT(1); 993 lt_AST = astFactory.create(lt); 994 astFactory.addASTChild(currentAST, lt_AST); 995 match(LT); 996 if ( inputState.guessing==0 ) { 997 lt_AST.setType(GENERIC_START); ;ltCounter++; 998 } 999 { 1000 if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) { 1001 typeArgument(addImagNode); 1002 astFactory.addASTChild(currentAST, returnAST); 1003 { 1004 _loop35: 1005 do { 1006 if (((LA(1)==COMMA) && (_tokenSet_7.member(LA(2))))&&(gtToReconcile == 0)) { 1007 AST tmp24_AST = null; 1008 tmp24_AST = astFactory.create(LT(1)); 1009 astFactory.addASTChild(currentAST, tmp24_AST); 1010 match(COMMA); 1011 typeArgument(addImagNode); 1012 astFactory.addASTChild(currentAST, returnAST); 1013 } 1014 else { 1015 break _loop35; 1016 } 1017 1018 } while (true); 1019 } 1020 } 1021 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 1022 } 1023 else { 1024 throw new NoViableAltException(LT(1), getFilename()); 1025 } 1026 1027 } 1028 { 1029 if ((_tokenSet_8.member(LA(1))) && (_tokenSet_5.member(LA(2)))) { 1030 typeArgumentsOrParametersEnd(); 1031 astFactory.addASTChild(currentAST, returnAST); 1032 } 1033 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 1034 } 1035 else { 1036 throw new NoViableAltException(LT(1), getFilename()); 1037 } 1038 1039 } 1040 if ( inputState.guessing==0 ) { 1041 1042 if (areThereGtsToEmit()) 1043 { 1044 astFactory.addASTChild(currentAST, emitSingleGt()); 1045 } 1046 1047 } 1048 if (!(areLtsAndGtsBalanced(currentLtLevel))) 1049 throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)"); 1050 if ( inputState.guessing==0 ) { 1051 typeArguments_AST = (AST)currentAST.root; 1052 typeArguments_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENTS,"TYPE_ARGUMENTS")).add(typeArguments_AST)); 1053 currentAST.root = typeArguments_AST; 1054 currentAST.child = typeArguments_AST!=null &&typeArguments_AST.getFirstChild()!=null ? 1055 typeArguments_AST.getFirstChild() : typeArguments_AST; 1056 currentAST.advanceChildToEnd(); 1057 } 1058 typeArguments_AST = (AST)currentAST.root; 1059 returnAST = typeArguments_AST; 1060 } 1061 1062 public final void typeArgument( 1063 boolean addImagNode 1064 ) throws RecognitionException, TokenStreamException { 1065 1066 returnAST = null; 1067 ASTPair currentAST = new ASTPair(); 1068 AST typeArgument_AST = null; 1069 1070 { 1071 { 1072 if (((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2))))&&(LA(1) == AT)) { 1073 annotations(); 1074 astFactory.addASTChild(currentAST, returnAST); 1075 } 1076 else if ((_tokenSet_7.member(LA(1))) && (_tokenSet_5.member(LA(2)))) { 1077 } 1078 else { 1079 throw new NoViableAltException(LT(1), getFilename()); 1080 } 1081 1082 } 1083 { 1084 switch ( LA(1)) { 1085 case IDENT: 1086 case AT: 1087 { 1088 classTypeSpec(addImagNode); 1089 astFactory.addASTChild(currentAST, returnAST); 1090 break; 1091 } 1092 case LITERAL_void: 1093 case LITERAL_boolean: 1094 case LITERAL_byte: 1095 case LITERAL_char: 1096 case LITERAL_short: 1097 case LITERAL_int: 1098 case LITERAL_float: 1099 case LITERAL_long: 1100 case LITERAL_double: 1101 { 1102 builtInTypeArraySpec(addImagNode); 1103 astFactory.addASTChild(currentAST, returnAST); 1104 break; 1105 } 1106 case QUESTION: 1107 { 1108 wildcardType(addImagNode); 1109 astFactory.addASTChild(currentAST, returnAST); 1110 break; 1111 } 1112 default: 1113 { 1114 throw new NoViableAltException(LT(1), getFilename()); 1115 } 1116 } 1117 } 1118 } 1119 if ( inputState.guessing==0 ) { 1120 typeArgument_AST = (AST)currentAST.root; 1121 typeArgument_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_ARGUMENT,"TYPE_ARGUMENT")).add(typeArgument_AST)); 1122 currentAST.root = typeArgument_AST; 1123 currentAST.child = typeArgument_AST!=null &&typeArgument_AST.getFirstChild()!=null ? 1124 typeArgument_AST.getFirstChild() : typeArgument_AST; 1125 currentAST.advanceChildToEnd(); 1126 } 1127 typeArgument_AST = (AST)currentAST.root; 1128 returnAST = typeArgument_AST; 1129 } 1130 1131 public final void builtInTypeArraySpec( 1132 boolean addImagNode 1133 ) throws RecognitionException, TokenStreamException { 1134 1135 returnAST = null; 1136 ASTPair currentAST = new ASTPair(); 1137 AST builtInTypeArraySpec_AST = null; 1138 Token lb = null; 1139 AST lb_AST = null; 1140 1141 builtInType(); 1142 astFactory.addASTChild(currentAST, returnAST); 1143 { 1144 int _cnt44=0; 1145 _loop44: 1146 do { 1147 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 1148 lb = LT(1); 1149 lb_AST = astFactory.create(lb); 1150 astFactory.makeASTRoot(currentAST, lb_AST); 1151 match(LBRACK); 1152 if ( inputState.guessing==0 ) { 1153 lb_AST.setType(ARRAY_DECLARATOR); 1154 } 1155 AST tmp25_AST = null; 1156 tmp25_AST = astFactory.create(LT(1)); 1157 astFactory.addASTChild(currentAST, tmp25_AST); 1158 match(RBRACK); 1159 } 1160 else { 1161 if ( _cnt44>=1 ) { break _loop44; } else {throw new NoViableAltException(LT(1), getFilename());} 1162 } 1163 1164 _cnt44++; 1165 } while (true); 1166 } 1167 if ( inputState.guessing==0 ) { 1168 builtInTypeArraySpec_AST = (AST)currentAST.root; 1169 1170 if ( addImagNode ) { 1171 builtInTypeArraySpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeArraySpec_AST)); 1172 } 1173 1174 currentAST.root = builtInTypeArraySpec_AST; 1175 currentAST.child = builtInTypeArraySpec_AST!=null &&builtInTypeArraySpec_AST.getFirstChild()!=null ? 1176 builtInTypeArraySpec_AST.getFirstChild() : builtInTypeArraySpec_AST; 1177 currentAST.advanceChildToEnd(); 1178 } 1179 builtInTypeArraySpec_AST = (AST)currentAST.root; 1180 returnAST = builtInTypeArraySpec_AST; 1181 } 1182 1183 public final void wildcardType( 1184 boolean addImagNode 1185 ) throws RecognitionException, TokenStreamException { 1186 1187 returnAST = null; 1188 ASTPair currentAST = new ASTPair(); 1189 AST wildcardType_AST = null; 1190 Token q = null; 1191 AST q_AST = null; 1192 1193 q = LT(1); 1194 q_AST = astFactory.create(q); 1195 astFactory.addASTChild(currentAST, q_AST); 1196 match(QUESTION); 1197 if ( inputState.guessing==0 ) { 1198 q_AST.setType(WILDCARD_TYPE); 1199 } 1200 { 1201 boolean synPredMatched31 = false; 1202 if (((LA(1)==LITERAL_extends||LA(1)==LITERAL_super) && (_tokenSet_9.member(LA(2))))) { 1203 int _m31 = mark(); 1204 synPredMatched31 = true; 1205 inputState.guessing++; 1206 try { 1207 { 1208 switch ( LA(1)) { 1209 case LITERAL_extends: 1210 { 1211 match(LITERAL_extends); 1212 break; 1213 } 1214 case LITERAL_super: 1215 { 1216 match(LITERAL_super); 1217 break; 1218 } 1219 default: 1220 { 1221 throw new NoViableAltException(LT(1), getFilename()); 1222 } 1223 } 1224 } 1225 } 1226 catch (RecognitionException pe) { 1227 synPredMatched31 = false; 1228 } 1229 rewind(_m31); 1230inputState.guessing--; 1231 } 1232 if ( synPredMatched31 ) { 1233 typeArgumentBounds(addImagNode); 1234 astFactory.addASTChild(currentAST, returnAST); 1235 } 1236 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 1237 } 1238 else { 1239 throw new NoViableAltException(LT(1), getFilename()); 1240 } 1241 1242 } 1243 wildcardType_AST = (AST)currentAST.root; 1244 returnAST = wildcardType_AST; 1245 } 1246 1247 public final void typeArgumentBounds( 1248 boolean addImagNode 1249 ) throws RecognitionException, TokenStreamException { 1250 1251 returnAST = null; 1252 ASTPair currentAST = new ASTPair(); 1253 AST typeArgumentBounds_AST = null; 1254 Token e = null; 1255 AST e_AST = null; 1256 Token s = null; 1257 AST s_AST = null; 1258 Token lb = null; 1259 AST lb_AST = null; 1260 1261 { 1262 switch ( LA(1)) { 1263 case LITERAL_extends: 1264 { 1265 e = LT(1); 1266 e_AST = astFactory.create(e); 1267 astFactory.makeASTRoot(currentAST, e_AST); 1268 match(LITERAL_extends); 1269 if ( inputState.guessing==0 ) { 1270 e_AST.setType(TYPE_UPPER_BOUNDS); 1271 } 1272 break; 1273 } 1274 case LITERAL_super: 1275 { 1276 s = LT(1); 1277 s_AST = astFactory.create(s); 1278 astFactory.makeASTRoot(currentAST, s_AST); 1279 match(LITERAL_super); 1280 if ( inputState.guessing==0 ) { 1281 s_AST.setType(TYPE_LOWER_BOUNDS); 1282 } 1283 break; 1284 } 1285 default: 1286 { 1287 throw new NoViableAltException(LT(1), getFilename()); 1288 } 1289 } 1290 } 1291 { 1292 switch ( LA(1)) { 1293 case IDENT: 1294 case AT: 1295 { 1296 classOrInterfaceType(addImagNode); 1297 astFactory.addASTChild(currentAST, returnAST); 1298 break; 1299 } 1300 case LITERAL_void: 1301 case LITERAL_boolean: 1302 case LITERAL_byte: 1303 case LITERAL_char: 1304 case LITERAL_short: 1305 case LITERAL_int: 1306 case LITERAL_float: 1307 case LITERAL_long: 1308 case LITERAL_double: 1309 { 1310 builtInType(); 1311 astFactory.addASTChild(currentAST, returnAST); 1312 break; 1313 } 1314 default: 1315 { 1316 throw new NoViableAltException(LT(1), getFilename()); 1317 } 1318 } 1319 } 1320 { 1321 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 1322 lb = LT(1); 1323 lb_AST = astFactory.create(lb); 1324 astFactory.makeASTRoot(currentAST, lb_AST); 1325 match(LBRACK); 1326 if ( inputState.guessing==0 ) { 1327 lb_AST.setType(ARRAY_DECLARATOR); 1328 } 1329 AST tmp26_AST = null; 1330 tmp26_AST = astFactory.create(LT(1)); 1331 astFactory.addASTChild(currentAST, tmp26_AST); 1332 match(RBRACK); 1333 } 1334 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 1335 } 1336 else { 1337 throw new NoViableAltException(LT(1), getFilename()); 1338 } 1339 1340 } 1341 typeArgumentBounds_AST = (AST)currentAST.root; 1342 returnAST = typeArgumentBounds_AST; 1343 } 1344 1345 protected final void typeArgumentsOrParametersEnd() throws RecognitionException, TokenStreamException { 1346 1347 returnAST = null; 1348 ASTPair currentAST = new ASTPair(); 1349 AST typeArgumentsOrParametersEnd_AST = null; 1350 Token g = null; 1351 AST g_AST = null; 1352 Token sr = null; 1353 AST sr_AST = null; 1354 Token bsr = null; 1355 AST bsr_AST = null; 1356 1357 switch ( LA(1)) { 1358 case GT: 1359 { 1360 g = LT(1); 1361 g_AST = astFactory.create(g); 1362 match(GT); 1363 if ( inputState.guessing==0 ) { 1364 consumeCurrentGtSequence((DetailAST)g_AST); 1365 } 1366 break; 1367 } 1368 case SR: 1369 { 1370 sr = LT(1); 1371 sr_AST = astFactory.create(sr); 1372 match(SR); 1373 if ( inputState.guessing==0 ) { 1374 consumeCurrentGtSequence((DetailAST)sr_AST); 1375 } 1376 break; 1377 } 1378 case BSR: 1379 { 1380 bsr = LT(1); 1381 bsr_AST = astFactory.create(bsr); 1382 match(BSR); 1383 if ( inputState.guessing==0 ) { 1384 consumeCurrentGtSequence((DetailAST)bsr_AST); 1385 } 1386 break; 1387 } 1388 default: 1389 { 1390 throw new NoViableAltException(LT(1), getFilename()); 1391 } 1392 } 1393 returnAST = typeArgumentsOrParametersEnd_AST; 1394 } 1395 1396 public final void builtInType() throws RecognitionException, TokenStreamException { 1397 1398 returnAST = null; 1399 ASTPair currentAST = new ASTPair(); 1400 AST builtInType_AST = null; 1401 1402 switch ( LA(1)) { 1403 case LITERAL_void: 1404 { 1405 AST tmp27_AST = null; 1406 tmp27_AST = astFactory.create(LT(1)); 1407 astFactory.addASTChild(currentAST, tmp27_AST); 1408 match(LITERAL_void); 1409 builtInType_AST = (AST)currentAST.root; 1410 break; 1411 } 1412 case LITERAL_boolean: 1413 { 1414 AST tmp28_AST = null; 1415 tmp28_AST = astFactory.create(LT(1)); 1416 astFactory.addASTChild(currentAST, tmp28_AST); 1417 match(LITERAL_boolean); 1418 builtInType_AST = (AST)currentAST.root; 1419 break; 1420 } 1421 case LITERAL_byte: 1422 { 1423 AST tmp29_AST = null; 1424 tmp29_AST = astFactory.create(LT(1)); 1425 astFactory.addASTChild(currentAST, tmp29_AST); 1426 match(LITERAL_byte); 1427 builtInType_AST = (AST)currentAST.root; 1428 break; 1429 } 1430 case LITERAL_char: 1431 { 1432 AST tmp30_AST = null; 1433 tmp30_AST = astFactory.create(LT(1)); 1434 astFactory.addASTChild(currentAST, tmp30_AST); 1435 match(LITERAL_char); 1436 builtInType_AST = (AST)currentAST.root; 1437 break; 1438 } 1439 case LITERAL_short: 1440 { 1441 AST tmp31_AST = null; 1442 tmp31_AST = astFactory.create(LT(1)); 1443 astFactory.addASTChild(currentAST, tmp31_AST); 1444 match(LITERAL_short); 1445 builtInType_AST = (AST)currentAST.root; 1446 break; 1447 } 1448 case LITERAL_int: 1449 { 1450 AST tmp32_AST = null; 1451 tmp32_AST = astFactory.create(LT(1)); 1452 astFactory.addASTChild(currentAST, tmp32_AST); 1453 match(LITERAL_int); 1454 builtInType_AST = (AST)currentAST.root; 1455 break; 1456 } 1457 case LITERAL_float: 1458 { 1459 AST tmp33_AST = null; 1460 tmp33_AST = astFactory.create(LT(1)); 1461 astFactory.addASTChild(currentAST, tmp33_AST); 1462 match(LITERAL_float); 1463 builtInType_AST = (AST)currentAST.root; 1464 break; 1465 } 1466 case LITERAL_long: 1467 { 1468 AST tmp34_AST = null; 1469 tmp34_AST = astFactory.create(LT(1)); 1470 astFactory.addASTChild(currentAST, tmp34_AST); 1471 match(LITERAL_long); 1472 builtInType_AST = (AST)currentAST.root; 1473 break; 1474 } 1475 case LITERAL_double: 1476 { 1477 AST tmp35_AST = null; 1478 tmp35_AST = astFactory.create(LT(1)); 1479 astFactory.addASTChild(currentAST, tmp35_AST); 1480 match(LITERAL_double); 1481 builtInType_AST = (AST)currentAST.root; 1482 break; 1483 } 1484 default: 1485 { 1486 throw new NoViableAltException(LT(1), getFilename()); 1487 } 1488 } 1489 returnAST = builtInType_AST; 1490 } 1491 1492 public final void type() throws RecognitionException, TokenStreamException { 1493 1494 returnAST = null; 1495 ASTPair currentAST = new ASTPair(); 1496 AST type_AST = null; 1497 1498 switch ( LA(1)) { 1499 case IDENT: 1500 case AT: 1501 { 1502 classOrInterfaceType(false); 1503 astFactory.addASTChild(currentAST, returnAST); 1504 type_AST = (AST)currentAST.root; 1505 break; 1506 } 1507 case LITERAL_void: 1508 case LITERAL_boolean: 1509 case LITERAL_byte: 1510 case LITERAL_char: 1511 case LITERAL_short: 1512 case LITERAL_int: 1513 case LITERAL_float: 1514 case LITERAL_long: 1515 case LITERAL_double: 1516 { 1517 builtInType(); 1518 astFactory.addASTChild(currentAST, returnAST); 1519 type_AST = (AST)currentAST.root; 1520 break; 1521 } 1522 default: 1523 { 1524 throw new NoViableAltException(LT(1), getFilename()); 1525 } 1526 } 1527 returnAST = type_AST; 1528 } 1529 1530/** A declaration is the creation of a reference or primitive-type variable 1531 * Create a separate Type/Var tree for each var in the var list. 1532 */ 1533 public final void declaration() throws RecognitionException, TokenStreamException { 1534 1535 returnAST = null; 1536 ASTPair currentAST = new ASTPair(); 1537 AST declaration_AST = null; 1538 AST m_AST = null; 1539 AST t_AST = null; 1540 AST v_AST = null; 1541 1542 modifiers(); 1543 m_AST = (AST)returnAST; 1544 typeSpec(false); 1545 t_AST = (AST)returnAST; 1546 variableDefinitions(m_AST,t_AST); 1547 v_AST = (AST)returnAST; 1548 if ( inputState.guessing==0 ) { 1549 declaration_AST = (AST)currentAST.root; 1550 declaration_AST = v_AST; 1551 currentAST.root = declaration_AST; 1552 currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ? 1553 declaration_AST.getFirstChild() : declaration_AST; 1554 currentAST.advanceChildToEnd(); 1555 } 1556 returnAST = declaration_AST; 1557 } 1558 1559 public final void variableDefinitions( 1560 AST mods, AST t 1561 ) throws RecognitionException, TokenStreamException { 1562 1563 returnAST = null; 1564 ASTPair currentAST = new ASTPair(); 1565 AST variableDefinitions_AST = null; 1566 1567 variableDeclarator((AST) getASTFactory().dupTree(mods), 1568 (AST) getASTFactory().dupList(t)); 1569 astFactory.addASTChild(currentAST, returnAST); 1570 { 1571 _loop159: 1572 do { 1573 if ((LA(1)==COMMA)) { 1574 AST tmp36_AST = null; 1575 tmp36_AST = astFactory.create(LT(1)); 1576 astFactory.addASTChild(currentAST, tmp36_AST); 1577 match(COMMA); 1578 variableDeclarator((AST) getASTFactory().dupTree(mods), 1579 (AST) getASTFactory().dupList(t)); 1580 astFactory.addASTChild(currentAST, returnAST); 1581 } 1582 else { 1583 break _loop159; 1584 } 1585 1586 } while (true); 1587 } 1588 variableDefinitions_AST = (AST)currentAST.root; 1589 returnAST = variableDefinitions_AST; 1590 } 1591 1592 public final void modifier() throws RecognitionException, TokenStreamException { 1593 1594 returnAST = null; 1595 ASTPair currentAST = new ASTPair(); 1596 AST modifier_AST = null; 1597 1598 switch ( LA(1)) { 1599 case LITERAL_private: 1600 { 1601 AST tmp37_AST = null; 1602 tmp37_AST = astFactory.create(LT(1)); 1603 astFactory.addASTChild(currentAST, tmp37_AST); 1604 match(LITERAL_private); 1605 modifier_AST = (AST)currentAST.root; 1606 break; 1607 } 1608 case LITERAL_public: 1609 { 1610 AST tmp38_AST = null; 1611 tmp38_AST = astFactory.create(LT(1)); 1612 astFactory.addASTChild(currentAST, tmp38_AST); 1613 match(LITERAL_public); 1614 modifier_AST = (AST)currentAST.root; 1615 break; 1616 } 1617 case LITERAL_protected: 1618 { 1619 AST tmp39_AST = null; 1620 tmp39_AST = astFactory.create(LT(1)); 1621 astFactory.addASTChild(currentAST, tmp39_AST); 1622 match(LITERAL_protected); 1623 modifier_AST = (AST)currentAST.root; 1624 break; 1625 } 1626 case LITERAL_static: 1627 { 1628 AST tmp40_AST = null; 1629 tmp40_AST = astFactory.create(LT(1)); 1630 astFactory.addASTChild(currentAST, tmp40_AST); 1631 match(LITERAL_static); 1632 modifier_AST = (AST)currentAST.root; 1633 break; 1634 } 1635 case LITERAL_transient: 1636 { 1637 AST tmp41_AST = null; 1638 tmp41_AST = astFactory.create(LT(1)); 1639 astFactory.addASTChild(currentAST, tmp41_AST); 1640 match(LITERAL_transient); 1641 modifier_AST = (AST)currentAST.root; 1642 break; 1643 } 1644 case FINAL: 1645 { 1646 AST tmp42_AST = null; 1647 tmp42_AST = astFactory.create(LT(1)); 1648 astFactory.addASTChild(currentAST, tmp42_AST); 1649 match(FINAL); 1650 modifier_AST = (AST)currentAST.root; 1651 break; 1652 } 1653 case ABSTRACT: 1654 { 1655 AST tmp43_AST = null; 1656 tmp43_AST = astFactory.create(LT(1)); 1657 astFactory.addASTChild(currentAST, tmp43_AST); 1658 match(ABSTRACT); 1659 modifier_AST = (AST)currentAST.root; 1660 break; 1661 } 1662 case LITERAL_native: 1663 { 1664 AST tmp44_AST = null; 1665 tmp44_AST = astFactory.create(LT(1)); 1666 astFactory.addASTChild(currentAST, tmp44_AST); 1667 match(LITERAL_native); 1668 modifier_AST = (AST)currentAST.root; 1669 break; 1670 } 1671 case LITERAL_synchronized: 1672 { 1673 AST tmp45_AST = null; 1674 tmp45_AST = astFactory.create(LT(1)); 1675 astFactory.addASTChild(currentAST, tmp45_AST); 1676 match(LITERAL_synchronized); 1677 modifier_AST = (AST)currentAST.root; 1678 break; 1679 } 1680 case LITERAL_volatile: 1681 { 1682 AST tmp46_AST = null; 1683 tmp46_AST = astFactory.create(LT(1)); 1684 astFactory.addASTChild(currentAST, tmp46_AST); 1685 match(LITERAL_volatile); 1686 modifier_AST = (AST)currentAST.root; 1687 break; 1688 } 1689 case STRICTFP: 1690 { 1691 AST tmp47_AST = null; 1692 tmp47_AST = astFactory.create(LT(1)); 1693 astFactory.addASTChild(currentAST, tmp47_AST); 1694 match(STRICTFP); 1695 modifier_AST = (AST)currentAST.root; 1696 break; 1697 } 1698 case LITERAL_default: 1699 { 1700 AST tmp48_AST = null; 1701 tmp48_AST = astFactory.create(LT(1)); 1702 astFactory.addASTChild(currentAST, tmp48_AST); 1703 match(LITERAL_default); 1704 modifier_AST = (AST)currentAST.root; 1705 break; 1706 } 1707 default: 1708 { 1709 throw new NoViableAltException(LT(1), getFilename()); 1710 } 1711 } 1712 returnAST = modifier_AST; 1713 } 1714 1715 public final void annotation() throws RecognitionException, TokenStreamException { 1716 1717 returnAST = null; 1718 ASTPair currentAST = new ASTPair(); 1719 AST annotation_AST = null; 1720 AST i_AST = null; 1721 Token l = null; 1722 AST l_AST = null; 1723 AST args_AST = null; 1724 Token r = null; 1725 AST r_AST = null; 1726 1727 AST tmp49_AST = null; 1728 tmp49_AST = astFactory.create(LT(1)); 1729 match(AT); 1730 identifier(); 1731 i_AST = (AST)returnAST; 1732 { 1733 if ((LA(1)==LPAREN) && (_tokenSet_10.member(LA(2)))) { 1734 l = LT(1); 1735 l_AST = astFactory.create(l); 1736 match(LPAREN); 1737 { 1738 switch ( LA(1)) { 1739 case LITERAL_void: 1740 case LITERAL_boolean: 1741 case LITERAL_byte: 1742 case LITERAL_char: 1743 case LITERAL_short: 1744 case LITERAL_int: 1745 case LITERAL_float: 1746 case LITERAL_long: 1747 case LITERAL_double: 1748 case IDENT: 1749 case LCURLY: 1750 case LPAREN: 1751 case LITERAL_this: 1752 case LITERAL_super: 1753 case PLUS: 1754 case MINUS: 1755 case INC: 1756 case DEC: 1757 case BNOT: 1758 case LNOT: 1759 case LITERAL_true: 1760 case LITERAL_false: 1761 case LITERAL_null: 1762 case LITERAL_new: 1763 case NUM_INT: 1764 case CHAR_LITERAL: 1765 case STRING_LITERAL: 1766 case NUM_FLOAT: 1767 case NUM_LONG: 1768 case NUM_DOUBLE: 1769 case AT: 1770 { 1771 annotationArguments(); 1772 args_AST = (AST)returnAST; 1773 break; 1774 } 1775 case RPAREN: 1776 { 1777 break; 1778 } 1779 default: 1780 { 1781 throw new NoViableAltException(LT(1), getFilename()); 1782 } 1783 } 1784 } 1785 r = LT(1); 1786 r_AST = astFactory.create(r); 1787 match(RPAREN); 1788 } 1789 else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 1790 } 1791 else { 1792 throw new NoViableAltException(LT(1), getFilename()); 1793 } 1794 1795 } 1796 if ( inputState.guessing==0 ) { 1797 annotation_AST = (AST)currentAST.root; 1798 annotation_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(ANNOTATION,"ANNOTATION")).add(tmp49_AST).add(i_AST).add(l_AST).add(args_AST).add(r_AST)); 1799 currentAST.root = annotation_AST; 1800 currentAST.child = annotation_AST!=null &&annotation_AST.getFirstChild()!=null ? 1801 annotation_AST.getFirstChild() : annotation_AST; 1802 currentAST.advanceChildToEnd(); 1803 } 1804 returnAST = annotation_AST; 1805 } 1806 1807 public final void annotationArguments() throws RecognitionException, TokenStreamException { 1808 1809 returnAST = null; 1810 ASTPair currentAST = new ASTPair(); 1811 AST annotationArguments_AST = null; 1812 1813 if ((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) { 1814 annotationMemberValueInitializer(); 1815 astFactory.addASTChild(currentAST, returnAST); 1816 annotationArguments_AST = (AST)currentAST.root; 1817 } 1818 else if ((LA(1)==IDENT) && (LA(2)==ASSIGN)) { 1819 annotationMemberValuePairs(); 1820 astFactory.addASTChild(currentAST, returnAST); 1821 annotationArguments_AST = (AST)currentAST.root; 1822 } 1823 else { 1824 throw new NoViableAltException(LT(1), getFilename()); 1825 } 1826 1827 returnAST = annotationArguments_AST; 1828 } 1829 1830 public final void annotationMemberValueInitializer() throws RecognitionException, TokenStreamException { 1831 1832 returnAST = null; 1833 ASTPair currentAST = new ASTPair(); 1834 AST annotationMemberValueInitializer_AST = null; 1835 1836 switch ( LA(1)) { 1837 case LITERAL_void: 1838 case LITERAL_boolean: 1839 case LITERAL_byte: 1840 case LITERAL_char: 1841 case LITERAL_short: 1842 case LITERAL_int: 1843 case LITERAL_float: 1844 case LITERAL_long: 1845 case LITERAL_double: 1846 case IDENT: 1847 case LPAREN: 1848 case LITERAL_this: 1849 case LITERAL_super: 1850 case PLUS: 1851 case MINUS: 1852 case INC: 1853 case DEC: 1854 case BNOT: 1855 case LNOT: 1856 case LITERAL_true: 1857 case LITERAL_false: 1858 case LITERAL_null: 1859 case LITERAL_new: 1860 case NUM_INT: 1861 case CHAR_LITERAL: 1862 case STRING_LITERAL: 1863 case NUM_FLOAT: 1864 case NUM_LONG: 1865 case NUM_DOUBLE: 1866 { 1867 annotationExpression(); 1868 astFactory.addASTChild(currentAST, returnAST); 1869 annotationMemberValueInitializer_AST = (AST)currentAST.root; 1870 break; 1871 } 1872 case AT: 1873 { 1874 annotation(); 1875 astFactory.addASTChild(currentAST, returnAST); 1876 annotationMemberValueInitializer_AST = (AST)currentAST.root; 1877 break; 1878 } 1879 case LCURLY: 1880 { 1881 annotationMemberArrayInitializer(); 1882 astFactory.addASTChild(currentAST, returnAST); 1883 annotationMemberValueInitializer_AST = (AST)currentAST.root; 1884 break; 1885 } 1886 default: 1887 { 1888 throw new NoViableAltException(LT(1), getFilename()); 1889 } 1890 } 1891 returnAST = annotationMemberValueInitializer_AST; 1892 } 1893 1894 public final void annotationMemberValuePairs() throws RecognitionException, TokenStreamException { 1895 1896 returnAST = null; 1897 ASTPair currentAST = new ASTPair(); 1898 AST annotationMemberValuePairs_AST = null; 1899 1900 annotationMemberValuePair(); 1901 astFactory.addASTChild(currentAST, returnAST); 1902 { 1903 _loop71: 1904 do { 1905 if ((LA(1)==COMMA)) { 1906 AST tmp50_AST = null; 1907 tmp50_AST = astFactory.create(LT(1)); 1908 astFactory.addASTChild(currentAST, tmp50_AST); 1909 match(COMMA); 1910 annotationMemberValuePair(); 1911 astFactory.addASTChild(currentAST, returnAST); 1912 } 1913 else { 1914 break _loop71; 1915 } 1916 1917 } while (true); 1918 } 1919 annotationMemberValuePairs_AST = (AST)currentAST.root; 1920 returnAST = annotationMemberValuePairs_AST; 1921 } 1922 1923 public final void annotationMemberValuePair() throws RecognitionException, TokenStreamException { 1924 1925 returnAST = null; 1926 ASTPair currentAST = new ASTPair(); 1927 AST annotationMemberValuePair_AST = null; 1928 Token i = null; 1929 AST i_AST = null; 1930 Token a = null; 1931 AST a_AST = null; 1932 AST v_AST = null; 1933 1934 i = LT(1); 1935 i_AST = astFactory.create(i); 1936 match(IDENT); 1937 a = LT(1); 1938 a_AST = astFactory.create(a); 1939 match(ASSIGN); 1940 annotationMemberValueInitializer(); 1941 v_AST = (AST)returnAST; 1942 if ( inputState.guessing==0 ) { 1943 annotationMemberValuePair_AST = (AST)currentAST.root; 1944 annotationMemberValuePair_AST = (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)); 1945 currentAST.root = annotationMemberValuePair_AST; 1946 currentAST.child = annotationMemberValuePair_AST!=null &&annotationMemberValuePair_AST.getFirstChild()!=null ? 1947 annotationMemberValuePair_AST.getFirstChild() : annotationMemberValuePair_AST; 1948 currentAST.advanceChildToEnd(); 1949 } 1950 returnAST = annotationMemberValuePair_AST; 1951 } 1952 1953 public final void annotationExpression() throws RecognitionException, TokenStreamException { 1954 1955 returnAST = null; 1956 ASTPair currentAST = new ASTPair(); 1957 AST annotationExpression_AST = null; 1958 1959 conditionalExpression(); 1960 astFactory.addASTChild(currentAST, returnAST); 1961 if ( inputState.guessing==0 ) { 1962 annotationExpression_AST = (AST)currentAST.root; 1963 annotationExpression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(annotationExpression_AST)); 1964 currentAST.root = annotationExpression_AST; 1965 currentAST.child = annotationExpression_AST!=null &&annotationExpression_AST.getFirstChild()!=null ? 1966 annotationExpression_AST.getFirstChild() : annotationExpression_AST; 1967 currentAST.advanceChildToEnd(); 1968 } 1969 annotationExpression_AST = (AST)currentAST.root; 1970 returnAST = annotationExpression_AST; 1971 } 1972 1973 public final void annotationMemberArrayInitializer() throws RecognitionException, TokenStreamException { 1974 1975 returnAST = null; 1976 ASTPair currentAST = new ASTPair(); 1977 AST annotationMemberArrayInitializer_AST = null; 1978 Token lc = null; 1979 AST lc_AST = null; 1980 1981 lc = LT(1); 1982 lc_AST = astFactory.create(lc); 1983 astFactory.makeASTRoot(currentAST, lc_AST); 1984 match(LCURLY); 1985 if ( inputState.guessing==0 ) { 1986 lc_AST.setType(ANNOTATION_ARRAY_INIT); 1987 } 1988 { 1989 switch ( LA(1)) { 1990 case LITERAL_void: 1991 case LITERAL_boolean: 1992 case LITERAL_byte: 1993 case LITERAL_char: 1994 case LITERAL_short: 1995 case LITERAL_int: 1996 case LITERAL_float: 1997 case LITERAL_long: 1998 case LITERAL_double: 1999 case IDENT: 2000 case LPAREN: 2001 case LITERAL_this: 2002 case LITERAL_super: 2003 case PLUS: 2004 case MINUS: 2005 case INC: 2006 case DEC: 2007 case BNOT: 2008 case LNOT: 2009 case LITERAL_true: 2010 case LITERAL_false: 2011 case LITERAL_null: 2012 case LITERAL_new: 2013 case NUM_INT: 2014 case CHAR_LITERAL: 2015 case STRING_LITERAL: 2016 case NUM_FLOAT: 2017 case NUM_LONG: 2018 case NUM_DOUBLE: 2019 case AT: 2020 { 2021 annotationMemberArrayValueInitializer(); 2022 astFactory.addASTChild(currentAST, returnAST); 2023 { 2024 _loop77: 2025 do { 2026 if ((LA(1)==COMMA) && (_tokenSet_14.member(LA(2)))) { 2027 AST tmp51_AST = null; 2028 tmp51_AST = astFactory.create(LT(1)); 2029 astFactory.addASTChild(currentAST, tmp51_AST); 2030 match(COMMA); 2031 annotationMemberArrayValueInitializer(); 2032 astFactory.addASTChild(currentAST, returnAST); 2033 } 2034 else { 2035 break _loop77; 2036 } 2037 2038 } while (true); 2039 } 2040 { 2041 switch ( LA(1)) { 2042 case COMMA: 2043 { 2044 AST tmp52_AST = null; 2045 tmp52_AST = astFactory.create(LT(1)); 2046 astFactory.addASTChild(currentAST, tmp52_AST); 2047 match(COMMA); 2048 break; 2049 } 2050 case RCURLY: 2051 { 2052 break; 2053 } 2054 default: 2055 { 2056 throw new NoViableAltException(LT(1), getFilename()); 2057 } 2058 } 2059 } 2060 break; 2061 } 2062 case RCURLY: 2063 { 2064 break; 2065 } 2066 default: 2067 { 2068 throw new NoViableAltException(LT(1), getFilename()); 2069 } 2070 } 2071 } 2072 AST tmp53_AST = null; 2073 tmp53_AST = astFactory.create(LT(1)); 2074 astFactory.addASTChild(currentAST, tmp53_AST); 2075 match(RCURLY); 2076 annotationMemberArrayInitializer_AST = (AST)currentAST.root; 2077 returnAST = annotationMemberArrayInitializer_AST; 2078 } 2079 2080 public final void annotationMemberArrayValueInitializer() throws RecognitionException, TokenStreamException { 2081 2082 returnAST = null; 2083 ASTPair currentAST = new ASTPair(); 2084 AST annotationMemberArrayValueInitializer_AST = null; 2085 2086 switch ( LA(1)) { 2087 case LITERAL_void: 2088 case LITERAL_boolean: 2089 case LITERAL_byte: 2090 case LITERAL_char: 2091 case LITERAL_short: 2092 case LITERAL_int: 2093 case LITERAL_float: 2094 case LITERAL_long: 2095 case LITERAL_double: 2096 case IDENT: 2097 case LPAREN: 2098 case LITERAL_this: 2099 case LITERAL_super: 2100 case PLUS: 2101 case MINUS: 2102 case INC: 2103 case DEC: 2104 case BNOT: 2105 case LNOT: 2106 case LITERAL_true: 2107 case LITERAL_false: 2108 case LITERAL_null: 2109 case LITERAL_new: 2110 case NUM_INT: 2111 case CHAR_LITERAL: 2112 case STRING_LITERAL: 2113 case NUM_FLOAT: 2114 case NUM_LONG: 2115 case NUM_DOUBLE: 2116 { 2117 annotationExpression(); 2118 astFactory.addASTChild(currentAST, returnAST); 2119 annotationMemberArrayValueInitializer_AST = (AST)currentAST.root; 2120 break; 2121 } 2122 case AT: 2123 { 2124 annotation(); 2125 astFactory.addASTChild(currentAST, returnAST); 2126 annotationMemberArrayValueInitializer_AST = (AST)currentAST.root; 2127 break; 2128 } 2129 default: 2130 { 2131 throw new NoViableAltException(LT(1), getFilename()); 2132 } 2133 } 2134 returnAST = annotationMemberArrayValueInitializer_AST; 2135 } 2136 2137 public final void conditionalExpression() throws RecognitionException, TokenStreamException { 2138 2139 returnAST = null; 2140 ASTPair currentAST = new ASTPair(); 2141 AST conditionalExpression_AST = null; 2142 2143 logicalOrExpression(); 2144 astFactory.addASTChild(currentAST, returnAST); 2145 { 2146 switch ( LA(1)) { 2147 case QUESTION: 2148 { 2149 AST tmp54_AST = null; 2150 tmp54_AST = astFactory.create(LT(1)); 2151 astFactory.makeASTRoot(currentAST, tmp54_AST); 2152 match(QUESTION); 2153 { 2154 boolean synPredMatched270 = false; 2155 if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) { 2156 int _m270 = mark(); 2157 synPredMatched270 = true; 2158 inputState.guessing++; 2159 try { 2160 { 2161 lambdaExpression(); 2162 } 2163 } 2164 catch (RecognitionException pe) { 2165 synPredMatched270 = false; 2166 } 2167 rewind(_m270); 2168inputState.guessing--; 2169 } 2170 if ( synPredMatched270 ) { 2171 lambdaExpression(); 2172 astFactory.addASTChild(currentAST, returnAST); 2173 } 2174 else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_17.member(LA(2)))) { 2175 assignmentExpression(); 2176 astFactory.addASTChild(currentAST, returnAST); 2177 } 2178 else { 2179 throw new NoViableAltException(LT(1), getFilename()); 2180 } 2181 2182 } 2183 AST tmp55_AST = null; 2184 tmp55_AST = astFactory.create(LT(1)); 2185 astFactory.addASTChild(currentAST, tmp55_AST); 2186 match(COLON); 2187 { 2188 boolean synPredMatched273 = false; 2189 if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) { 2190 int _m273 = mark(); 2191 synPredMatched273 = true; 2192 inputState.guessing++; 2193 try { 2194 { 2195 lambdaExpression(); 2196 } 2197 } 2198 catch (RecognitionException pe) { 2199 synPredMatched273 = false; 2200 } 2201 rewind(_m273); 2202inputState.guessing--; 2203 } 2204 if ( synPredMatched273 ) { 2205 lambdaExpression(); 2206 astFactory.addASTChild(currentAST, returnAST); 2207 } 2208 else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { 2209 conditionalExpression(); 2210 astFactory.addASTChild(currentAST, returnAST); 2211 } 2212 else { 2213 throw new NoViableAltException(LT(1), getFilename()); 2214 } 2215 2216 } 2217 break; 2218 } 2219 case FINAL: 2220 case ABSTRACT: 2221 case STRICTFP: 2222 case SEMI: 2223 case RBRACK: 2224 case LITERAL_void: 2225 case LITERAL_boolean: 2226 case LITERAL_byte: 2227 case LITERAL_char: 2228 case LITERAL_short: 2229 case LITERAL_int: 2230 case LITERAL_float: 2231 case LITERAL_long: 2232 case LITERAL_double: 2233 case IDENT: 2234 case LITERAL_private: 2235 case LITERAL_public: 2236 case LITERAL_protected: 2237 case LITERAL_static: 2238 case LITERAL_transient: 2239 case LITERAL_native: 2240 case LITERAL_synchronized: 2241 case LITERAL_volatile: 2242 case LITERAL_class: 2243 case LITERAL_interface: 2244 case LCURLY: 2245 case RCURLY: 2246 case COMMA: 2247 case LPAREN: 2248 case RPAREN: 2249 case LITERAL_this: 2250 case LITERAL_super: 2251 case ASSIGN: 2252 case COLON: 2253 case LITERAL_if: 2254 case LITERAL_while: 2255 case LITERAL_do: 2256 case LITERAL_break: 2257 case LITERAL_continue: 2258 case LITERAL_return: 2259 case LITERAL_switch: 2260 case LITERAL_throw: 2261 case LITERAL_for: 2262 case LITERAL_else: 2263 case LITERAL_case: 2264 case LITERAL_default: 2265 case LITERAL_try: 2266 case PLUS_ASSIGN: 2267 case MINUS_ASSIGN: 2268 case STAR_ASSIGN: 2269 case DIV_ASSIGN: 2270 case MOD_ASSIGN: 2271 case SR_ASSIGN: 2272 case BSR_ASSIGN: 2273 case SL_ASSIGN: 2274 case BAND_ASSIGN: 2275 case BXOR_ASSIGN: 2276 case BOR_ASSIGN: 2277 case LT: 2278 case PLUS: 2279 case MINUS: 2280 case INC: 2281 case DEC: 2282 case BNOT: 2283 case LNOT: 2284 case LITERAL_true: 2285 case LITERAL_false: 2286 case LITERAL_null: 2287 case LITERAL_new: 2288 case NUM_INT: 2289 case CHAR_LITERAL: 2290 case STRING_LITERAL: 2291 case NUM_FLOAT: 2292 case NUM_LONG: 2293 case NUM_DOUBLE: 2294 case ASSERT: 2295 case ENUM: 2296 case AT: 2297 { 2298 break; 2299 } 2300 default: 2301 { 2302 throw new NoViableAltException(LT(1), getFilename()); 2303 } 2304 } 2305 } 2306 conditionalExpression_AST = (AST)currentAST.root; 2307 returnAST = conditionalExpression_AST; 2308 } 2309 2310 public final void typeParameters() throws RecognitionException, TokenStreamException { 2311 2312 returnAST = null; 2313 ASTPair currentAST = new ASTPair(); 2314 AST typeParameters_AST = null; 2315 Token lt = null; 2316 AST lt_AST = null; 2317 int currentLtLevel = 0; 2318 2319 if ( inputState.guessing==0 ) { 2320 currentLtLevel = ltCounter; 2321 } 2322 lt = LT(1); 2323 lt_AST = astFactory.create(lt); 2324 astFactory.addASTChild(currentAST, lt_AST); 2325 match(LT); 2326 if ( inputState.guessing==0 ) { 2327 lt_AST.setType(GENERIC_START); ltCounter++; 2328 } 2329 typeParameter(); 2330 astFactory.addASTChild(currentAST, returnAST); 2331 { 2332 _loop91: 2333 do { 2334 if ((LA(1)==COMMA)) { 2335 AST tmp56_AST = null; 2336 tmp56_AST = astFactory.create(LT(1)); 2337 astFactory.addASTChild(currentAST, tmp56_AST); 2338 match(COMMA); 2339 typeParameter(); 2340 astFactory.addASTChild(currentAST, returnAST); 2341 } 2342 else { 2343 break _loop91; 2344 } 2345 2346 } while (true); 2347 } 2348 { 2349 switch ( LA(1)) { 2350 case GT: 2351 case SR: 2352 case BSR: 2353 { 2354 typeArgumentsOrParametersEnd(); 2355 astFactory.addASTChild(currentAST, returnAST); 2356 break; 2357 } 2358 case LITERAL_void: 2359 case LITERAL_boolean: 2360 case LITERAL_byte: 2361 case LITERAL_char: 2362 case LITERAL_short: 2363 case LITERAL_int: 2364 case LITERAL_float: 2365 case LITERAL_long: 2366 case LITERAL_double: 2367 case IDENT: 2368 case LITERAL_extends: 2369 case LCURLY: 2370 case LITERAL_implements: 2371 case AT: 2372 { 2373 break; 2374 } 2375 default: 2376 { 2377 throw new NoViableAltException(LT(1), getFilename()); 2378 } 2379 } 2380 } 2381 if ( inputState.guessing==0 ) { 2382 2383 if (isThereASingleGtToEmit()) { 2384 astFactory.addASTChild(currentAST, emitSingleGt()); 2385 } 2386 2387 } 2388 if (!(areLtsAndGtsBalanced(currentLtLevel))) 2389 throw new SemanticException("areLtsAndGtsBalanced(currentLtLevel)"); 2390 if ( inputState.guessing==0 ) { 2391 typeParameters_AST = (AST)currentAST.root; 2392 typeParameters_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETERS,"TYPE_PARAMETERS")).add(typeParameters_AST)); 2393 currentAST.root = typeParameters_AST; 2394 currentAST.child = typeParameters_AST!=null &&typeParameters_AST.getFirstChild()!=null ? 2395 typeParameters_AST.getFirstChild() : typeParameters_AST; 2396 currentAST.advanceChildToEnd(); 2397 } 2398 typeParameters_AST = (AST)currentAST.root; 2399 returnAST = typeParameters_AST; 2400 } 2401 2402 public final void superClassClause() throws RecognitionException, TokenStreamException { 2403 2404 returnAST = null; 2405 ASTPair currentAST = new ASTPair(); 2406 AST superClassClause_AST = null; 2407 Token e = null; 2408 AST e_AST = null; 2409 AST c_AST = null; 2410 2411 { 2412 switch ( LA(1)) { 2413 case LITERAL_extends: 2414 { 2415 e = LT(1); 2416 e_AST = astFactory.create(e); 2417 astFactory.makeASTRoot(currentAST, e_AST); 2418 match(LITERAL_extends); 2419 if ( inputState.guessing==0 ) { 2420 e_AST.setType(EXTENDS_CLAUSE); 2421 } 2422 classOrInterfaceType(false); 2423 c_AST = (AST)returnAST; 2424 astFactory.addASTChild(currentAST, returnAST); 2425 break; 2426 } 2427 case LCURLY: 2428 case LITERAL_implements: 2429 { 2430 break; 2431 } 2432 default: 2433 { 2434 throw new NoViableAltException(LT(1), getFilename()); 2435 } 2436 } 2437 } 2438 superClassClause_AST = (AST)currentAST.root; 2439 returnAST = superClassClause_AST; 2440 } 2441 2442 public final void implementsClause() throws RecognitionException, TokenStreamException { 2443 2444 returnAST = null; 2445 ASTPair currentAST = new ASTPair(); 2446 AST implementsClause_AST = null; 2447 Token i = null; 2448 AST i_AST = null; 2449 2450 { 2451 switch ( LA(1)) { 2452 case LITERAL_implements: 2453 { 2454 i = LT(1); 2455 i_AST = astFactory.create(i); 2456 astFactory.makeASTRoot(currentAST, i_AST); 2457 match(LITERAL_implements); 2458 if ( inputState.guessing==0 ) { 2459 i_AST.setType(IMPLEMENTS_CLAUSE); 2460 } 2461 classOrInterfaceType(false); 2462 astFactory.addASTChild(currentAST, returnAST); 2463 { 2464 _loop137: 2465 do { 2466 if ((LA(1)==COMMA)) { 2467 AST tmp57_AST = null; 2468 tmp57_AST = astFactory.create(LT(1)); 2469 astFactory.addASTChild(currentAST, tmp57_AST); 2470 match(COMMA); 2471 classOrInterfaceType(false); 2472 astFactory.addASTChild(currentAST, returnAST); 2473 } 2474 else { 2475 break _loop137; 2476 } 2477 2478 } while (true); 2479 } 2480 break; 2481 } 2482 case LCURLY: 2483 { 2484 break; 2485 } 2486 default: 2487 { 2488 throw new NoViableAltException(LT(1), getFilename()); 2489 } 2490 } 2491 } 2492 implementsClause_AST = (AST)currentAST.root; 2493 returnAST = implementsClause_AST; 2494 } 2495 2496 public final void classBlock() throws RecognitionException, TokenStreamException { 2497 2498 returnAST = null; 2499 ASTPair currentAST = new ASTPair(); 2500 AST classBlock_AST = null; 2501 2502 AST tmp58_AST = null; 2503 tmp58_AST = astFactory.create(LT(1)); 2504 astFactory.addASTChild(currentAST, tmp58_AST); 2505 match(LCURLY); 2506 { 2507 _loop129: 2508 do { 2509 switch ( LA(1)) { 2510 case FINAL: 2511 case ABSTRACT: 2512 case STRICTFP: 2513 case LITERAL_void: 2514 case LITERAL_boolean: 2515 case LITERAL_byte: 2516 case LITERAL_char: 2517 case LITERAL_short: 2518 case LITERAL_int: 2519 case LITERAL_float: 2520 case LITERAL_long: 2521 case LITERAL_double: 2522 case IDENT: 2523 case LITERAL_private: 2524 case LITERAL_public: 2525 case LITERAL_protected: 2526 case LITERAL_static: 2527 case LITERAL_transient: 2528 case LITERAL_native: 2529 case LITERAL_synchronized: 2530 case LITERAL_volatile: 2531 case LITERAL_class: 2532 case LITERAL_interface: 2533 case LCURLY: 2534 case LITERAL_default: 2535 case LT: 2536 case ENUM: 2537 case AT: 2538 { 2539 field(); 2540 astFactory.addASTChild(currentAST, returnAST); 2541 break; 2542 } 2543 case SEMI: 2544 { 2545 AST tmp59_AST = null; 2546 tmp59_AST = astFactory.create(LT(1)); 2547 astFactory.addASTChild(currentAST, tmp59_AST); 2548 match(SEMI); 2549 break; 2550 } 2551 default: 2552 { 2553 break _loop129; 2554 } 2555 } 2556 } while (true); 2557 } 2558 AST tmp60_AST = null; 2559 tmp60_AST = astFactory.create(LT(1)); 2560 astFactory.addASTChild(currentAST, tmp60_AST); 2561 match(RCURLY); 2562 if ( inputState.guessing==0 ) { 2563 classBlock_AST = (AST)currentAST.root; 2564 classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST)); 2565 currentAST.root = classBlock_AST; 2566 currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ? 2567 classBlock_AST.getFirstChild() : classBlock_AST; 2568 currentAST.advanceChildToEnd(); 2569 } 2570 classBlock_AST = (AST)currentAST.root; 2571 returnAST = classBlock_AST; 2572 } 2573 2574 public final void interfaceExtends() throws RecognitionException, TokenStreamException { 2575 2576 returnAST = null; 2577 ASTPair currentAST = new ASTPair(); 2578 AST interfaceExtends_AST = null; 2579 Token e = null; 2580 AST e_AST = null; 2581 2582 { 2583 switch ( LA(1)) { 2584 case LITERAL_extends: 2585 { 2586 e = LT(1); 2587 e_AST = astFactory.create(e); 2588 astFactory.makeASTRoot(currentAST, e_AST); 2589 match(LITERAL_extends); 2590 if ( inputState.guessing==0 ) { 2591 e_AST.setType(EXTENDS_CLAUSE); 2592 } 2593 classOrInterfaceType(false); 2594 astFactory.addASTChild(currentAST, returnAST); 2595 { 2596 _loop133: 2597 do { 2598 if ((LA(1)==COMMA)) { 2599 AST tmp61_AST = null; 2600 tmp61_AST = astFactory.create(LT(1)); 2601 astFactory.addASTChild(currentAST, tmp61_AST); 2602 match(COMMA); 2603 classOrInterfaceType(false); 2604 astFactory.addASTChild(currentAST, returnAST); 2605 } 2606 else { 2607 break _loop133; 2608 } 2609 2610 } while (true); 2611 } 2612 break; 2613 } 2614 case LCURLY: 2615 { 2616 break; 2617 } 2618 default: 2619 { 2620 throw new NoViableAltException(LT(1), getFilename()); 2621 } 2622 } 2623 } 2624 interfaceExtends_AST = (AST)currentAST.root; 2625 returnAST = interfaceExtends_AST; 2626 } 2627 2628 public final void enumBlock() throws RecognitionException, TokenStreamException { 2629 2630 returnAST = null; 2631 ASTPair currentAST = new ASTPair(); 2632 AST enumBlock_AST = null; 2633 2634 AST tmp62_AST = null; 2635 tmp62_AST = astFactory.create(LT(1)); 2636 astFactory.addASTChild(currentAST, tmp62_AST); 2637 match(LCURLY); 2638 { 2639 switch ( LA(1)) { 2640 case IDENT: 2641 case AT: 2642 { 2643 enumConstant(); 2644 astFactory.addASTChild(currentAST, returnAST); 2645 { 2646 _loop110: 2647 do { 2648 if ((LA(1)==COMMA) && (LA(2)==IDENT||LA(2)==AT)) { 2649 AST tmp63_AST = null; 2650 tmp63_AST = astFactory.create(LT(1)); 2651 astFactory.addASTChild(currentAST, tmp63_AST); 2652 match(COMMA); 2653 enumConstant(); 2654 astFactory.addASTChild(currentAST, returnAST); 2655 } 2656 else { 2657 break _loop110; 2658 } 2659 2660 } while (true); 2661 } 2662 { 2663 switch ( LA(1)) { 2664 case COMMA: 2665 { 2666 AST tmp64_AST = null; 2667 tmp64_AST = astFactory.create(LT(1)); 2668 astFactory.addASTChild(currentAST, tmp64_AST); 2669 match(COMMA); 2670 break; 2671 } 2672 case SEMI: 2673 case RCURLY: 2674 { 2675 break; 2676 } 2677 default: 2678 { 2679 throw new NoViableAltException(LT(1), getFilename()); 2680 } 2681 } 2682 } 2683 break; 2684 } 2685 case SEMI: 2686 case RCURLY: 2687 { 2688 break; 2689 } 2690 default: 2691 { 2692 throw new NoViableAltException(LT(1), getFilename()); 2693 } 2694 } 2695 } 2696 { 2697 switch ( LA(1)) { 2698 case SEMI: 2699 { 2700 AST tmp65_AST = null; 2701 tmp65_AST = astFactory.create(LT(1)); 2702 astFactory.addASTChild(currentAST, tmp65_AST); 2703 match(SEMI); 2704 { 2705 _loop114: 2706 do { 2707 switch ( LA(1)) { 2708 case FINAL: 2709 case ABSTRACT: 2710 case STRICTFP: 2711 case LITERAL_void: 2712 case LITERAL_boolean: 2713 case LITERAL_byte: 2714 case LITERAL_char: 2715 case LITERAL_short: 2716 case LITERAL_int: 2717 case LITERAL_float: 2718 case LITERAL_long: 2719 case LITERAL_double: 2720 case IDENT: 2721 case LITERAL_private: 2722 case LITERAL_public: 2723 case LITERAL_protected: 2724 case LITERAL_static: 2725 case LITERAL_transient: 2726 case LITERAL_native: 2727 case LITERAL_synchronized: 2728 case LITERAL_volatile: 2729 case LITERAL_class: 2730 case LITERAL_interface: 2731 case LCURLY: 2732 case LITERAL_default: 2733 case LT: 2734 case ENUM: 2735 case AT: 2736 { 2737 field(); 2738 astFactory.addASTChild(currentAST, returnAST); 2739 break; 2740 } 2741 case SEMI: 2742 { 2743 AST tmp66_AST = null; 2744 tmp66_AST = astFactory.create(LT(1)); 2745 astFactory.addASTChild(currentAST, tmp66_AST); 2746 match(SEMI); 2747 break; 2748 } 2749 default: 2750 { 2751 break _loop114; 2752 } 2753 } 2754 } while (true); 2755 } 2756 break; 2757 } 2758 case RCURLY: 2759 { 2760 break; 2761 } 2762 default: 2763 { 2764 throw new NoViableAltException(LT(1), getFilename()); 2765 } 2766 } 2767 } 2768 AST tmp67_AST = null; 2769 tmp67_AST = astFactory.create(LT(1)); 2770 astFactory.addASTChild(currentAST, tmp67_AST); 2771 match(RCURLY); 2772 if ( inputState.guessing==0 ) { 2773 enumBlock_AST = (AST)currentAST.root; 2774 enumBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumBlock_AST)); 2775 currentAST.root = enumBlock_AST; 2776 currentAST.child = enumBlock_AST!=null &&enumBlock_AST.getFirstChild()!=null ? 2777 enumBlock_AST.getFirstChild() : enumBlock_AST; 2778 currentAST.advanceChildToEnd(); 2779 } 2780 enumBlock_AST = (AST)currentAST.root; 2781 returnAST = enumBlock_AST; 2782 } 2783 2784 public final void annotationBlock() throws RecognitionException, TokenStreamException { 2785 2786 returnAST = null; 2787 ASTPair currentAST = new ASTPair(); 2788 AST annotationBlock_AST = null; 2789 2790 AST tmp68_AST = null; 2791 tmp68_AST = astFactory.create(LT(1)); 2792 astFactory.addASTChild(currentAST, tmp68_AST); 2793 match(LCURLY); 2794 { 2795 _loop101: 2796 do { 2797 switch ( LA(1)) { 2798 case FINAL: 2799 case ABSTRACT: 2800 case STRICTFP: 2801 case LITERAL_void: 2802 case LITERAL_boolean: 2803 case LITERAL_byte: 2804 case LITERAL_char: 2805 case LITERAL_short: 2806 case LITERAL_int: 2807 case LITERAL_float: 2808 case LITERAL_long: 2809 case LITERAL_double: 2810 case IDENT: 2811 case LITERAL_private: 2812 case LITERAL_public: 2813 case LITERAL_protected: 2814 case LITERAL_static: 2815 case LITERAL_transient: 2816 case LITERAL_native: 2817 case LITERAL_synchronized: 2818 case LITERAL_volatile: 2819 case LITERAL_class: 2820 case LITERAL_interface: 2821 case LITERAL_default: 2822 case ENUM: 2823 case AT: 2824 { 2825 annotationField(); 2826 astFactory.addASTChild(currentAST, returnAST); 2827 break; 2828 } 2829 case SEMI: 2830 { 2831 AST tmp69_AST = null; 2832 tmp69_AST = astFactory.create(LT(1)); 2833 astFactory.addASTChild(currentAST, tmp69_AST); 2834 match(SEMI); 2835 break; 2836 } 2837 default: 2838 { 2839 break _loop101; 2840 } 2841 } 2842 } while (true); 2843 } 2844 AST tmp70_AST = null; 2845 tmp70_AST = astFactory.create(LT(1)); 2846 astFactory.addASTChild(currentAST, tmp70_AST); 2847 match(RCURLY); 2848 if ( inputState.guessing==0 ) { 2849 annotationBlock_AST = (AST)currentAST.root; 2850 annotationBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(annotationBlock_AST)); 2851 currentAST.root = annotationBlock_AST; 2852 currentAST.child = annotationBlock_AST!=null &&annotationBlock_AST.getFirstChild()!=null ? 2853 annotationBlock_AST.getFirstChild() : annotationBlock_AST; 2854 currentAST.advanceChildToEnd(); 2855 } 2856 annotationBlock_AST = (AST)currentAST.root; 2857 returnAST = annotationBlock_AST; 2858 } 2859 2860 public final void typeParameter() throws RecognitionException, TokenStreamException { 2861 2862 returnAST = null; 2863 ASTPair currentAST = new ASTPair(); 2864 AST typeParameter_AST = null; 2865 Token id = null; 2866 AST id_AST = null; 2867 2868 { 2869 id = LT(1); 2870 id_AST = astFactory.create(id); 2871 astFactory.addASTChild(currentAST, id_AST); 2872 match(IDENT); 2873 } 2874 { 2875 if ((LA(1)==LITERAL_extends) && (LA(2)==IDENT||LA(2)==AT)) { 2876 typeParameterBounds(); 2877 astFactory.addASTChild(currentAST, returnAST); 2878 } 2879 else if ((_tokenSet_19.member(LA(1))) && (_tokenSet_20.member(LA(2)))) { 2880 } 2881 else { 2882 throw new NoViableAltException(LT(1), getFilename()); 2883 } 2884 2885 } 2886 if ( inputState.guessing==0 ) { 2887 typeParameter_AST = (AST)currentAST.root; 2888 typeParameter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_PARAMETER,"TYPE_PARAMETER")).add(typeParameter_AST)); 2889 currentAST.root = typeParameter_AST; 2890 currentAST.child = typeParameter_AST!=null &&typeParameter_AST.getFirstChild()!=null ? 2891 typeParameter_AST.getFirstChild() : typeParameter_AST; 2892 currentAST.advanceChildToEnd(); 2893 } 2894 typeParameter_AST = (AST)currentAST.root; 2895 returnAST = typeParameter_AST; 2896 } 2897 2898 public final void typeParameterBounds() throws RecognitionException, TokenStreamException { 2899 2900 returnAST = null; 2901 ASTPair currentAST = new ASTPair(); 2902 AST typeParameterBounds_AST = null; 2903 Token e = null; 2904 AST e_AST = null; 2905 Token b = null; 2906 AST b_AST = null; 2907 2908 e = LT(1); 2909 e_AST = astFactory.create(e); 2910 astFactory.makeASTRoot(currentAST, e_AST); 2911 match(LITERAL_extends); 2912 classOrInterfaceType(true); 2913 astFactory.addASTChild(currentAST, returnAST); 2914 { 2915 _loop98: 2916 do { 2917 if ((LA(1)==BAND)) { 2918 b = LT(1); 2919 b_AST = astFactory.create(b); 2920 astFactory.addASTChild(currentAST, b_AST); 2921 match(BAND); 2922 if ( inputState.guessing==0 ) { 2923 b_AST.setType(TYPE_EXTENSION_AND); 2924 } 2925 classOrInterfaceType(true); 2926 astFactory.addASTChild(currentAST, returnAST); 2927 } 2928 else { 2929 break _loop98; 2930 } 2931 2932 } while (true); 2933 } 2934 if ( inputState.guessing==0 ) { 2935 e_AST.setType(TYPE_UPPER_BOUNDS); 2936 } 2937 typeParameterBounds_AST = (AST)currentAST.root; 2938 returnAST = typeParameterBounds_AST; 2939 } 2940 2941 public final void annotationField() throws RecognitionException, TokenStreamException { 2942 2943 returnAST = null; 2944 ASTPair currentAST = new ASTPair(); 2945 AST annotationField_AST = null; 2946 AST mods_AST = null; 2947 AST td_AST = null; 2948 AST t_AST = null; 2949 Token i = null; 2950 AST i_AST = null; 2951 AST rt_AST = null; 2952 AST d_AST = null; 2953 Token s = null; 2954 AST s_AST = null; 2955 AST v_AST = null; 2956 Token s6 = null; 2957 AST s6_AST = null; 2958 2959 modifiers(); 2960 mods_AST = (AST)returnAST; 2961 { 2962 if ((_tokenSet_21.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) { 2963 typeDefinitionInternal(mods_AST); 2964 td_AST = (AST)returnAST; 2965 if ( inputState.guessing==0 ) { 2966 annotationField_AST = (AST)currentAST.root; 2967 annotationField_AST = td_AST; 2968 currentAST.root = annotationField_AST; 2969 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? 2970 annotationField_AST.getFirstChild() : annotationField_AST; 2971 currentAST.advanceChildToEnd(); 2972 } 2973 } 2974 else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_22.member(LA(2)))) { 2975 typeSpec(false); 2976 t_AST = (AST)returnAST; 2977 { 2978 if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { 2979 i = LT(1); 2980 i_AST = astFactory.create(i); 2981 match(IDENT); 2982 AST tmp71_AST = null; 2983 tmp71_AST = astFactory.create(LT(1)); 2984 match(LPAREN); 2985 AST tmp72_AST = null; 2986 tmp72_AST = astFactory.create(LT(1)); 2987 match(RPAREN); 2988 declaratorBrackets(t_AST); 2989 rt_AST = (AST)returnAST; 2990 { 2991 switch ( LA(1)) { 2992 case LITERAL_default: 2993 { 2994 annotationDefault(); 2995 d_AST = (AST)returnAST; 2996 break; 2997 } 2998 case SEMI: 2999 { 3000 break; 3001 } 3002 default: 3003 { 3004 throw new NoViableAltException(LT(1), getFilename()); 3005 } 3006 } 3007 } 3008 s = LT(1); 3009 s_AST = astFactory.create(s); 3010 match(SEMI); 3011 if ( inputState.guessing==0 ) { 3012 annotationField_AST = (AST)currentAST.root; 3013 annotationField_AST = 3014 (AST)astFactory.make( (new ASTArray(8)).add(astFactory.create(ANNOTATION_FIELD_DEF,"ANNOTATION_FIELD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(i_AST).add(tmp71_AST).add(tmp72_AST).add(d_AST).add(s_AST)); 3015 currentAST.root = annotationField_AST; 3016 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? 3017 annotationField_AST.getFirstChild() : annotationField_AST; 3018 currentAST.advanceChildToEnd(); 3019 } 3020 } 3021 else if ((LA(1)==IDENT) && (_tokenSet_23.member(LA(2)))) { 3022 variableDefinitions(mods_AST,t_AST); 3023 v_AST = (AST)returnAST; 3024 s6 = LT(1); 3025 s6_AST = astFactory.create(s6); 3026 match(SEMI); 3027 if ( inputState.guessing==0 ) { 3028 annotationField_AST = (AST)currentAST.root; 3029 3030 annotationField_AST = v_AST; 3031 v_AST.addChild(s6_AST); 3032 3033 currentAST.root = annotationField_AST; 3034 currentAST.child = annotationField_AST!=null &&annotationField_AST.getFirstChild()!=null ? 3035 annotationField_AST.getFirstChild() : annotationField_AST; 3036 currentAST.advanceChildToEnd(); 3037 } 3038 } 3039 else { 3040 throw new NoViableAltException(LT(1), getFilename()); 3041 } 3042 3043 } 3044 } 3045 else { 3046 throw new NoViableAltException(LT(1), getFilename()); 3047 } 3048 3049 } 3050 returnAST = annotationField_AST; 3051 } 3052 3053 public final void declaratorBrackets( 3054 AST typ 3055 ) throws RecognitionException, TokenStreamException { 3056 3057 returnAST = null; 3058 ASTPair currentAST = new ASTPair(); 3059 AST declaratorBrackets_AST = null; 3060 Token lb = null; 3061 AST lb_AST = null; 3062 3063 if ( inputState.guessing==0 ) { 3064 declaratorBrackets_AST = (AST)currentAST.root; 3065 declaratorBrackets_AST=typ; 3066 currentAST.root = declaratorBrackets_AST; 3067 currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ? 3068 declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST; 3069 currentAST.advanceChildToEnd(); 3070 } 3071 { 3072 _loop163: 3073 do { 3074 if ((LA(1)==LBRACK)) { 3075 lb = LT(1); 3076 lb_AST = astFactory.create(lb); 3077 astFactory.makeASTRoot(currentAST, lb_AST); 3078 match(LBRACK); 3079 if ( inputState.guessing==0 ) { 3080 lb_AST.setType(ARRAY_DECLARATOR); 3081 } 3082 AST tmp73_AST = null; 3083 tmp73_AST = astFactory.create(LT(1)); 3084 astFactory.addASTChild(currentAST, tmp73_AST); 3085 match(RBRACK); 3086 } 3087 else { 3088 break _loop163; 3089 } 3090 3091 } while (true); 3092 } 3093 declaratorBrackets_AST = (AST)currentAST.root; 3094 returnAST = declaratorBrackets_AST; 3095 } 3096 3097 public final void annotationDefault() throws RecognitionException, TokenStreamException { 3098 3099 returnAST = null; 3100 ASTPair currentAST = new ASTPair(); 3101 AST annotationDefault_AST = null; 3102 3103 AST tmp74_AST = null; 3104 tmp74_AST = astFactory.create(LT(1)); 3105 astFactory.makeASTRoot(currentAST, tmp74_AST); 3106 match(LITERAL_default); 3107 annotationMemberValueInitializer(); 3108 astFactory.addASTChild(currentAST, returnAST); 3109 annotationDefault_AST = (AST)currentAST.root; 3110 returnAST = annotationDefault_AST; 3111 } 3112 3113 public final void enumConstant() throws RecognitionException, TokenStreamException { 3114 3115 returnAST = null; 3116 ASTPair currentAST = new ASTPair(); 3117 AST enumConstant_AST = null; 3118 AST an_AST = null; 3119 Token i = null; 3120 AST i_AST = null; 3121 Token l = null; 3122 AST l_AST = null; 3123 AST args_AST = null; 3124 Token r = null; 3125 AST r_AST = null; 3126 AST b_AST = null; 3127 3128 annotations(); 3129 an_AST = (AST)returnAST; 3130 i = LT(1); 3131 i_AST = astFactory.create(i); 3132 match(IDENT); 3133 { 3134 switch ( LA(1)) { 3135 case LPAREN: 3136 { 3137 l = LT(1); 3138 l_AST = astFactory.create(l); 3139 match(LPAREN); 3140 argList(); 3141 args_AST = (AST)returnAST; 3142 r = LT(1); 3143 r_AST = astFactory.create(r); 3144 match(RPAREN); 3145 break; 3146 } 3147 case SEMI: 3148 case LCURLY: 3149 case RCURLY: 3150 case COMMA: 3151 { 3152 break; 3153 } 3154 default: 3155 { 3156 throw new NoViableAltException(LT(1), getFilename()); 3157 } 3158 } 3159 } 3160 { 3161 switch ( LA(1)) { 3162 case LCURLY: 3163 { 3164 enumConstantBlock(); 3165 b_AST = (AST)returnAST; 3166 break; 3167 } 3168 case SEMI: 3169 case RCURLY: 3170 case COMMA: 3171 { 3172 break; 3173 } 3174 default: 3175 { 3176 throw new NoViableAltException(LT(1), getFilename()); 3177 } 3178 } 3179 } 3180 if ( inputState.guessing==0 ) { 3181 enumConstant_AST = (AST)currentAST.root; 3182 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)); 3183 currentAST.root = enumConstant_AST; 3184 currentAST.child = enumConstant_AST!=null &&enumConstant_AST.getFirstChild()!=null ? 3185 enumConstant_AST.getFirstChild() : enumConstant_AST; 3186 currentAST.advanceChildToEnd(); 3187 } 3188 returnAST = enumConstant_AST; 3189 } 3190 3191 public final void field() throws RecognitionException, TokenStreamException { 3192 3193 returnAST = null; 3194 ASTPair currentAST = new ASTPair(); 3195 AST field_AST = null; 3196 AST mods_AST = null; 3197 AST td_AST = null; 3198 AST tp_AST = null; 3199 AST h_AST = null; 3200 AST s_AST = null; 3201 AST t_AST = null; 3202 AST param_AST = null; 3203 AST rt_AST = null; 3204 AST tc_AST = null; 3205 AST s2_AST = null; 3206 Token s5 = null; 3207 AST s5_AST = null; 3208 AST v_AST = null; 3209 Token s6 = null; 3210 AST s6_AST = null; 3211 Token si = null; 3212 AST si_AST = null; 3213 AST s3_AST = null; 3214 AST s4_AST = null; 3215 3216 if ((_tokenSet_24.member(LA(1))) && (_tokenSet_25.member(LA(2)))) { 3217 modifiers(); 3218 mods_AST = (AST)returnAST; 3219 { 3220 if ((_tokenSet_21.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) { 3221 typeDefinitionInternal(mods_AST); 3222 td_AST = (AST)returnAST; 3223 if ( inputState.guessing==0 ) { 3224 field_AST = (AST)currentAST.root; 3225 field_AST = td_AST; 3226 currentAST.root = field_AST; 3227 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3228 field_AST.getFirstChild() : field_AST; 3229 currentAST.advanceChildToEnd(); 3230 } 3231 } 3232 else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) { 3233 { 3234 switch ( LA(1)) { 3235 case LT: 3236 { 3237 typeParameters(); 3238 tp_AST = (AST)returnAST; 3239 break; 3240 } 3241 case LITERAL_void: 3242 case LITERAL_boolean: 3243 case LITERAL_byte: 3244 case LITERAL_char: 3245 case LITERAL_short: 3246 case LITERAL_int: 3247 case LITERAL_float: 3248 case LITERAL_long: 3249 case LITERAL_double: 3250 case IDENT: 3251 case AT: 3252 { 3253 break; 3254 } 3255 default: 3256 { 3257 throw new NoViableAltException(LT(1), getFilename()); 3258 } 3259 } 3260 } 3261 { 3262 if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { 3263 ctorHead(); 3264 h_AST = (AST)returnAST; 3265 constructorBody(); 3266 s_AST = (AST)returnAST; 3267 if ( inputState.guessing==0 ) { 3268 field_AST = (AST)currentAST.root; 3269 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)); 3270 currentAST.root = field_AST; 3271 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3272 field_AST.getFirstChild() : field_AST; 3273 currentAST.advanceChildToEnd(); 3274 } 3275 } 3276 else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_22.member(LA(2)))) { 3277 typeSpec(false); 3278 t_AST = (AST)returnAST; 3279 { 3280 if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { 3281 AST tmp75_AST = null; 3282 tmp75_AST = astFactory.create(LT(1)); 3283 match(IDENT); 3284 AST tmp76_AST = null; 3285 tmp76_AST = astFactory.create(LT(1)); 3286 match(LPAREN); 3287 parameterDeclarationList(); 3288 param_AST = (AST)returnAST; 3289 AST tmp77_AST = null; 3290 tmp77_AST = astFactory.create(LT(1)); 3291 match(RPAREN); 3292 declaratorBrackets(t_AST); 3293 rt_AST = (AST)returnAST; 3294 { 3295 switch ( LA(1)) { 3296 case LITERAL_throws: 3297 { 3298 throwsClause(); 3299 tc_AST = (AST)returnAST; 3300 break; 3301 } 3302 case SEMI: 3303 case LCURLY: 3304 { 3305 break; 3306 } 3307 default: 3308 { 3309 throw new NoViableAltException(LT(1), getFilename()); 3310 } 3311 } 3312 } 3313 { 3314 switch ( LA(1)) { 3315 case LCURLY: 3316 { 3317 compoundStatement(); 3318 s2_AST = (AST)returnAST; 3319 break; 3320 } 3321 case SEMI: 3322 { 3323 s5 = LT(1); 3324 s5_AST = astFactory.create(s5); 3325 match(SEMI); 3326 break; 3327 } 3328 default: 3329 { 3330 throw new NoViableAltException(LT(1), getFilename()); 3331 } 3332 } 3333 } 3334 if ( inputState.guessing==0 ) { 3335 field_AST = (AST)currentAST.root; 3336 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(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp75_AST).add(tmp76_AST).add(param_AST).add(tmp77_AST).add(tc_AST).add(s2_AST).add(s5_AST)); 3337 currentAST.root = field_AST; 3338 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3339 field_AST.getFirstChild() : field_AST; 3340 currentAST.advanceChildToEnd(); 3341 } 3342 } 3343 else if ((LA(1)==IDENT) && (_tokenSet_28.member(LA(2)))) { 3344 variableDefinitions(mods_AST,t_AST); 3345 v_AST = (AST)returnAST; 3346 { 3347 if ((LA(1)==SEMI) && (_tokenSet_29.member(LA(2)))) { 3348 s6 = LT(1); 3349 s6_AST = astFactory.create(s6); 3350 match(SEMI); 3351 } 3352 else if ((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2)))) { 3353 } 3354 else { 3355 throw new NoViableAltException(LT(1), getFilename()); 3356 } 3357 3358 } 3359 if ( inputState.guessing==0 ) { 3360 field_AST = (AST)currentAST.root; 3361 3362 field_AST = v_AST; 3363 v_AST.addChild(s6_AST); 3364 3365 currentAST.root = field_AST; 3366 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3367 field_AST.getFirstChild() : field_AST; 3368 currentAST.advanceChildToEnd(); 3369 } 3370 } 3371 else { 3372 throw new NoViableAltException(LT(1), getFilename()); 3373 } 3374 3375 } 3376 } 3377 else { 3378 throw new NoViableAltException(LT(1), getFilename()); 3379 } 3380 3381 } 3382 } 3383 else { 3384 throw new NoViableAltException(LT(1), getFilename()); 3385 } 3386 3387 } 3388 } 3389 else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) { 3390 si = LT(1); 3391 si_AST = astFactory.create(si); 3392 match(LITERAL_static); 3393 compoundStatement(); 3394 s3_AST = (AST)returnAST; 3395 if ( inputState.guessing==0 ) { 3396 field_AST = (AST)currentAST.root; 3397 si_AST.setType(STATIC_INIT); 3398 si_AST.setText("STATIC_INIT"); 3399 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(si_AST).add(s3_AST)); 3400 currentAST.root = field_AST; 3401 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3402 field_AST.getFirstChild() : field_AST; 3403 currentAST.advanceChildToEnd(); 3404 } 3405 } 3406 else if ((LA(1)==LCURLY)) { 3407 compoundStatement(); 3408 s4_AST = (AST)returnAST; 3409 if ( inputState.guessing==0 ) { 3410 field_AST = (AST)currentAST.root; 3411 field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST)); 3412 currentAST.root = field_AST; 3413 currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ? 3414 field_AST.getFirstChild() : field_AST; 3415 currentAST.advanceChildToEnd(); 3416 } 3417 } 3418 else { 3419 throw new NoViableAltException(LT(1), getFilename()); 3420 } 3421 3422 returnAST = field_AST; 3423 } 3424 3425 public final void argList() throws RecognitionException, TokenStreamException { 3426 3427 returnAST = null; 3428 ASTPair currentAST = new ASTPair(); 3429 AST argList_AST = null; 3430 3431 { 3432 if (((_tokenSet_16.member(LA(1))))&&(LA(1)!=RPAREN)) { 3433 expressionList(); 3434 astFactory.addASTChild(currentAST, returnAST); 3435 } 3436 else if ((LA(1)==RPAREN)) { 3437 if ( inputState.guessing==0 ) { 3438 argList_AST = (AST)currentAST.root; 3439 argList_AST = astFactory.create(ELIST,"ELIST"); 3440 currentAST.root = argList_AST; 3441 currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ? 3442 argList_AST.getFirstChild() : argList_AST; 3443 currentAST.advanceChildToEnd(); 3444 } 3445 } 3446 else { 3447 throw new NoViableAltException(LT(1), getFilename()); 3448 } 3449 3450 } 3451 argList_AST = (AST)currentAST.root; 3452 returnAST = argList_AST; 3453 } 3454 3455 public final void enumConstantBlock() throws RecognitionException, TokenStreamException { 3456 3457 returnAST = null; 3458 ASTPair currentAST = new ASTPair(); 3459 AST enumConstantBlock_AST = null; 3460 3461 AST tmp78_AST = null; 3462 tmp78_AST = astFactory.create(LT(1)); 3463 astFactory.addASTChild(currentAST, tmp78_AST); 3464 match(LCURLY); 3465 { 3466 _loop120: 3467 do { 3468 switch ( LA(1)) { 3469 case FINAL: 3470 case ABSTRACT: 3471 case STRICTFP: 3472 case LITERAL_void: 3473 case LITERAL_boolean: 3474 case LITERAL_byte: 3475 case LITERAL_char: 3476 case LITERAL_short: 3477 case LITERAL_int: 3478 case LITERAL_float: 3479 case LITERAL_long: 3480 case LITERAL_double: 3481 case IDENT: 3482 case LITERAL_private: 3483 case LITERAL_public: 3484 case LITERAL_protected: 3485 case LITERAL_static: 3486 case LITERAL_transient: 3487 case LITERAL_native: 3488 case LITERAL_synchronized: 3489 case LITERAL_volatile: 3490 case LITERAL_class: 3491 case LITERAL_interface: 3492 case LCURLY: 3493 case LITERAL_default: 3494 case LT: 3495 case ENUM: 3496 case AT: 3497 { 3498 enumConstantField(); 3499 astFactory.addASTChild(currentAST, returnAST); 3500 break; 3501 } 3502 case SEMI: 3503 { 3504 AST tmp79_AST = null; 3505 tmp79_AST = astFactory.create(LT(1)); 3506 astFactory.addASTChild(currentAST, tmp79_AST); 3507 match(SEMI); 3508 break; 3509 } 3510 default: 3511 { 3512 break _loop120; 3513 } 3514 } 3515 } while (true); 3516 } 3517 AST tmp80_AST = null; 3518 tmp80_AST = astFactory.create(LT(1)); 3519 astFactory.addASTChild(currentAST, tmp80_AST); 3520 match(RCURLY); 3521 if ( inputState.guessing==0 ) { 3522 enumConstantBlock_AST = (AST)currentAST.root; 3523 enumConstantBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(enumConstantBlock_AST)); 3524 currentAST.root = enumConstantBlock_AST; 3525 currentAST.child = enumConstantBlock_AST!=null &&enumConstantBlock_AST.getFirstChild()!=null ? 3526 enumConstantBlock_AST.getFirstChild() : enumConstantBlock_AST; 3527 currentAST.advanceChildToEnd(); 3528 } 3529 enumConstantBlock_AST = (AST)currentAST.root; 3530 returnAST = enumConstantBlock_AST; 3531 } 3532 3533 public final void enumConstantField() throws RecognitionException, TokenStreamException { 3534 3535 returnAST = null; 3536 ASTPair currentAST = new ASTPair(); 3537 AST enumConstantField_AST = null; 3538 AST mods_AST = null; 3539 AST td_AST = null; 3540 AST tp_AST = null; 3541 AST t_AST = null; 3542 AST param_AST = null; 3543 AST rt_AST = null; 3544 AST tc_AST = null; 3545 AST s2_AST = null; 3546 Token s3 = null; 3547 AST s3_AST = null; 3548 AST v_AST = null; 3549 Token s6 = null; 3550 AST s6_AST = null; 3551 AST s4_AST = null; 3552 3553 switch ( LA(1)) { 3554 case FINAL: 3555 case ABSTRACT: 3556 case STRICTFP: 3557 case LITERAL_void: 3558 case LITERAL_boolean: 3559 case LITERAL_byte: 3560 case LITERAL_char: 3561 case LITERAL_short: 3562 case LITERAL_int: 3563 case LITERAL_float: 3564 case LITERAL_long: 3565 case LITERAL_double: 3566 case IDENT: 3567 case LITERAL_private: 3568 case LITERAL_public: 3569 case LITERAL_protected: 3570 case LITERAL_static: 3571 case LITERAL_transient: 3572 case LITERAL_native: 3573 case LITERAL_synchronized: 3574 case LITERAL_volatile: 3575 case LITERAL_class: 3576 case LITERAL_interface: 3577 case LITERAL_default: 3578 case LT: 3579 case ENUM: 3580 case AT: 3581 { 3582 modifiers(); 3583 mods_AST = (AST)returnAST; 3584 { 3585 if ((_tokenSet_21.member(LA(1))) && (LA(2)==IDENT||LA(2)==LITERAL_interface)) { 3586 typeDefinitionInternal(mods_AST); 3587 td_AST = (AST)returnAST; 3588 if ( inputState.guessing==0 ) { 3589 enumConstantField_AST = (AST)currentAST.root; 3590 enumConstantField_AST = td_AST; 3591 currentAST.root = enumConstantField_AST; 3592 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 3593 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 3594 currentAST.advanceChildToEnd(); 3595 } 3596 } 3597 else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_22.member(LA(2)))) { 3598 { 3599 switch ( LA(1)) { 3600 case LT: 3601 { 3602 typeParameters(); 3603 tp_AST = (AST)returnAST; 3604 break; 3605 } 3606 case LITERAL_void: 3607 case LITERAL_boolean: 3608 case LITERAL_byte: 3609 case LITERAL_char: 3610 case LITERAL_short: 3611 case LITERAL_int: 3612 case LITERAL_float: 3613 case LITERAL_long: 3614 case LITERAL_double: 3615 case IDENT: 3616 case AT: 3617 { 3618 break; 3619 } 3620 default: 3621 { 3622 throw new NoViableAltException(LT(1), getFilename()); 3623 } 3624 } 3625 } 3626 typeSpec(false); 3627 t_AST = (AST)returnAST; 3628 { 3629 if ((LA(1)==IDENT) && (LA(2)==LPAREN)) { 3630 AST tmp81_AST = null; 3631 tmp81_AST = astFactory.create(LT(1)); 3632 match(IDENT); 3633 AST tmp82_AST = null; 3634 tmp82_AST = astFactory.create(LT(1)); 3635 match(LPAREN); 3636 parameterDeclarationList(); 3637 param_AST = (AST)returnAST; 3638 AST tmp83_AST = null; 3639 tmp83_AST = astFactory.create(LT(1)); 3640 match(RPAREN); 3641 declaratorBrackets(t_AST); 3642 rt_AST = (AST)returnAST; 3643 { 3644 switch ( LA(1)) { 3645 case LITERAL_throws: 3646 { 3647 throwsClause(); 3648 tc_AST = (AST)returnAST; 3649 break; 3650 } 3651 case SEMI: 3652 case LCURLY: 3653 { 3654 break; 3655 } 3656 default: 3657 { 3658 throw new NoViableAltException(LT(1), getFilename()); 3659 } 3660 } 3661 } 3662 { 3663 switch ( LA(1)) { 3664 case LCURLY: 3665 { 3666 compoundStatement(); 3667 s2_AST = (AST)returnAST; 3668 break; 3669 } 3670 case SEMI: 3671 { 3672 s3 = LT(1); 3673 s3_AST = astFactory.create(s3); 3674 match(SEMI); 3675 break; 3676 } 3677 default: 3678 { 3679 throw new NoViableAltException(LT(1), getFilename()); 3680 } 3681 } 3682 } 3683 if ( inputState.guessing==0 ) { 3684 enumConstantField_AST = (AST)currentAST.root; 3685 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(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp81_AST).add(tmp82_AST).add(param_AST).add(tmp83_AST).add(tc_AST).add(s2_AST).add(s3_AST)); 3686 currentAST.root = enumConstantField_AST; 3687 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 3688 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 3689 currentAST.advanceChildToEnd(); 3690 } 3691 } 3692 else if ((LA(1)==IDENT) && (_tokenSet_23.member(LA(2)))) { 3693 variableDefinitions(mods_AST,t_AST); 3694 v_AST = (AST)returnAST; 3695 s6 = LT(1); 3696 s6_AST = astFactory.create(s6); 3697 match(SEMI); 3698 if ( inputState.guessing==0 ) { 3699 enumConstantField_AST = (AST)currentAST.root; 3700 3701 enumConstantField_AST = v_AST; 3702 v_AST.addChild(s6_AST); 3703 3704 currentAST.root = enumConstantField_AST; 3705 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 3706 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 3707 currentAST.advanceChildToEnd(); 3708 } 3709 } 3710 else { 3711 throw new NoViableAltException(LT(1), getFilename()); 3712 } 3713 3714 } 3715 } 3716 else { 3717 throw new NoViableAltException(LT(1), getFilename()); 3718 } 3719 3720 } 3721 break; 3722 } 3723 case LCURLY: 3724 { 3725 compoundStatement(); 3726 s4_AST = (AST)returnAST; 3727 if ( inputState.guessing==0 ) { 3728 enumConstantField_AST = (AST)currentAST.root; 3729 enumConstantField_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST)); 3730 currentAST.root = enumConstantField_AST; 3731 currentAST.child = enumConstantField_AST!=null &&enumConstantField_AST.getFirstChild()!=null ? 3732 enumConstantField_AST.getFirstChild() : enumConstantField_AST; 3733 currentAST.advanceChildToEnd(); 3734 } 3735 break; 3736 } 3737 default: 3738 { 3739 throw new NoViableAltException(LT(1), getFilename()); 3740 } 3741 } 3742 returnAST = enumConstantField_AST; 3743 } 3744 3745 public final void parameterDeclarationList() throws RecognitionException, TokenStreamException { 3746 3747 returnAST = null; 3748 ASTPair currentAST = new ASTPair(); 3749 AST parameterDeclarationList_AST = null; 3750 3751 { 3752 boolean synPredMatched181 = false; 3753 if (((_tokenSet_31.member(LA(1))) && (_tokenSet_32.member(LA(2))))) { 3754 int _m181 = mark(); 3755 synPredMatched181 = true; 3756 inputState.guessing++; 3757 try { 3758 { 3759 parameterDeclaration(); 3760 } 3761 } 3762 catch (RecognitionException pe) { 3763 synPredMatched181 = false; 3764 } 3765 rewind(_m181); 3766inputState.guessing--; 3767 } 3768 if ( synPredMatched181 ) { 3769 parameterDeclaration(); 3770 astFactory.addASTChild(currentAST, returnAST); 3771 { 3772 _loop185: 3773 do { 3774 boolean synPredMatched184 = false; 3775 if (((LA(1)==COMMA) && (_tokenSet_31.member(LA(2))))) { 3776 int _m184 = mark(); 3777 synPredMatched184 = true; 3778 inputState.guessing++; 3779 try { 3780 { 3781 match(COMMA); 3782 parameterDeclaration(); 3783 } 3784 } 3785 catch (RecognitionException pe) { 3786 synPredMatched184 = false; 3787 } 3788 rewind(_m184); 3789inputState.guessing--; 3790 } 3791 if ( synPredMatched184 ) { 3792 AST tmp84_AST = null; 3793 tmp84_AST = astFactory.create(LT(1)); 3794 astFactory.addASTChild(currentAST, tmp84_AST); 3795 match(COMMA); 3796 parameterDeclaration(); 3797 astFactory.addASTChild(currentAST, returnAST); 3798 } 3799 else { 3800 break _loop185; 3801 } 3802 3803 } while (true); 3804 } 3805 { 3806 switch ( LA(1)) { 3807 case COMMA: 3808 { 3809 AST tmp85_AST = null; 3810 tmp85_AST = astFactory.create(LT(1)); 3811 astFactory.addASTChild(currentAST, tmp85_AST); 3812 match(COMMA); 3813 variableLengthParameterDeclaration(); 3814 astFactory.addASTChild(currentAST, returnAST); 3815 break; 3816 } 3817 case RPAREN: 3818 { 3819 break; 3820 } 3821 default: 3822 { 3823 throw new NoViableAltException(LT(1), getFilename()); 3824 } 3825 } 3826 } 3827 } 3828 else if ((_tokenSet_31.member(LA(1))) && (_tokenSet_33.member(LA(2)))) { 3829 variableLengthParameterDeclaration(); 3830 astFactory.addASTChild(currentAST, returnAST); 3831 } 3832 else if ((LA(1)==RPAREN)) { 3833 } 3834 else { 3835 throw new NoViableAltException(LT(1), getFilename()); 3836 } 3837 3838 } 3839 if ( inputState.guessing==0 ) { 3840 parameterDeclarationList_AST = (AST)currentAST.root; 3841 parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST)); 3842 currentAST.root = parameterDeclarationList_AST; 3843 currentAST.child = parameterDeclarationList_AST!=null &¶meterDeclarationList_AST.getFirstChild()!=null ? 3844 parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST; 3845 currentAST.advanceChildToEnd(); 3846 } 3847 parameterDeclarationList_AST = (AST)currentAST.root; 3848 returnAST = parameterDeclarationList_AST; 3849 } 3850 3851 public final void throwsClause() throws RecognitionException, TokenStreamException { 3852 3853 returnAST = null; 3854 ASTPair currentAST = new ASTPair(); 3855 AST throwsClause_AST = null; 3856 3857 AST tmp86_AST = null; 3858 tmp86_AST = astFactory.create(LT(1)); 3859 astFactory.makeASTRoot(currentAST, tmp86_AST); 3860 match(LITERAL_throws); 3861 { 3862 if (((LA(1)==IDENT||LA(1)==AT) && (_tokenSet_34.member(LA(2))))&&(LA(1) == AT)) { 3863 annotations(); 3864 astFactory.addASTChild(currentAST, returnAST); 3865 } 3866 else if ((LA(1)==IDENT) && (_tokenSet_35.member(LA(2)))) { 3867 } 3868 else { 3869 throw new NoViableAltException(LT(1), getFilename()); 3870 } 3871 3872 } 3873 identifier(); 3874 astFactory.addASTChild(currentAST, returnAST); 3875 { 3876 _loop177: 3877 do { 3878 if ((LA(1)==COMMA)) { 3879 AST tmp87_AST = null; 3880 tmp87_AST = astFactory.create(LT(1)); 3881 astFactory.addASTChild(currentAST, tmp87_AST); 3882 match(COMMA); 3883 identifier(); 3884 astFactory.addASTChild(currentAST, returnAST); 3885 } 3886 else { 3887 break _loop177; 3888 } 3889 3890 } while (true); 3891 } 3892 throwsClause_AST = (AST)currentAST.root; 3893 returnAST = throwsClause_AST; 3894 } 3895 3896 public final void compoundStatement() throws RecognitionException, TokenStreamException { 3897 3898 returnAST = null; 3899 ASTPair currentAST = new ASTPair(); 3900 AST compoundStatement_AST = null; 3901 Token lc = null; 3902 AST lc_AST = null; 3903 3904 lc = LT(1); 3905 lc_AST = astFactory.create(lc); 3906 astFactory.makeASTRoot(currentAST, lc_AST); 3907 match(LCURLY); 3908 if ( inputState.guessing==0 ) { 3909 lc_AST.setType(SLIST); 3910 } 3911 { 3912 _loop202: 3913 do { 3914 if ((_tokenSet_36.member(LA(1)))) { 3915 statement(); 3916 astFactory.addASTChild(currentAST, returnAST); 3917 } 3918 else { 3919 break _loop202; 3920 } 3921 3922 } while (true); 3923 } 3924 AST tmp88_AST = null; 3925 tmp88_AST = astFactory.create(LT(1)); 3926 astFactory.addASTChild(currentAST, tmp88_AST); 3927 match(RCURLY); 3928 compoundStatement_AST = (AST)currentAST.root; 3929 returnAST = compoundStatement_AST; 3930 } 3931 3932 public final void ctorHead() throws RecognitionException, TokenStreamException { 3933 3934 returnAST = null; 3935 ASTPair currentAST = new ASTPair(); 3936 AST ctorHead_AST = null; 3937 3938 AST tmp89_AST = null; 3939 tmp89_AST = astFactory.create(LT(1)); 3940 astFactory.addASTChild(currentAST, tmp89_AST); 3941 match(IDENT); 3942 AST tmp90_AST = null; 3943 tmp90_AST = astFactory.create(LT(1)); 3944 astFactory.addASTChild(currentAST, tmp90_AST); 3945 match(LPAREN); 3946 parameterDeclarationList(); 3947 astFactory.addASTChild(currentAST, returnAST); 3948 AST tmp91_AST = null; 3949 tmp91_AST = astFactory.create(LT(1)); 3950 astFactory.addASTChild(currentAST, tmp91_AST); 3951 match(RPAREN); 3952 { 3953 switch ( LA(1)) { 3954 case LITERAL_throws: 3955 { 3956 throwsClause(); 3957 astFactory.addASTChild(currentAST, returnAST); 3958 break; 3959 } 3960 case LCURLY: 3961 { 3962 break; 3963 } 3964 default: 3965 { 3966 throw new NoViableAltException(LT(1), getFilename()); 3967 } 3968 } 3969 } 3970 ctorHead_AST = (AST)currentAST.root; 3971 returnAST = ctorHead_AST; 3972 } 3973 3974 public final void constructorBody() throws RecognitionException, TokenStreamException { 3975 3976 returnAST = null; 3977 ASTPair currentAST = new ASTPair(); 3978 AST constructorBody_AST = null; 3979 Token lc = null; 3980 AST lc_AST = null; 3981 3982 lc = LT(1); 3983 lc_AST = astFactory.create(lc); 3984 astFactory.makeASTRoot(currentAST, lc_AST); 3985 match(LCURLY); 3986 if ( inputState.guessing==0 ) { 3987 lc_AST.setType(SLIST); 3988 } 3989 { 3990 boolean synPredMatched149 = false; 3991 if (((_tokenSet_37.member(LA(1))) && (_tokenSet_38.member(LA(2))))) { 3992 int _m149 = mark(); 3993 synPredMatched149 = true; 3994 inputState.guessing++; 3995 try { 3996 { 3997 explicitConstructorInvocation(); 3998 } 3999 } 4000 catch (RecognitionException pe) { 4001 synPredMatched149 = false; 4002 } 4003 rewind(_m149); 4004inputState.guessing--; 4005 } 4006 if ( synPredMatched149 ) { 4007 explicitConstructorInvocation(); 4008 astFactory.addASTChild(currentAST, returnAST); 4009 } 4010 else if ((_tokenSet_39.member(LA(1))) && (_tokenSet_40.member(LA(2)))) { 4011 } 4012 else { 4013 throw new NoViableAltException(LT(1), getFilename()); 4014 } 4015 4016 } 4017 { 4018 _loop151: 4019 do { 4020 if ((_tokenSet_36.member(LA(1)))) { 4021 statement(); 4022 astFactory.addASTChild(currentAST, returnAST); 4023 } 4024 else { 4025 break _loop151; 4026 } 4027 4028 } while (true); 4029 } 4030 AST tmp92_AST = null; 4031 tmp92_AST = astFactory.create(LT(1)); 4032 astFactory.addASTChild(currentAST, tmp92_AST); 4033 match(RCURLY); 4034 constructorBody_AST = (AST)currentAST.root; 4035 returnAST = constructorBody_AST; 4036 } 4037 4038 public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException { 4039 4040 returnAST = null; 4041 ASTPair currentAST = new ASTPair(); 4042 AST explicitConstructorInvocation_AST = null; 4043 Token t = null; 4044 AST t_AST = null; 4045 Token s = null; 4046 AST s_AST = null; 4047 Token s1 = null; 4048 AST s1_AST = null; 4049 4050 { 4051 if ((_tokenSet_41.member(LA(1))) && (_tokenSet_42.member(LA(2)))) { 4052 { 4053 switch ( LA(1)) { 4054 case LT: 4055 { 4056 typeArguments(false); 4057 astFactory.addASTChild(currentAST, returnAST); 4058 break; 4059 } 4060 case LITERAL_this: 4061 case LITERAL_super: 4062 { 4063 break; 4064 } 4065 default: 4066 { 4067 throw new NoViableAltException(LT(1), getFilename()); 4068 } 4069 } 4070 } 4071 { 4072 switch ( LA(1)) { 4073 case LITERAL_this: 4074 { 4075 t = LT(1); 4076 t_AST = astFactory.create(t); 4077 astFactory.makeASTRoot(currentAST, t_AST); 4078 match(LITERAL_this); 4079 AST tmp93_AST = null; 4080 tmp93_AST = astFactory.create(LT(1)); 4081 astFactory.addASTChild(currentAST, tmp93_AST); 4082 match(LPAREN); 4083 argList(); 4084 astFactory.addASTChild(currentAST, returnAST); 4085 AST tmp94_AST = null; 4086 tmp94_AST = astFactory.create(LT(1)); 4087 astFactory.addASTChild(currentAST, tmp94_AST); 4088 match(RPAREN); 4089 AST tmp95_AST = null; 4090 tmp95_AST = astFactory.create(LT(1)); 4091 astFactory.addASTChild(currentAST, tmp95_AST); 4092 match(SEMI); 4093 if ( inputState.guessing==0 ) { 4094 t_AST.setType(CTOR_CALL); 4095 } 4096 break; 4097 } 4098 case LITERAL_super: 4099 { 4100 s = LT(1); 4101 s_AST = astFactory.create(s); 4102 astFactory.makeASTRoot(currentAST, s_AST); 4103 match(LITERAL_super); 4104 AST tmp96_AST = null; 4105 tmp96_AST = astFactory.create(LT(1)); 4106 astFactory.addASTChild(currentAST, tmp96_AST); 4107 match(LPAREN); 4108 argList(); 4109 astFactory.addASTChild(currentAST, returnAST); 4110 AST tmp97_AST = null; 4111 tmp97_AST = astFactory.create(LT(1)); 4112 astFactory.addASTChild(currentAST, tmp97_AST); 4113 match(RPAREN); 4114 AST tmp98_AST = null; 4115 tmp98_AST = astFactory.create(LT(1)); 4116 astFactory.addASTChild(currentAST, tmp98_AST); 4117 match(SEMI); 4118 if ( inputState.guessing==0 ) { 4119 s_AST.setType(SUPER_CTOR_CALL); 4120 } 4121 break; 4122 } 4123 default: 4124 { 4125 throw new NoViableAltException(LT(1), getFilename()); 4126 } 4127 } 4128 } 4129 } 4130 else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_44.member(LA(2)))) { 4131 primaryExpression(); 4132 astFactory.addASTChild(currentAST, returnAST); 4133 AST tmp99_AST = null; 4134 tmp99_AST = astFactory.create(LT(1)); 4135 astFactory.addASTChild(currentAST, tmp99_AST); 4136 match(DOT); 4137 { 4138 switch ( LA(1)) { 4139 case LT: 4140 { 4141 typeArguments(false); 4142 astFactory.addASTChild(currentAST, returnAST); 4143 break; 4144 } 4145 case LITERAL_super: 4146 { 4147 break; 4148 } 4149 default: 4150 { 4151 throw new NoViableAltException(LT(1), getFilename()); 4152 } 4153 } 4154 } 4155 s1 = LT(1); 4156 s1_AST = astFactory.create(s1); 4157 astFactory.makeASTRoot(currentAST, s1_AST); 4158 match(LITERAL_super); 4159 AST tmp100_AST = null; 4160 tmp100_AST = astFactory.create(LT(1)); 4161 astFactory.addASTChild(currentAST, tmp100_AST); 4162 match(LPAREN); 4163 argList(); 4164 astFactory.addASTChild(currentAST, returnAST); 4165 AST tmp101_AST = null; 4166 tmp101_AST = astFactory.create(LT(1)); 4167 astFactory.addASTChild(currentAST, tmp101_AST); 4168 match(RPAREN); 4169 AST tmp102_AST = null; 4170 tmp102_AST = astFactory.create(LT(1)); 4171 astFactory.addASTChild(currentAST, tmp102_AST); 4172 match(SEMI); 4173 if ( inputState.guessing==0 ) { 4174 s1_AST.setType(SUPER_CTOR_CALL); 4175 } 4176 } 4177 else { 4178 throw new NoViableAltException(LT(1), getFilename()); 4179 } 4180 4181 } 4182 explicitConstructorInvocation_AST = (AST)currentAST.root; 4183 returnAST = explicitConstructorInvocation_AST; 4184 } 4185 4186 public final void statement() throws RecognitionException, TokenStreamException { 4187 4188 returnAST = null; 4189 ASTPair currentAST = new ASTPair(); 4190 AST statement_AST = null; 4191 4192 switch ( LA(1)) { 4193 case FINAL: 4194 case ABSTRACT: 4195 case STRICTFP: 4196 case SEMI: 4197 case LITERAL_void: 4198 case LITERAL_boolean: 4199 case LITERAL_byte: 4200 case LITERAL_char: 4201 case LITERAL_short: 4202 case LITERAL_int: 4203 case LITERAL_float: 4204 case LITERAL_long: 4205 case LITERAL_double: 4206 case IDENT: 4207 case LITERAL_private: 4208 case LITERAL_public: 4209 case LITERAL_protected: 4210 case LITERAL_static: 4211 case LITERAL_transient: 4212 case LITERAL_native: 4213 case LITERAL_synchronized: 4214 case LITERAL_volatile: 4215 case LITERAL_class: 4216 case LCURLY: 4217 case LPAREN: 4218 case LITERAL_this: 4219 case LITERAL_super: 4220 case LITERAL_if: 4221 case LITERAL_while: 4222 case LITERAL_do: 4223 case LITERAL_break: 4224 case LITERAL_continue: 4225 case LITERAL_return: 4226 case LITERAL_switch: 4227 case LITERAL_throw: 4228 case LITERAL_for: 4229 case LITERAL_default: 4230 case LITERAL_try: 4231 case PLUS: 4232 case MINUS: 4233 case INC: 4234 case DEC: 4235 case BNOT: 4236 case LNOT: 4237 case LITERAL_true: 4238 case LITERAL_false: 4239 case LITERAL_null: 4240 case LITERAL_new: 4241 case NUM_INT: 4242 case CHAR_LITERAL: 4243 case STRING_LITERAL: 4244 case NUM_FLOAT: 4245 case NUM_LONG: 4246 case NUM_DOUBLE: 4247 case AT: 4248 { 4249 traditionalStatement(); 4250 astFactory.addASTChild(currentAST, returnAST); 4251 statement_AST = (AST)currentAST.root; 4252 break; 4253 } 4254 case ASSERT: 4255 { 4256 assertStatement(); 4257 astFactory.addASTChild(currentAST, returnAST); 4258 statement_AST = (AST)currentAST.root; 4259 break; 4260 } 4261 default: 4262 { 4263 throw new NoViableAltException(LT(1), getFilename()); 4264 } 4265 } 4266 returnAST = statement_AST; 4267 } 4268 4269 public final void primaryExpression() throws RecognitionException, TokenStreamException { 4270 4271 returnAST = null; 4272 ASTPair currentAST = new ASTPair(); 4273 AST primaryExpression_AST = null; 4274 Token lbt = null; 4275 AST lbt_AST = null; 4276 4277 switch ( LA(1)) { 4278 case IDENT: 4279 { 4280 AST tmp103_AST = null; 4281 tmp103_AST = astFactory.create(LT(1)); 4282 astFactory.addASTChild(currentAST, tmp103_AST); 4283 match(IDENT); 4284 { 4285 boolean synPredMatched339 = false; 4286 if (((LA(1)==LT) && (_tokenSet_18.member(LA(2))))) { 4287 int _m339 = mark(); 4288 synPredMatched339 = true; 4289 inputState.guessing++; 4290 try { 4291 { 4292 typeArguments(false); 4293 match(DOUBLE_COLON); 4294 } 4295 } 4296 catch (RecognitionException pe) { 4297 synPredMatched339 = false; 4298 } 4299 rewind(_m339); 4300inputState.guessing--; 4301 } 4302 if ( synPredMatched339 ) { 4303 typeArguments(false); 4304 astFactory.addASTChild(currentAST, returnAST); 4305 } 4306 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 4307 } 4308 else { 4309 throw new NoViableAltException(LT(1), getFilename()); 4310 } 4311 4312 } 4313 primaryExpression_AST = (AST)currentAST.root; 4314 break; 4315 } 4316 case NUM_INT: 4317 case CHAR_LITERAL: 4318 case STRING_LITERAL: 4319 case NUM_FLOAT: 4320 case NUM_LONG: 4321 case NUM_DOUBLE: 4322 { 4323 constant(); 4324 astFactory.addASTChild(currentAST, returnAST); 4325 primaryExpression_AST = (AST)currentAST.root; 4326 break; 4327 } 4328 case LITERAL_true: 4329 { 4330 AST tmp104_AST = null; 4331 tmp104_AST = astFactory.create(LT(1)); 4332 astFactory.addASTChild(currentAST, tmp104_AST); 4333 match(LITERAL_true); 4334 primaryExpression_AST = (AST)currentAST.root; 4335 break; 4336 } 4337 case LITERAL_false: 4338 { 4339 AST tmp105_AST = null; 4340 tmp105_AST = astFactory.create(LT(1)); 4341 astFactory.addASTChild(currentAST, tmp105_AST); 4342 match(LITERAL_false); 4343 primaryExpression_AST = (AST)currentAST.root; 4344 break; 4345 } 4346 case LITERAL_this: 4347 { 4348 AST tmp106_AST = null; 4349 tmp106_AST = astFactory.create(LT(1)); 4350 astFactory.addASTChild(currentAST, tmp106_AST); 4351 match(LITERAL_this); 4352 primaryExpression_AST = (AST)currentAST.root; 4353 break; 4354 } 4355 case LITERAL_null: 4356 { 4357 AST tmp107_AST = null; 4358 tmp107_AST = astFactory.create(LT(1)); 4359 astFactory.addASTChild(currentAST, tmp107_AST); 4360 match(LITERAL_null); 4361 primaryExpression_AST = (AST)currentAST.root; 4362 break; 4363 } 4364 case LITERAL_new: 4365 { 4366 newExpression(); 4367 astFactory.addASTChild(currentAST, returnAST); 4368 primaryExpression_AST = (AST)currentAST.root; 4369 break; 4370 } 4371 case LPAREN: 4372 { 4373 AST tmp108_AST = null; 4374 tmp108_AST = astFactory.create(LT(1)); 4375 astFactory.addASTChild(currentAST, tmp108_AST); 4376 match(LPAREN); 4377 { 4378 boolean synPredMatched342 = false; 4379 if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) { 4380 int _m342 = mark(); 4381 synPredMatched342 = true; 4382 inputState.guessing++; 4383 try { 4384 { 4385 lambdaExpression(); 4386 } 4387 } 4388 catch (RecognitionException pe) { 4389 synPredMatched342 = false; 4390 } 4391 rewind(_m342); 4392inputState.guessing--; 4393 } 4394 if ( synPredMatched342 ) { 4395 lambdaExpression(); 4396 astFactory.addASTChild(currentAST, returnAST); 4397 } 4398 else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_46.member(LA(2)))) { 4399 assignmentExpression(); 4400 astFactory.addASTChild(currentAST, returnAST); 4401 } 4402 else { 4403 throw new NoViableAltException(LT(1), getFilename()); 4404 } 4405 4406 } 4407 AST tmp109_AST = null; 4408 tmp109_AST = astFactory.create(LT(1)); 4409 astFactory.addASTChild(currentAST, tmp109_AST); 4410 match(RPAREN); 4411 primaryExpression_AST = (AST)currentAST.root; 4412 break; 4413 } 4414 case LITERAL_super: 4415 { 4416 AST tmp110_AST = null; 4417 tmp110_AST = astFactory.create(LT(1)); 4418 astFactory.addASTChild(currentAST, tmp110_AST); 4419 match(LITERAL_super); 4420 primaryExpression_AST = (AST)currentAST.root; 4421 break; 4422 } 4423 case LITERAL_void: 4424 case LITERAL_boolean: 4425 case LITERAL_byte: 4426 case LITERAL_char: 4427 case LITERAL_short: 4428 case LITERAL_int: 4429 case LITERAL_float: 4430 case LITERAL_long: 4431 case LITERAL_double: 4432 { 4433 builtInType(); 4434 astFactory.addASTChild(currentAST, returnAST); 4435 { 4436 _loop344: 4437 do { 4438 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 4439 lbt = LT(1); 4440 lbt_AST = astFactory.create(lbt); 4441 astFactory.makeASTRoot(currentAST, lbt_AST); 4442 match(LBRACK); 4443 if ( inputState.guessing==0 ) { 4444 lbt_AST.setType(ARRAY_DECLARATOR); 4445 } 4446 AST tmp111_AST = null; 4447 tmp111_AST = astFactory.create(LT(1)); 4448 astFactory.addASTChild(currentAST, tmp111_AST); 4449 match(RBRACK); 4450 } 4451 else { 4452 break _loop344; 4453 } 4454 4455 } while (true); 4456 } 4457 { 4458 if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) { 4459 AST tmp112_AST = null; 4460 tmp112_AST = astFactory.create(LT(1)); 4461 astFactory.makeASTRoot(currentAST, tmp112_AST); 4462 match(DOT); 4463 AST tmp113_AST = null; 4464 tmp113_AST = astFactory.create(LT(1)); 4465 astFactory.addASTChild(currentAST, tmp113_AST); 4466 match(LITERAL_class); 4467 } 4468 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 4469 } 4470 else { 4471 throw new NoViableAltException(LT(1), getFilename()); 4472 } 4473 4474 } 4475 primaryExpression_AST = (AST)currentAST.root; 4476 break; 4477 } 4478 default: 4479 { 4480 throw new NoViableAltException(LT(1), getFilename()); 4481 } 4482 } 4483 returnAST = primaryExpression_AST; 4484 } 4485 4486/** Declaration of a variable. This can be a class/instance variable, 4487 * or a local variable in a method 4488 * It can also include possible initialization. 4489 */ 4490 public final void variableDeclarator( 4491 AST mods, AST t 4492 ) throws RecognitionException, TokenStreamException { 4493 4494 returnAST = null; 4495 ASTPair currentAST = new ASTPair(); 4496 AST variableDeclarator_AST = null; 4497 Token id = null; 4498 AST id_AST = null; 4499 AST d_AST = null; 4500 AST v_AST = null; 4501 4502 id = LT(1); 4503 id_AST = astFactory.create(id); 4504 match(IDENT); 4505 declaratorBrackets(t); 4506 d_AST = (AST)returnAST; 4507 varInitializer(); 4508 v_AST = (AST)returnAST; 4509 if ( inputState.guessing==0 ) { 4510 variableDeclarator_AST = (AST)currentAST.root; 4511 variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST).add(v_AST)); 4512 currentAST.root = variableDeclarator_AST; 4513 currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ? 4514 variableDeclarator_AST.getFirstChild() : variableDeclarator_AST; 4515 currentAST.advanceChildToEnd(); 4516 } 4517 returnAST = variableDeclarator_AST; 4518 } 4519 4520 public final void varInitializer() throws RecognitionException, TokenStreamException { 4521 4522 returnAST = null; 4523 ASTPair currentAST = new ASTPair(); 4524 AST varInitializer_AST = null; 4525 4526 { 4527 switch ( LA(1)) { 4528 case ASSIGN: 4529 { 4530 AST tmp114_AST = null; 4531 tmp114_AST = astFactory.create(LT(1)); 4532 astFactory.makeASTRoot(currentAST, tmp114_AST); 4533 match(ASSIGN); 4534 initializer(); 4535 astFactory.addASTChild(currentAST, returnAST); 4536 break; 4537 } 4538 case FINAL: 4539 case ABSTRACT: 4540 case STRICTFP: 4541 case SEMI: 4542 case LITERAL_void: 4543 case LITERAL_boolean: 4544 case LITERAL_byte: 4545 case LITERAL_char: 4546 case LITERAL_short: 4547 case LITERAL_int: 4548 case LITERAL_float: 4549 case LITERAL_long: 4550 case LITERAL_double: 4551 case IDENT: 4552 case LITERAL_private: 4553 case LITERAL_public: 4554 case LITERAL_protected: 4555 case LITERAL_static: 4556 case LITERAL_transient: 4557 case LITERAL_native: 4558 case LITERAL_synchronized: 4559 case LITERAL_volatile: 4560 case LITERAL_class: 4561 case LITERAL_interface: 4562 case LCURLY: 4563 case RCURLY: 4564 case COMMA: 4565 case LITERAL_default: 4566 case LT: 4567 case ENUM: 4568 case AT: 4569 { 4570 break; 4571 } 4572 default: 4573 { 4574 throw new NoViableAltException(LT(1), getFilename()); 4575 } 4576 } 4577 } 4578 varInitializer_AST = (AST)currentAST.root; 4579 returnAST = varInitializer_AST; 4580 } 4581 4582 public final void initializer() throws RecognitionException, TokenStreamException { 4583 4584 returnAST = null; 4585 ASTPair currentAST = new ASTPair(); 4586 AST initializer_AST = null; 4587 4588 switch ( LA(1)) { 4589 case LITERAL_void: 4590 case LITERAL_boolean: 4591 case LITERAL_byte: 4592 case LITERAL_char: 4593 case LITERAL_short: 4594 case LITERAL_int: 4595 case LITERAL_float: 4596 case LITERAL_long: 4597 case LITERAL_double: 4598 case IDENT: 4599 case LPAREN: 4600 case LITERAL_this: 4601 case LITERAL_super: 4602 case PLUS: 4603 case MINUS: 4604 case INC: 4605 case DEC: 4606 case BNOT: 4607 case LNOT: 4608 case LITERAL_true: 4609 case LITERAL_false: 4610 case LITERAL_null: 4611 case LITERAL_new: 4612 case NUM_INT: 4613 case CHAR_LITERAL: 4614 case STRING_LITERAL: 4615 case NUM_FLOAT: 4616 case NUM_LONG: 4617 case NUM_DOUBLE: 4618 { 4619 expression(); 4620 astFactory.addASTChild(currentAST, returnAST); 4621 initializer_AST = (AST)currentAST.root; 4622 break; 4623 } 4624 case LCURLY: 4625 { 4626 arrayInitializer(); 4627 astFactory.addASTChild(currentAST, returnAST); 4628 initializer_AST = (AST)currentAST.root; 4629 break; 4630 } 4631 default: 4632 { 4633 throw new NoViableAltException(LT(1), getFilename()); 4634 } 4635 } 4636 returnAST = initializer_AST; 4637 } 4638 4639 public final void arrayInitializer() throws RecognitionException, TokenStreamException { 4640 4641 returnAST = null; 4642 ASTPair currentAST = new ASTPair(); 4643 AST arrayInitializer_AST = null; 4644 Token lc = null; 4645 AST lc_AST = null; 4646 4647 lc = LT(1); 4648 lc_AST = astFactory.create(lc); 4649 astFactory.makeASTRoot(currentAST, lc_AST); 4650 match(LCURLY); 4651 if ( inputState.guessing==0 ) { 4652 lc_AST.setType(ARRAY_INIT); 4653 } 4654 { 4655 switch ( LA(1)) { 4656 case LITERAL_void: 4657 case LITERAL_boolean: 4658 case LITERAL_byte: 4659 case LITERAL_char: 4660 case LITERAL_short: 4661 case LITERAL_int: 4662 case LITERAL_float: 4663 case LITERAL_long: 4664 case LITERAL_double: 4665 case IDENT: 4666 case LCURLY: 4667 case LPAREN: 4668 case LITERAL_this: 4669 case LITERAL_super: 4670 case PLUS: 4671 case MINUS: 4672 case INC: 4673 case DEC: 4674 case BNOT: 4675 case LNOT: 4676 case LITERAL_true: 4677 case LITERAL_false: 4678 case LITERAL_null: 4679 case LITERAL_new: 4680 case NUM_INT: 4681 case CHAR_LITERAL: 4682 case STRING_LITERAL: 4683 case NUM_FLOAT: 4684 case NUM_LONG: 4685 case NUM_DOUBLE: 4686 { 4687 initializer(); 4688 astFactory.addASTChild(currentAST, returnAST); 4689 { 4690 _loop169: 4691 do { 4692 if ((LA(1)==COMMA) && (_tokenSet_47.member(LA(2)))) { 4693 AST tmp115_AST = null; 4694 tmp115_AST = astFactory.create(LT(1)); 4695 astFactory.addASTChild(currentAST, tmp115_AST); 4696 match(COMMA); 4697 initializer(); 4698 astFactory.addASTChild(currentAST, returnAST); 4699 } 4700 else { 4701 break _loop169; 4702 } 4703 4704 } while (true); 4705 } 4706 break; 4707 } 4708 case RCURLY: 4709 case COMMA: 4710 { 4711 break; 4712 } 4713 default: 4714 { 4715 throw new NoViableAltException(LT(1), getFilename()); 4716 } 4717 } 4718 } 4719 { 4720 switch ( LA(1)) { 4721 case COMMA: 4722 { 4723 AST tmp116_AST = null; 4724 tmp116_AST = astFactory.create(LT(1)); 4725 astFactory.addASTChild(currentAST, tmp116_AST); 4726 match(COMMA); 4727 break; 4728 } 4729 case RCURLY: 4730 { 4731 break; 4732 } 4733 default: 4734 { 4735 throw new NoViableAltException(LT(1), getFilename()); 4736 } 4737 } 4738 } 4739 AST tmp117_AST = null; 4740 tmp117_AST = astFactory.create(LT(1)); 4741 astFactory.addASTChild(currentAST, tmp117_AST); 4742 match(RCURLY); 4743 arrayInitializer_AST = (AST)currentAST.root; 4744 returnAST = arrayInitializer_AST; 4745 } 4746 4747 public final void expression() throws RecognitionException, TokenStreamException { 4748 4749 returnAST = null; 4750 ASTPair currentAST = new ASTPair(); 4751 AST expression_AST = null; 4752 4753 boolean synPredMatched256 = false; 4754 if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) { 4755 int _m256 = mark(); 4756 synPredMatched256 = true; 4757 inputState.guessing++; 4758 try { 4759 { 4760 lambdaExpression(); 4761 } 4762 } 4763 catch (RecognitionException pe) { 4764 synPredMatched256 = false; 4765 } 4766 rewind(_m256); 4767inputState.guessing--; 4768 } 4769 if ( synPredMatched256 ) { 4770 lambdaExpression(); 4771 astFactory.addASTChild(currentAST, returnAST); 4772 expression_AST = (AST)currentAST.root; 4773 } 4774 else if (((_tokenSet_16.member(LA(1))) && (_tokenSet_18.member(LA(2))))&&(LA(1)!=RPAREN)) { 4775 assignmentExpression(); 4776 astFactory.addASTChild(currentAST, returnAST); 4777 if ( inputState.guessing==0 ) { 4778 expression_AST = (AST)currentAST.root; 4779 expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST)); 4780 currentAST.root = expression_AST; 4781 currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ? 4782 expression_AST.getFirstChild() : expression_AST; 4783 currentAST.advanceChildToEnd(); 4784 } 4785 expression_AST = (AST)currentAST.root; 4786 } 4787 else { 4788 throw new NoViableAltException(LT(1), getFilename()); 4789 } 4790 4791 returnAST = expression_AST; 4792 } 4793 4794 public final void parameterDeclaration() throws RecognitionException, TokenStreamException { 4795 4796 returnAST = null; 4797 ASTPair currentAST = new ASTPair(); 4798 AST parameterDeclaration_AST = null; 4799 AST pm_AST = null; 4800 AST t_AST = null; 4801 Token id = null; 4802 AST id_AST = null; 4803 AST pd_AST = null; 4804 4805 parameterModifier(); 4806 pm_AST = (AST)returnAST; 4807 { 4808 if ((_tokenSet_9.member(LA(1))) && (_tokenSet_22.member(LA(2)))) { 4809 typeSpec(false); 4810 t_AST = (AST)returnAST; 4811 } 4812 else if ((LA(1)==IDENT) && (_tokenSet_48.member(LA(2)))) { 4813 } 4814 else { 4815 throw new NoViableAltException(LT(1), getFilename()); 4816 } 4817 4818 } 4819 id = LT(1); 4820 id_AST = astFactory.create(id); 4821 match(IDENT); 4822 declaratorBrackets(t_AST); 4823 pd_AST = (AST)returnAST; 4824 if ( inputState.guessing==0 ) { 4825 parameterDeclaration_AST = (AST)currentAST.root; 4826 parameterDeclaration_AST = (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(pd_AST))).add(id_AST)); 4827 currentAST.root = parameterDeclaration_AST; 4828 currentAST.child = parameterDeclaration_AST!=null &¶meterDeclaration_AST.getFirstChild()!=null ? 4829 parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST; 4830 currentAST.advanceChildToEnd(); 4831 } 4832 returnAST = parameterDeclaration_AST; 4833 } 4834 4835 public final void variableLengthParameterDeclaration() throws RecognitionException, TokenStreamException { 4836 4837 returnAST = null; 4838 ASTPair currentAST = new ASTPair(); 4839 AST variableLengthParameterDeclaration_AST = null; 4840 AST pm_AST = null; 4841 AST t_AST = null; 4842 Token td = null; 4843 AST td_AST = null; 4844 AST pd_AST = null; 4845 4846 parameterModifier(); 4847 pm_AST = (AST)returnAST; 4848 typeSpec(false); 4849 t_AST = (AST)returnAST; 4850 td = LT(1); 4851 td_AST = astFactory.create(td); 4852 match(ELLIPSIS); 4853 AST tmp118_AST = null; 4854 tmp118_AST = astFactory.create(LT(1)); 4855 match(IDENT); 4856 declaratorBrackets(t_AST); 4857 pd_AST = (AST)returnAST; 4858 if ( inputState.guessing==0 ) { 4859 variableLengthParameterDeclaration_AST = (AST)currentAST.root; 4860 variableLengthParameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(td_AST).add(tmp118_AST)); 4861 currentAST.root = variableLengthParameterDeclaration_AST; 4862 currentAST.child = variableLengthParameterDeclaration_AST!=null &&variableLengthParameterDeclaration_AST.getFirstChild()!=null ? 4863 variableLengthParameterDeclaration_AST.getFirstChild() : variableLengthParameterDeclaration_AST; 4864 currentAST.advanceChildToEnd(); 4865 } 4866 returnAST = variableLengthParameterDeclaration_AST; 4867 } 4868 4869 public final void parameterModifier() throws RecognitionException, TokenStreamException { 4870 4871 returnAST = null; 4872 ASTPair currentAST = new ASTPair(); 4873 AST parameterModifier_AST = null; 4874 Token f = null; 4875 AST f_AST = null; 4876 4877 { 4878 _loop190: 4879 do { 4880 if ((LA(1)==AT) && (LA(2)==IDENT)) { 4881 annotation(); 4882 astFactory.addASTChild(currentAST, returnAST); 4883 } 4884 else { 4885 break _loop190; 4886 } 4887 4888 } while (true); 4889 } 4890 { 4891 switch ( LA(1)) { 4892 case FINAL: 4893 { 4894 f = LT(1); 4895 f_AST = astFactory.create(f); 4896 astFactory.addASTChild(currentAST, f_AST); 4897 match(FINAL); 4898 break; 4899 } 4900 case LITERAL_void: 4901 case LITERAL_boolean: 4902 case LITERAL_byte: 4903 case LITERAL_char: 4904 case LITERAL_short: 4905 case LITERAL_int: 4906 case LITERAL_float: 4907 case LITERAL_long: 4908 case LITERAL_double: 4909 case IDENT: 4910 case AT: 4911 { 4912 break; 4913 } 4914 default: 4915 { 4916 throw new NoViableAltException(LT(1), getFilename()); 4917 } 4918 } 4919 } 4920 { 4921 _loop193: 4922 do { 4923 if ((LA(1)==AT) && (LA(2)==IDENT)) { 4924 annotation(); 4925 astFactory.addASTChild(currentAST, returnAST); 4926 } 4927 else { 4928 break _loop193; 4929 } 4930 4931 } while (true); 4932 } 4933 if ( inputState.guessing==0 ) { 4934 parameterModifier_AST = (AST)currentAST.root; 4935 parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(parameterModifier_AST)); 4936 currentAST.root = parameterModifier_AST; 4937 currentAST.child = parameterModifier_AST!=null &¶meterModifier_AST.getFirstChild()!=null ? 4938 parameterModifier_AST.getFirstChild() : parameterModifier_AST; 4939 currentAST.advanceChildToEnd(); 4940 } 4941 parameterModifier_AST = (AST)currentAST.root; 4942 returnAST = parameterModifier_AST; 4943 } 4944 4945 public final void catchParameterDeclaration() throws RecognitionException, TokenStreamException { 4946 4947 returnAST = null; 4948 ASTPair currentAST = new ASTPair(); 4949 AST catchParameterDeclaration_AST = null; 4950 AST pm_AST = null; 4951 AST mct_AST = null; 4952 Token id = null; 4953 AST id_AST = null; 4954 4955 parameterModifier(); 4956 pm_AST = (AST)returnAST; 4957 multiCatchTypes(); 4958 mct_AST = (AST)returnAST; 4959 id = LT(1); 4960 id_AST = astFactory.create(id); 4961 match(IDENT); 4962 if ( inputState.guessing==0 ) { 4963 catchParameterDeclaration_AST = (AST)currentAST.root; 4964 catchParameterDeclaration_AST = (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)); 4965 currentAST.root = catchParameterDeclaration_AST; 4966 currentAST.child = catchParameterDeclaration_AST!=null &&catchParameterDeclaration_AST.getFirstChild()!=null ? 4967 catchParameterDeclaration_AST.getFirstChild() : catchParameterDeclaration_AST; 4968 currentAST.advanceChildToEnd(); 4969 } 4970 returnAST = catchParameterDeclaration_AST; 4971 } 4972 4973 public final void multiCatchTypes() throws RecognitionException, TokenStreamException { 4974 4975 returnAST = null; 4976 ASTPair currentAST = new ASTPair(); 4977 AST multiCatchTypes_AST = null; 4978 4979 typeSpec(false); 4980 astFactory.addASTChild(currentAST, returnAST); 4981 { 4982 _loop199: 4983 do { 4984 if ((LA(1)==BOR)) { 4985 AST tmp119_AST = null; 4986 tmp119_AST = astFactory.create(LT(1)); 4987 astFactory.makeASTRoot(currentAST, tmp119_AST); 4988 match(BOR); 4989 typeSpec(false); 4990 astFactory.addASTChild(currentAST, returnAST); 4991 } 4992 else { 4993 break _loop199; 4994 } 4995 4996 } while (true); 4997 } 4998 multiCatchTypes_AST = (AST)currentAST.root; 4999 returnAST = multiCatchTypes_AST; 5000 } 5001 5002 public final void traditionalStatement() throws RecognitionException, TokenStreamException { 5003 5004 returnAST = null; 5005 ASTPair currentAST = new ASTPair(); 5006 AST traditionalStatement_AST = null; 5007 AST m_AST = null; 5008 Token c = null; 5009 AST c_AST = null; 5010 Token w = null; 5011 AST w_AST = null; 5012 Token s = null; 5013 AST s_AST = null; 5014 5015 switch ( LA(1)) { 5016 case LCURLY: 5017 { 5018 compoundStatement(); 5019 astFactory.addASTChild(currentAST, returnAST); 5020 traditionalStatement_AST = (AST)currentAST.root; 5021 break; 5022 } 5023 case LITERAL_if: 5024 { 5025 AST tmp120_AST = null; 5026 tmp120_AST = astFactory.create(LT(1)); 5027 astFactory.makeASTRoot(currentAST, tmp120_AST); 5028 match(LITERAL_if); 5029 AST tmp121_AST = null; 5030 tmp121_AST = astFactory.create(LT(1)); 5031 astFactory.addASTChild(currentAST, tmp121_AST); 5032 match(LPAREN); 5033 expression(); 5034 astFactory.addASTChild(currentAST, returnAST); 5035 AST tmp122_AST = null; 5036 tmp122_AST = astFactory.create(LT(1)); 5037 astFactory.addASTChild(currentAST, tmp122_AST); 5038 match(RPAREN); 5039 statement(); 5040 astFactory.addASTChild(currentAST, returnAST); 5041 { 5042 if ((LA(1)==LITERAL_else) && (_tokenSet_36.member(LA(2)))) { 5043 elseStatement(); 5044 astFactory.addASTChild(currentAST, returnAST); 5045 } 5046 else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) { 5047 } 5048 else { 5049 throw new NoViableAltException(LT(1), getFilename()); 5050 } 5051 5052 } 5053 traditionalStatement_AST = (AST)currentAST.root; 5054 break; 5055 } 5056 case LITERAL_for: 5057 { 5058 forStatement(); 5059 astFactory.addASTChild(currentAST, returnAST); 5060 traditionalStatement_AST = (AST)currentAST.root; 5061 break; 5062 } 5063 case LITERAL_while: 5064 { 5065 AST tmp123_AST = null; 5066 tmp123_AST = astFactory.create(LT(1)); 5067 astFactory.makeASTRoot(currentAST, tmp123_AST); 5068 match(LITERAL_while); 5069 AST tmp124_AST = null; 5070 tmp124_AST = astFactory.create(LT(1)); 5071 astFactory.addASTChild(currentAST, tmp124_AST); 5072 match(LPAREN); 5073 expression(); 5074 astFactory.addASTChild(currentAST, returnAST); 5075 AST tmp125_AST = null; 5076 tmp125_AST = astFactory.create(LT(1)); 5077 astFactory.addASTChild(currentAST, tmp125_AST); 5078 match(RPAREN); 5079 statement(); 5080 astFactory.addASTChild(currentAST, returnAST); 5081 traditionalStatement_AST = (AST)currentAST.root; 5082 break; 5083 } 5084 case LITERAL_do: 5085 { 5086 AST tmp126_AST = null; 5087 tmp126_AST = astFactory.create(LT(1)); 5088 astFactory.makeASTRoot(currentAST, tmp126_AST); 5089 match(LITERAL_do); 5090 statement(); 5091 astFactory.addASTChild(currentAST, returnAST); 5092 w = LT(1); 5093 w_AST = astFactory.create(w); 5094 astFactory.addASTChild(currentAST, w_AST); 5095 match(LITERAL_while); 5096 if ( inputState.guessing==0 ) { 5097 w_AST.setType(DO_WHILE); 5098 } 5099 AST tmp127_AST = null; 5100 tmp127_AST = astFactory.create(LT(1)); 5101 astFactory.addASTChild(currentAST, tmp127_AST); 5102 match(LPAREN); 5103 expression(); 5104 astFactory.addASTChild(currentAST, returnAST); 5105 AST tmp128_AST = null; 5106 tmp128_AST = astFactory.create(LT(1)); 5107 astFactory.addASTChild(currentAST, tmp128_AST); 5108 match(RPAREN); 5109 AST tmp129_AST = null; 5110 tmp129_AST = astFactory.create(LT(1)); 5111 astFactory.addASTChild(currentAST, tmp129_AST); 5112 match(SEMI); 5113 traditionalStatement_AST = (AST)currentAST.root; 5114 break; 5115 } 5116 case LITERAL_break: 5117 { 5118 AST tmp130_AST = null; 5119 tmp130_AST = astFactory.create(LT(1)); 5120 astFactory.makeASTRoot(currentAST, tmp130_AST); 5121 match(LITERAL_break); 5122 { 5123 switch ( LA(1)) { 5124 case IDENT: 5125 { 5126 AST tmp131_AST = null; 5127 tmp131_AST = astFactory.create(LT(1)); 5128 astFactory.addASTChild(currentAST, tmp131_AST); 5129 match(IDENT); 5130 break; 5131 } 5132 case SEMI: 5133 { 5134 break; 5135 } 5136 default: 5137 { 5138 throw new NoViableAltException(LT(1), getFilename()); 5139 } 5140 } 5141 } 5142 AST tmp132_AST = null; 5143 tmp132_AST = astFactory.create(LT(1)); 5144 astFactory.addASTChild(currentAST, tmp132_AST); 5145 match(SEMI); 5146 traditionalStatement_AST = (AST)currentAST.root; 5147 break; 5148 } 5149 case LITERAL_continue: 5150 { 5151 AST tmp133_AST = null; 5152 tmp133_AST = astFactory.create(LT(1)); 5153 astFactory.makeASTRoot(currentAST, tmp133_AST); 5154 match(LITERAL_continue); 5155 { 5156 switch ( LA(1)) { 5157 case IDENT: 5158 { 5159 AST tmp134_AST = null; 5160 tmp134_AST = astFactory.create(LT(1)); 5161 astFactory.addASTChild(currentAST, tmp134_AST); 5162 match(IDENT); 5163 break; 5164 } 5165 case SEMI: 5166 { 5167 break; 5168 } 5169 default: 5170 { 5171 throw new NoViableAltException(LT(1), getFilename()); 5172 } 5173 } 5174 } 5175 AST tmp135_AST = null; 5176 tmp135_AST = astFactory.create(LT(1)); 5177 astFactory.addASTChild(currentAST, tmp135_AST); 5178 match(SEMI); 5179 traditionalStatement_AST = (AST)currentAST.root; 5180 break; 5181 } 5182 case LITERAL_return: 5183 { 5184 AST tmp136_AST = null; 5185 tmp136_AST = astFactory.create(LT(1)); 5186 astFactory.makeASTRoot(currentAST, tmp136_AST); 5187 match(LITERAL_return); 5188 { 5189 switch ( LA(1)) { 5190 case LITERAL_void: 5191 case LITERAL_boolean: 5192 case LITERAL_byte: 5193 case LITERAL_char: 5194 case LITERAL_short: 5195 case LITERAL_int: 5196 case LITERAL_float: 5197 case LITERAL_long: 5198 case LITERAL_double: 5199 case IDENT: 5200 case LPAREN: 5201 case LITERAL_this: 5202 case LITERAL_super: 5203 case PLUS: 5204 case MINUS: 5205 case INC: 5206 case DEC: 5207 case BNOT: 5208 case LNOT: 5209 case LITERAL_true: 5210 case LITERAL_false: 5211 case LITERAL_null: 5212 case LITERAL_new: 5213 case NUM_INT: 5214 case CHAR_LITERAL: 5215 case STRING_LITERAL: 5216 case NUM_FLOAT: 5217 case NUM_LONG: 5218 case NUM_DOUBLE: 5219 { 5220 expression(); 5221 astFactory.addASTChild(currentAST, returnAST); 5222 break; 5223 } 5224 case SEMI: 5225 { 5226 break; 5227 } 5228 default: 5229 { 5230 throw new NoViableAltException(LT(1), getFilename()); 5231 } 5232 } 5233 } 5234 AST tmp137_AST = null; 5235 tmp137_AST = astFactory.create(LT(1)); 5236 astFactory.addASTChild(currentAST, tmp137_AST); 5237 match(SEMI); 5238 traditionalStatement_AST = (AST)currentAST.root; 5239 break; 5240 } 5241 case LITERAL_switch: 5242 { 5243 AST tmp138_AST = null; 5244 tmp138_AST = astFactory.create(LT(1)); 5245 astFactory.makeASTRoot(currentAST, tmp138_AST); 5246 match(LITERAL_switch); 5247 AST tmp139_AST = null; 5248 tmp139_AST = astFactory.create(LT(1)); 5249 astFactory.addASTChild(currentAST, tmp139_AST); 5250 match(LPAREN); 5251 expression(); 5252 astFactory.addASTChild(currentAST, returnAST); 5253 AST tmp140_AST = null; 5254 tmp140_AST = astFactory.create(LT(1)); 5255 astFactory.addASTChild(currentAST, tmp140_AST); 5256 match(RPAREN); 5257 AST tmp141_AST = null; 5258 tmp141_AST = astFactory.create(LT(1)); 5259 astFactory.addASTChild(currentAST, tmp141_AST); 5260 match(LCURLY); 5261 { 5262 _loop215: 5263 do { 5264 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) { 5265 casesGroup(); 5266 astFactory.addASTChild(currentAST, returnAST); 5267 } 5268 else { 5269 break _loop215; 5270 } 5271 5272 } while (true); 5273 } 5274 AST tmp142_AST = null; 5275 tmp142_AST = astFactory.create(LT(1)); 5276 astFactory.addASTChild(currentAST, tmp142_AST); 5277 match(RCURLY); 5278 traditionalStatement_AST = (AST)currentAST.root; 5279 break; 5280 } 5281 case LITERAL_try: 5282 { 5283 tryBlock(); 5284 astFactory.addASTChild(currentAST, returnAST); 5285 traditionalStatement_AST = (AST)currentAST.root; 5286 break; 5287 } 5288 case LITERAL_throw: 5289 { 5290 AST tmp143_AST = null; 5291 tmp143_AST = astFactory.create(LT(1)); 5292 astFactory.makeASTRoot(currentAST, tmp143_AST); 5293 match(LITERAL_throw); 5294 expression(); 5295 astFactory.addASTChild(currentAST, returnAST); 5296 AST tmp144_AST = null; 5297 tmp144_AST = astFactory.create(LT(1)); 5298 astFactory.addASTChild(currentAST, tmp144_AST); 5299 match(SEMI); 5300 traditionalStatement_AST = (AST)currentAST.root; 5301 break; 5302 } 5303 case SEMI: 5304 { 5305 s = LT(1); 5306 s_AST = astFactory.create(s); 5307 astFactory.addASTChild(currentAST, s_AST); 5308 match(SEMI); 5309 if ( inputState.guessing==0 ) { 5310 s_AST.setType(EMPTY_STAT); 5311 } 5312 traditionalStatement_AST = (AST)currentAST.root; 5313 break; 5314 } 5315 default: 5316 boolean synPredMatched208 = false; 5317 if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) { 5318 int _m208 = mark(); 5319 synPredMatched208 = true; 5320 inputState.guessing++; 5321 try { 5322 { 5323 declaration(); 5324 } 5325 } 5326 catch (RecognitionException pe) { 5327 synPredMatched208 = false; 5328 } 5329 rewind(_m208); 5330inputState.guessing--; 5331 } 5332 if ( synPredMatched208 ) { 5333 declaration(); 5334 astFactory.addASTChild(currentAST, returnAST); 5335 AST tmp145_AST = null; 5336 tmp145_AST = astFactory.create(LT(1)); 5337 astFactory.addASTChild(currentAST, tmp145_AST); 5338 match(SEMI); 5339 traditionalStatement_AST = (AST)currentAST.root; 5340 } 5341 else if (((_tokenSet_16.member(LA(1))) && (_tokenSet_53.member(LA(2))))&&(LA(2) != COLON)) { 5342 expression(); 5343 astFactory.addASTChild(currentAST, returnAST); 5344 { 5345 if ((LA(1)==SEMI) && (_tokenSet_49.member(LA(2)))) { 5346 AST tmp146_AST = null; 5347 tmp146_AST = astFactory.create(LT(1)); 5348 astFactory.addASTChild(currentAST, tmp146_AST); 5349 match(SEMI); 5350 } 5351 else if ((_tokenSet_49.member(LA(1))) && (_tokenSet_50.member(LA(2)))) { 5352 } 5353 else { 5354 throw new NoViableAltException(LT(1), getFilename()); 5355 } 5356 5357 } 5358 traditionalStatement_AST = (AST)currentAST.root; 5359 } 5360 else if ((_tokenSet_54.member(LA(1))) && (_tokenSet_55.member(LA(2)))) { 5361 modifiers(); 5362 m_AST = (AST)returnAST; 5363 classDefinition(m_AST); 5364 astFactory.addASTChild(currentAST, returnAST); 5365 traditionalStatement_AST = (AST)currentAST.root; 5366 } 5367 else if ((LA(1)==IDENT) && (LA(2)==COLON)) { 5368 AST tmp147_AST = null; 5369 tmp147_AST = astFactory.create(LT(1)); 5370 astFactory.addASTChild(currentAST, tmp147_AST); 5371 match(IDENT); 5372 c = LT(1); 5373 c_AST = astFactory.create(c); 5374 astFactory.makeASTRoot(currentAST, c_AST); 5375 match(COLON); 5376 if ( inputState.guessing==0 ) { 5377 c_AST.setType(LABELED_STAT); 5378 } 5379 statement(); 5380 astFactory.addASTChild(currentAST, returnAST); 5381 traditionalStatement_AST = (AST)currentAST.root; 5382 } 5383 else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) { 5384 AST tmp148_AST = null; 5385 tmp148_AST = astFactory.create(LT(1)); 5386 astFactory.makeASTRoot(currentAST, tmp148_AST); 5387 match(LITERAL_synchronized); 5388 AST tmp149_AST = null; 5389 tmp149_AST = astFactory.create(LT(1)); 5390 astFactory.addASTChild(currentAST, tmp149_AST); 5391 match(LPAREN); 5392 expression(); 5393 astFactory.addASTChild(currentAST, returnAST); 5394 AST tmp150_AST = null; 5395 tmp150_AST = astFactory.create(LT(1)); 5396 astFactory.addASTChild(currentAST, tmp150_AST); 5397 match(RPAREN); 5398 compoundStatement(); 5399 astFactory.addASTChild(currentAST, returnAST); 5400 traditionalStatement_AST = (AST)currentAST.root; 5401 } 5402 else { 5403 throw new NoViableAltException(LT(1), getFilename()); 5404 } 5405 } 5406 returnAST = traditionalStatement_AST; 5407 } 5408 5409 public final void assertStatement() throws RecognitionException, TokenStreamException { 5410 5411 returnAST = null; 5412 ASTPair currentAST = new ASTPair(); 5413 AST assertStatement_AST = null; 5414 5415 AST tmp151_AST = null; 5416 tmp151_AST = astFactory.create(LT(1)); 5417 astFactory.makeASTRoot(currentAST, tmp151_AST); 5418 match(ASSERT); 5419 expression(); 5420 astFactory.addASTChild(currentAST, returnAST); 5421 { 5422 switch ( LA(1)) { 5423 case COLON: 5424 { 5425 AST tmp152_AST = null; 5426 tmp152_AST = astFactory.create(LT(1)); 5427 astFactory.addASTChild(currentAST, tmp152_AST); 5428 match(COLON); 5429 expression(); 5430 astFactory.addASTChild(currentAST, returnAST); 5431 break; 5432 } 5433 case SEMI: 5434 { 5435 break; 5436 } 5437 default: 5438 { 5439 throw new NoViableAltException(LT(1), getFilename()); 5440 } 5441 } 5442 } 5443 AST tmp153_AST = null; 5444 tmp153_AST = astFactory.create(LT(1)); 5445 astFactory.addASTChild(currentAST, tmp153_AST); 5446 match(SEMI); 5447 assertStatement_AST = (AST)currentAST.root; 5448 returnAST = assertStatement_AST; 5449 } 5450 5451 public final void elseStatement() throws RecognitionException, TokenStreamException { 5452 5453 returnAST = null; 5454 ASTPair currentAST = new ASTPair(); 5455 AST elseStatement_AST = null; 5456 5457 AST tmp154_AST = null; 5458 tmp154_AST = astFactory.create(LT(1)); 5459 astFactory.makeASTRoot(currentAST, tmp154_AST); 5460 match(LITERAL_else); 5461 statement(); 5462 astFactory.addASTChild(currentAST, returnAST); 5463 elseStatement_AST = (AST)currentAST.root; 5464 returnAST = elseStatement_AST; 5465 } 5466 5467 public final void forStatement() throws RecognitionException, TokenStreamException { 5468 5469 returnAST = null; 5470 ASTPair currentAST = new ASTPair(); 5471 AST forStatement_AST = null; 5472 Token f = null; 5473 AST f_AST = null; 5474 5475 f = LT(1); 5476 f_AST = astFactory.create(f); 5477 astFactory.makeASTRoot(currentAST, f_AST); 5478 match(LITERAL_for); 5479 AST tmp155_AST = null; 5480 tmp155_AST = astFactory.create(LT(1)); 5481 astFactory.addASTChild(currentAST, tmp155_AST); 5482 match(LPAREN); 5483 { 5484 boolean synPredMatched219 = false; 5485 if (((_tokenSet_56.member(LA(1))) && (_tokenSet_57.member(LA(2))))) { 5486 int _m219 = mark(); 5487 synPredMatched219 = true; 5488 inputState.guessing++; 5489 try { 5490 { 5491 forInit(); 5492 match(SEMI); 5493 } 5494 } 5495 catch (RecognitionException pe) { 5496 synPredMatched219 = false; 5497 } 5498 rewind(_m219); 5499inputState.guessing--; 5500 } 5501 if ( synPredMatched219 ) { 5502 traditionalForClause(); 5503 astFactory.addASTChild(currentAST, returnAST); 5504 } 5505 else if ((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2)))) { 5506 forEachClause(); 5507 astFactory.addASTChild(currentAST, returnAST); 5508 } 5509 else { 5510 throw new NoViableAltException(LT(1), getFilename()); 5511 } 5512 5513 } 5514 AST tmp156_AST = null; 5515 tmp156_AST = astFactory.create(LT(1)); 5516 astFactory.addASTChild(currentAST, tmp156_AST); 5517 match(RPAREN); 5518 statement(); 5519 astFactory.addASTChild(currentAST, returnAST); 5520 forStatement_AST = (AST)currentAST.root; 5521 returnAST = forStatement_AST; 5522 } 5523 5524 public final void casesGroup() throws RecognitionException, TokenStreamException { 5525 5526 returnAST = null; 5527 ASTPair currentAST = new ASTPair(); 5528 AST casesGroup_AST = null; 5529 5530 { 5531 int _cnt226=0; 5532 _loop226: 5533 do { 5534 if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_58.member(LA(2)))) { 5535 aCase(); 5536 astFactory.addASTChild(currentAST, returnAST); 5537 } 5538 else { 5539 if ( _cnt226>=1 ) { break _loop226; } else {throw new NoViableAltException(LT(1), getFilename());} 5540 } 5541 5542 _cnt226++; 5543 } while (true); 5544 } 5545 caseSList(); 5546 astFactory.addASTChild(currentAST, returnAST); 5547 if ( inputState.guessing==0 ) { 5548 casesGroup_AST = (AST)currentAST.root; 5549 casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST)); 5550 currentAST.root = casesGroup_AST; 5551 currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ? 5552 casesGroup_AST.getFirstChild() : casesGroup_AST; 5553 currentAST.advanceChildToEnd(); 5554 } 5555 casesGroup_AST = (AST)currentAST.root; 5556 returnAST = casesGroup_AST; 5557 } 5558 5559 public final void tryBlock() throws RecognitionException, TokenStreamException { 5560 5561 returnAST = null; 5562 ASTPair currentAST = new ASTPair(); 5563 AST tryBlock_AST = null; 5564 5565 AST tmp157_AST = null; 5566 tmp157_AST = astFactory.create(LT(1)); 5567 astFactory.makeASTRoot(currentAST, tmp157_AST); 5568 match(LITERAL_try); 5569 { 5570 switch ( LA(1)) { 5571 case LPAREN: 5572 { 5573 resourceSpecification(); 5574 astFactory.addASTChild(currentAST, returnAST); 5575 break; 5576 } 5577 case LCURLY: 5578 { 5579 break; 5580 } 5581 default: 5582 { 5583 throw new NoViableAltException(LT(1), getFilename()); 5584 } 5585 } 5586 } 5587 compoundStatement(); 5588 astFactory.addASTChild(currentAST, returnAST); 5589 { 5590 _loop243: 5591 do { 5592 if ((LA(1)==LITERAL_catch)) { 5593 handler(); 5594 astFactory.addASTChild(currentAST, returnAST); 5595 } 5596 else { 5597 break _loop243; 5598 } 5599 5600 } while (true); 5601 } 5602 { 5603 switch ( LA(1)) { 5604 case LITERAL_finally: 5605 { 5606 finallyHandler(); 5607 astFactory.addASTChild(currentAST, returnAST); 5608 break; 5609 } 5610 case FINAL: 5611 case ABSTRACT: 5612 case STRICTFP: 5613 case SEMI: 5614 case LITERAL_void: 5615 case LITERAL_boolean: 5616 case LITERAL_byte: 5617 case LITERAL_char: 5618 case LITERAL_short: 5619 case LITERAL_int: 5620 case LITERAL_float: 5621 case LITERAL_long: 5622 case LITERAL_double: 5623 case IDENT: 5624 case LITERAL_private: 5625 case LITERAL_public: 5626 case LITERAL_protected: 5627 case LITERAL_static: 5628 case LITERAL_transient: 5629 case LITERAL_native: 5630 case LITERAL_synchronized: 5631 case LITERAL_volatile: 5632 case LITERAL_class: 5633 case LCURLY: 5634 case RCURLY: 5635 case LPAREN: 5636 case RPAREN: 5637 case LITERAL_this: 5638 case LITERAL_super: 5639 case COLON: 5640 case LITERAL_if: 5641 case LITERAL_while: 5642 case LITERAL_do: 5643 case LITERAL_break: 5644 case LITERAL_continue: 5645 case LITERAL_return: 5646 case LITERAL_switch: 5647 case LITERAL_throw: 5648 case LITERAL_for: 5649 case LITERAL_else: 5650 case LITERAL_case: 5651 case LITERAL_default: 5652 case LITERAL_try: 5653 case PLUS: 5654 case MINUS: 5655 case INC: 5656 case DEC: 5657 case BNOT: 5658 case LNOT: 5659 case LITERAL_true: 5660 case LITERAL_false: 5661 case LITERAL_null: 5662 case LITERAL_new: 5663 case NUM_INT: 5664 case CHAR_LITERAL: 5665 case STRING_LITERAL: 5666 case NUM_FLOAT: 5667 case NUM_LONG: 5668 case NUM_DOUBLE: 5669 case ASSERT: 5670 case AT: 5671 { 5672 break; 5673 } 5674 default: 5675 { 5676 throw new NoViableAltException(LT(1), getFilename()); 5677 } 5678 } 5679 } 5680 tryBlock_AST = (AST)currentAST.root; 5681 returnAST = tryBlock_AST; 5682 } 5683 5684 public final void forInit() throws RecognitionException, TokenStreamException { 5685 5686 returnAST = null; 5687 ASTPair currentAST = new ASTPair(); 5688 AST forInit_AST = null; 5689 5690 { 5691 boolean synPredMatched235 = false; 5692 if (((_tokenSet_51.member(LA(1))) && (_tokenSet_52.member(LA(2))))) { 5693 int _m235 = mark(); 5694 synPredMatched235 = true; 5695 inputState.guessing++; 5696 try { 5697 { 5698 declaration(); 5699 } 5700 } 5701 catch (RecognitionException pe) { 5702 synPredMatched235 = false; 5703 } 5704 rewind(_m235); 5705inputState.guessing--; 5706 } 5707 if ( synPredMatched235 ) { 5708 declaration(); 5709 astFactory.addASTChild(currentAST, returnAST); 5710 } 5711 else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_59.member(LA(2)))) { 5712 expressionList(); 5713 astFactory.addASTChild(currentAST, returnAST); 5714 } 5715 else if ((LA(1)==SEMI)) { 5716 } 5717 else { 5718 throw new NoViableAltException(LT(1), getFilename()); 5719 } 5720 5721 } 5722 if ( inputState.guessing==0 ) { 5723 forInit_AST = (AST)currentAST.root; 5724 forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_INIT,"FOR_INIT")).add(forInit_AST)); 5725 currentAST.root = forInit_AST; 5726 currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ? 5727 forInit_AST.getFirstChild() : forInit_AST; 5728 currentAST.advanceChildToEnd(); 5729 } 5730 forInit_AST = (AST)currentAST.root; 5731 returnAST = forInit_AST; 5732 } 5733 5734 public final void traditionalForClause() throws RecognitionException, TokenStreamException { 5735 5736 returnAST = null; 5737 ASTPair currentAST = new ASTPair(); 5738 AST traditionalForClause_AST = null; 5739 5740 forInit(); 5741 astFactory.addASTChild(currentAST, returnAST); 5742 AST tmp158_AST = null; 5743 tmp158_AST = astFactory.create(LT(1)); 5744 astFactory.addASTChild(currentAST, tmp158_AST); 5745 match(SEMI); 5746 forCond(); 5747 astFactory.addASTChild(currentAST, returnAST); 5748 AST tmp159_AST = null; 5749 tmp159_AST = astFactory.create(LT(1)); 5750 astFactory.addASTChild(currentAST, tmp159_AST); 5751 match(SEMI); 5752 forIter(); 5753 astFactory.addASTChild(currentAST, returnAST); 5754 traditionalForClause_AST = (AST)currentAST.root; 5755 returnAST = traditionalForClause_AST; 5756 } 5757 5758 public final void forEachClause() throws RecognitionException, TokenStreamException { 5759 5760 returnAST = null; 5761 ASTPair currentAST = new ASTPair(); 5762 AST forEachClause_AST = null; 5763 5764 forEachDeclarator(); 5765 astFactory.addASTChild(currentAST, returnAST); 5766 AST tmp160_AST = null; 5767 tmp160_AST = astFactory.create(LT(1)); 5768 astFactory.addASTChild(currentAST, tmp160_AST); 5769 match(COLON); 5770 expression(); 5771 astFactory.addASTChild(currentAST, returnAST); 5772 if ( inputState.guessing==0 ) { 5773 forEachClause_AST = (AST)currentAST.root; 5774 forEachClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_EACH_CLAUSE,"FOR_EACH_CLAUSE")).add(forEachClause_AST)); 5775 currentAST.root = forEachClause_AST; 5776 currentAST.child = forEachClause_AST!=null &&forEachClause_AST.getFirstChild()!=null ? 5777 forEachClause_AST.getFirstChild() : forEachClause_AST; 5778 currentAST.advanceChildToEnd(); 5779 } 5780 forEachClause_AST = (AST)currentAST.root; 5781 returnAST = forEachClause_AST; 5782 } 5783 5784 public final void forCond() throws RecognitionException, TokenStreamException { 5785 5786 returnAST = null; 5787 ASTPair currentAST = new ASTPair(); 5788 AST forCond_AST = null; 5789 5790 { 5791 switch ( LA(1)) { 5792 case LITERAL_void: 5793 case LITERAL_boolean: 5794 case LITERAL_byte: 5795 case LITERAL_char: 5796 case LITERAL_short: 5797 case LITERAL_int: 5798 case LITERAL_float: 5799 case LITERAL_long: 5800 case LITERAL_double: 5801 case IDENT: 5802 case LPAREN: 5803 case LITERAL_this: 5804 case LITERAL_super: 5805 case PLUS: 5806 case MINUS: 5807 case INC: 5808 case DEC: 5809 case BNOT: 5810 case LNOT: 5811 case LITERAL_true: 5812 case LITERAL_false: 5813 case LITERAL_null: 5814 case LITERAL_new: 5815 case NUM_INT: 5816 case CHAR_LITERAL: 5817 case STRING_LITERAL: 5818 case NUM_FLOAT: 5819 case NUM_LONG: 5820 case NUM_DOUBLE: 5821 { 5822 expression(); 5823 astFactory.addASTChild(currentAST, returnAST); 5824 break; 5825 } 5826 case SEMI: 5827 { 5828 break; 5829 } 5830 default: 5831 { 5832 throw new NoViableAltException(LT(1), getFilename()); 5833 } 5834 } 5835 } 5836 if ( inputState.guessing==0 ) { 5837 forCond_AST = (AST)currentAST.root; 5838 forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).add(forCond_AST)); 5839 currentAST.root = forCond_AST; 5840 currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ? 5841 forCond_AST.getFirstChild() : forCond_AST; 5842 currentAST.advanceChildToEnd(); 5843 } 5844 forCond_AST = (AST)currentAST.root; 5845 returnAST = forCond_AST; 5846 } 5847 5848 public final void forIter() throws RecognitionException, TokenStreamException { 5849 5850 returnAST = null; 5851 ASTPair currentAST = new ASTPair(); 5852 AST forIter_AST = null; 5853 5854 { 5855 switch ( LA(1)) { 5856 case LITERAL_void: 5857 case LITERAL_boolean: 5858 case LITERAL_byte: 5859 case LITERAL_char: 5860 case LITERAL_short: 5861 case LITERAL_int: 5862 case LITERAL_float: 5863 case LITERAL_long: 5864 case LITERAL_double: 5865 case IDENT: 5866 case LPAREN: 5867 case LITERAL_this: 5868 case LITERAL_super: 5869 case PLUS: 5870 case MINUS: 5871 case INC: 5872 case DEC: 5873 case BNOT: 5874 case LNOT: 5875 case LITERAL_true: 5876 case LITERAL_false: 5877 case LITERAL_null: 5878 case LITERAL_new: 5879 case NUM_INT: 5880 case CHAR_LITERAL: 5881 case STRING_LITERAL: 5882 case NUM_FLOAT: 5883 case NUM_LONG: 5884 case NUM_DOUBLE: 5885 { 5886 expressionList(); 5887 astFactory.addASTChild(currentAST, returnAST); 5888 break; 5889 } 5890 case RPAREN: 5891 { 5892 break; 5893 } 5894 default: 5895 { 5896 throw new NoViableAltException(LT(1), getFilename()); 5897 } 5898 } 5899 } 5900 if ( inputState.guessing==0 ) { 5901 forIter_AST = (AST)currentAST.root; 5902 forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).add(forIter_AST)); 5903 currentAST.root = forIter_AST; 5904 currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ? 5905 forIter_AST.getFirstChild() : forIter_AST; 5906 currentAST.advanceChildToEnd(); 5907 } 5908 forIter_AST = (AST)currentAST.root; 5909 returnAST = forIter_AST; 5910 } 5911 5912 public final void forEachDeclarator() throws RecognitionException, TokenStreamException { 5913 5914 returnAST = null; 5915 ASTPair currentAST = new ASTPair(); 5916 AST forEachDeclarator_AST = null; 5917 AST m_AST = null; 5918 AST t_AST = null; 5919 Token id = null; 5920 AST id_AST = null; 5921 AST d_AST = null; 5922 5923 modifiers(); 5924 m_AST = (AST)returnAST; 5925 typeSpec(false); 5926 t_AST = (AST)returnAST; 5927 id = LT(1); 5928 id_AST = astFactory.create(id); 5929 match(IDENT); 5930 declaratorBrackets(t_AST); 5931 d_AST = (AST)returnAST; 5932 if ( inputState.guessing==0 ) { 5933 forEachDeclarator_AST = (AST)currentAST.root; 5934 forEachDeclarator_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(m_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST)); 5935 currentAST.root = forEachDeclarator_AST; 5936 currentAST.child = forEachDeclarator_AST!=null &&forEachDeclarator_AST.getFirstChild()!=null ? 5937 forEachDeclarator_AST.getFirstChild() : forEachDeclarator_AST; 5938 currentAST.advanceChildToEnd(); 5939 } 5940 returnAST = forEachDeclarator_AST; 5941 } 5942 5943 public final void aCase() throws RecognitionException, TokenStreamException { 5944 5945 returnAST = null; 5946 ASTPair currentAST = new ASTPair(); 5947 AST aCase_AST = null; 5948 5949 { 5950 switch ( LA(1)) { 5951 case LITERAL_case: 5952 { 5953 AST tmp161_AST = null; 5954 tmp161_AST = astFactory.create(LT(1)); 5955 astFactory.makeASTRoot(currentAST, tmp161_AST); 5956 match(LITERAL_case); 5957 expression(); 5958 astFactory.addASTChild(currentAST, returnAST); 5959 break; 5960 } 5961 case LITERAL_default: 5962 { 5963 AST tmp162_AST = null; 5964 tmp162_AST = astFactory.create(LT(1)); 5965 astFactory.makeASTRoot(currentAST, tmp162_AST); 5966 match(LITERAL_default); 5967 break; 5968 } 5969 default: 5970 { 5971 throw new NoViableAltException(LT(1), getFilename()); 5972 } 5973 } 5974 } 5975 AST tmp163_AST = null; 5976 tmp163_AST = astFactory.create(LT(1)); 5977 astFactory.addASTChild(currentAST, tmp163_AST); 5978 match(COLON); 5979 aCase_AST = (AST)currentAST.root; 5980 returnAST = aCase_AST; 5981 } 5982 5983 public final void caseSList() throws RecognitionException, TokenStreamException { 5984 5985 returnAST = null; 5986 ASTPair currentAST = new ASTPair(); 5987 AST caseSList_AST = null; 5988 5989 { 5990 _loop231: 5991 do { 5992 if (((_tokenSet_36.member(LA(1))) && (_tokenSet_60.member(LA(2))))&&(LA(1)!=LITERAL_default)) { 5993 statement(); 5994 astFactory.addASTChild(currentAST, returnAST); 5995 } 5996 else { 5997 break _loop231; 5998 } 5999 6000 } while (true); 6001 } 6002 if ( inputState.guessing==0 ) { 6003 caseSList_AST = (AST)currentAST.root; 6004 caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).add(caseSList_AST)); 6005 currentAST.root = caseSList_AST; 6006 currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ? 6007 caseSList_AST.getFirstChild() : caseSList_AST; 6008 currentAST.advanceChildToEnd(); 6009 } 6010 caseSList_AST = (AST)currentAST.root; 6011 returnAST = caseSList_AST; 6012 } 6013 6014 public final void expressionList() throws RecognitionException, TokenStreamException { 6015 6016 returnAST = null; 6017 ASTPair currentAST = new ASTPair(); 6018 AST expressionList_AST = null; 6019 6020 expression(); 6021 astFactory.addASTChild(currentAST, returnAST); 6022 { 6023 _loop259: 6024 do { 6025 if ((LA(1)==COMMA)) { 6026 AST tmp164_AST = null; 6027 tmp164_AST = astFactory.create(LT(1)); 6028 astFactory.addASTChild(currentAST, tmp164_AST); 6029 match(COMMA); 6030 expression(); 6031 astFactory.addASTChild(currentAST, returnAST); 6032 } 6033 else { 6034 break _loop259; 6035 } 6036 6037 } while (true); 6038 } 6039 if ( inputState.guessing==0 ) { 6040 expressionList_AST = (AST)currentAST.root; 6041 expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).add(expressionList_AST)); 6042 currentAST.root = expressionList_AST; 6043 currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ? 6044 expressionList_AST.getFirstChild() : expressionList_AST; 6045 currentAST.advanceChildToEnd(); 6046 } 6047 expressionList_AST = (AST)currentAST.root; 6048 returnAST = expressionList_AST; 6049 } 6050 6051 public final void resourceSpecification() throws RecognitionException, TokenStreamException { 6052 6053 returnAST = null; 6054 ASTPair currentAST = new ASTPair(); 6055 AST resourceSpecification_AST = null; 6056 6057 AST tmp165_AST = null; 6058 tmp165_AST = astFactory.create(LT(1)); 6059 astFactory.addASTChild(currentAST, tmp165_AST); 6060 match(LPAREN); 6061 resources(); 6062 astFactory.addASTChild(currentAST, returnAST); 6063 { 6064 switch ( LA(1)) { 6065 case SEMI: 6066 { 6067 AST tmp166_AST = null; 6068 tmp166_AST = astFactory.create(LT(1)); 6069 astFactory.addASTChild(currentAST, tmp166_AST); 6070 match(SEMI); 6071 break; 6072 } 6073 case RPAREN: 6074 { 6075 break; 6076 } 6077 default: 6078 { 6079 throw new NoViableAltException(LT(1), getFilename()); 6080 } 6081 } 6082 } 6083 AST tmp167_AST = null; 6084 tmp167_AST = astFactory.create(LT(1)); 6085 astFactory.addASTChild(currentAST, tmp167_AST); 6086 match(RPAREN); 6087 if ( inputState.guessing==0 ) { 6088 resourceSpecification_AST = (AST)currentAST.root; 6089 resourceSpecification_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE_SPECIFICATION,"RESOURCE_SPECIFICATION")).add(resourceSpecification_AST)); 6090 currentAST.root = resourceSpecification_AST; 6091 currentAST.child = resourceSpecification_AST!=null &&resourceSpecification_AST.getFirstChild()!=null ? 6092 resourceSpecification_AST.getFirstChild() : resourceSpecification_AST; 6093 currentAST.advanceChildToEnd(); 6094 } 6095 resourceSpecification_AST = (AST)currentAST.root; 6096 returnAST = resourceSpecification_AST; 6097 } 6098 6099 public final void handler() throws RecognitionException, TokenStreamException { 6100 6101 returnAST = null; 6102 ASTPair currentAST = new ASTPair(); 6103 AST handler_AST = null; 6104 6105 AST tmp168_AST = null; 6106 tmp168_AST = astFactory.create(LT(1)); 6107 astFactory.makeASTRoot(currentAST, tmp168_AST); 6108 match(LITERAL_catch); 6109 AST tmp169_AST = null; 6110 tmp169_AST = astFactory.create(LT(1)); 6111 astFactory.addASTChild(currentAST, tmp169_AST); 6112 match(LPAREN); 6113 catchParameterDeclaration(); 6114 astFactory.addASTChild(currentAST, returnAST); 6115 AST tmp170_AST = null; 6116 tmp170_AST = astFactory.create(LT(1)); 6117 astFactory.addASTChild(currentAST, tmp170_AST); 6118 match(RPAREN); 6119 compoundStatement(); 6120 astFactory.addASTChild(currentAST, returnAST); 6121 handler_AST = (AST)currentAST.root; 6122 returnAST = handler_AST; 6123 } 6124 6125 public final void finallyHandler() throws RecognitionException, TokenStreamException { 6126 6127 returnAST = null; 6128 ASTPair currentAST = new ASTPair(); 6129 AST finallyHandler_AST = null; 6130 6131 AST tmp171_AST = null; 6132 tmp171_AST = astFactory.create(LT(1)); 6133 astFactory.makeASTRoot(currentAST, tmp171_AST); 6134 match(LITERAL_finally); 6135 compoundStatement(); 6136 astFactory.addASTChild(currentAST, returnAST); 6137 finallyHandler_AST = (AST)currentAST.root; 6138 returnAST = finallyHandler_AST; 6139 } 6140 6141 public final void resources() throws RecognitionException, TokenStreamException { 6142 6143 returnAST = null; 6144 ASTPair currentAST = new ASTPair(); 6145 AST resources_AST = null; 6146 6147 resource(); 6148 astFactory.addASTChild(currentAST, returnAST); 6149 { 6150 _loop249: 6151 do { 6152 if ((LA(1)==SEMI) && (_tokenSet_51.member(LA(2)))) { 6153 AST tmp172_AST = null; 6154 tmp172_AST = astFactory.create(LT(1)); 6155 astFactory.addASTChild(currentAST, tmp172_AST); 6156 match(SEMI); 6157 resource(); 6158 astFactory.addASTChild(currentAST, returnAST); 6159 } 6160 else { 6161 break _loop249; 6162 } 6163 6164 } while (true); 6165 } 6166 if ( inputState.guessing==0 ) { 6167 resources_AST = (AST)currentAST.root; 6168 resources_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCES,"RESOURCES")).add(resources_AST)); 6169 currentAST.root = resources_AST; 6170 currentAST.child = resources_AST!=null &&resources_AST.getFirstChild()!=null ? 6171 resources_AST.getFirstChild() : resources_AST; 6172 currentAST.advanceChildToEnd(); 6173 } 6174 resources_AST = (AST)currentAST.root; 6175 returnAST = resources_AST; 6176 } 6177 6178 public final void resource() throws RecognitionException, TokenStreamException { 6179 6180 returnAST = null; 6181 ASTPair currentAST = new ASTPair(); 6182 AST resource_AST = null; 6183 6184 modifiers(); 6185 astFactory.addASTChild(currentAST, returnAST); 6186 typeSpec(true); 6187 astFactory.addASTChild(currentAST, returnAST); 6188 AST tmp173_AST = null; 6189 tmp173_AST = astFactory.create(LT(1)); 6190 astFactory.addASTChild(currentAST, tmp173_AST); 6191 match(IDENT); 6192 resource_assign(); 6193 astFactory.addASTChild(currentAST, returnAST); 6194 if ( inputState.guessing==0 ) { 6195 resource_AST = (AST)currentAST.root; 6196 resource_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RESOURCE,"RESOURCE")).add(resource_AST)); 6197 currentAST.root = resource_AST; 6198 currentAST.child = resource_AST!=null &&resource_AST.getFirstChild()!=null ? 6199 resource_AST.getFirstChild() : resource_AST; 6200 currentAST.advanceChildToEnd(); 6201 } 6202 resource_AST = (AST)currentAST.root; 6203 returnAST = resource_AST; 6204 } 6205 6206 public final void resource_assign() throws RecognitionException, TokenStreamException { 6207 6208 returnAST = null; 6209 ASTPair currentAST = new ASTPair(); 6210 AST resource_assign_AST = null; 6211 6212 AST tmp174_AST = null; 6213 tmp174_AST = astFactory.create(LT(1)); 6214 astFactory.makeASTRoot(currentAST, tmp174_AST); 6215 match(ASSIGN); 6216 expression(); 6217 astFactory.addASTChild(currentAST, returnAST); 6218 resource_assign_AST = (AST)currentAST.root; 6219 returnAST = resource_assign_AST; 6220 } 6221 6222 public final void lambdaExpression() throws RecognitionException, TokenStreamException { 6223 6224 returnAST = null; 6225 ASTPair currentAST = new ASTPair(); 6226 AST lambdaExpression_AST = null; 6227 6228 lambdaParameters(); 6229 astFactory.addASTChild(currentAST, returnAST); 6230 AST tmp175_AST = null; 6231 tmp175_AST = astFactory.create(LT(1)); 6232 astFactory.makeASTRoot(currentAST, tmp175_AST); 6233 match(LAMBDA); 6234 lambdaBody(); 6235 astFactory.addASTChild(currentAST, returnAST); 6236 lambdaExpression_AST = (AST)currentAST.root; 6237 returnAST = lambdaExpression_AST; 6238 } 6239 6240 public final void assignmentExpression() throws RecognitionException, TokenStreamException { 6241 6242 returnAST = null; 6243 ASTPair currentAST = new ASTPair(); 6244 AST assignmentExpression_AST = null; 6245 6246 conditionalExpression(); 6247 astFactory.addASTChild(currentAST, returnAST); 6248 { 6249 switch ( LA(1)) { 6250 case ASSIGN: 6251 case PLUS_ASSIGN: 6252 case MINUS_ASSIGN: 6253 case STAR_ASSIGN: 6254 case DIV_ASSIGN: 6255 case MOD_ASSIGN: 6256 case SR_ASSIGN: 6257 case BSR_ASSIGN: 6258 case SL_ASSIGN: 6259 case BAND_ASSIGN: 6260 case BXOR_ASSIGN: 6261 case BOR_ASSIGN: 6262 { 6263 { 6264 switch ( LA(1)) { 6265 case ASSIGN: 6266 { 6267 AST tmp176_AST = null; 6268 tmp176_AST = astFactory.create(LT(1)); 6269 astFactory.makeASTRoot(currentAST, tmp176_AST); 6270 match(ASSIGN); 6271 break; 6272 } 6273 case PLUS_ASSIGN: 6274 { 6275 AST tmp177_AST = null; 6276 tmp177_AST = astFactory.create(LT(1)); 6277 astFactory.makeASTRoot(currentAST, tmp177_AST); 6278 match(PLUS_ASSIGN); 6279 break; 6280 } 6281 case MINUS_ASSIGN: 6282 { 6283 AST tmp178_AST = null; 6284 tmp178_AST = astFactory.create(LT(1)); 6285 astFactory.makeASTRoot(currentAST, tmp178_AST); 6286 match(MINUS_ASSIGN); 6287 break; 6288 } 6289 case STAR_ASSIGN: 6290 { 6291 AST tmp179_AST = null; 6292 tmp179_AST = astFactory.create(LT(1)); 6293 astFactory.makeASTRoot(currentAST, tmp179_AST); 6294 match(STAR_ASSIGN); 6295 break; 6296 } 6297 case DIV_ASSIGN: 6298 { 6299 AST tmp180_AST = null; 6300 tmp180_AST = astFactory.create(LT(1)); 6301 astFactory.makeASTRoot(currentAST, tmp180_AST); 6302 match(DIV_ASSIGN); 6303 break; 6304 } 6305 case MOD_ASSIGN: 6306 { 6307 AST tmp181_AST = null; 6308 tmp181_AST = astFactory.create(LT(1)); 6309 astFactory.makeASTRoot(currentAST, tmp181_AST); 6310 match(MOD_ASSIGN); 6311 break; 6312 } 6313 case SR_ASSIGN: 6314 { 6315 AST tmp182_AST = null; 6316 tmp182_AST = astFactory.create(LT(1)); 6317 astFactory.makeASTRoot(currentAST, tmp182_AST); 6318 match(SR_ASSIGN); 6319 break; 6320 } 6321 case BSR_ASSIGN: 6322 { 6323 AST tmp183_AST = null; 6324 tmp183_AST = astFactory.create(LT(1)); 6325 astFactory.makeASTRoot(currentAST, tmp183_AST); 6326 match(BSR_ASSIGN); 6327 break; 6328 } 6329 case SL_ASSIGN: 6330 { 6331 AST tmp184_AST = null; 6332 tmp184_AST = astFactory.create(LT(1)); 6333 astFactory.makeASTRoot(currentAST, tmp184_AST); 6334 match(SL_ASSIGN); 6335 break; 6336 } 6337 case BAND_ASSIGN: 6338 { 6339 AST tmp185_AST = null; 6340 tmp185_AST = astFactory.create(LT(1)); 6341 astFactory.makeASTRoot(currentAST, tmp185_AST); 6342 match(BAND_ASSIGN); 6343 break; 6344 } 6345 case BXOR_ASSIGN: 6346 { 6347 AST tmp186_AST = null; 6348 tmp186_AST = astFactory.create(LT(1)); 6349 astFactory.makeASTRoot(currentAST, tmp186_AST); 6350 match(BXOR_ASSIGN); 6351 break; 6352 } 6353 case BOR_ASSIGN: 6354 { 6355 AST tmp187_AST = null; 6356 tmp187_AST = astFactory.create(LT(1)); 6357 astFactory.makeASTRoot(currentAST, tmp187_AST); 6358 match(BOR_ASSIGN); 6359 break; 6360 } 6361 default: 6362 { 6363 throw new NoViableAltException(LT(1), getFilename()); 6364 } 6365 } 6366 } 6367 { 6368 boolean synPredMatched265 = false; 6369 if (((LA(1)==IDENT||LA(1)==LPAREN) && (_tokenSet_15.member(LA(2))))) { 6370 int _m265 = mark(); 6371 synPredMatched265 = true; 6372 inputState.guessing++; 6373 try { 6374 { 6375 lambdaExpression(); 6376 } 6377 } 6378 catch (RecognitionException pe) { 6379 synPredMatched265 = false; 6380 } 6381 rewind(_m265); 6382inputState.guessing--; 6383 } 6384 if ( synPredMatched265 ) { 6385 lambdaExpression(); 6386 astFactory.addASTChild(currentAST, returnAST); 6387 } 6388 else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { 6389 assignmentExpression(); 6390 astFactory.addASTChild(currentAST, returnAST); 6391 } 6392 else { 6393 throw new NoViableAltException(LT(1), getFilename()); 6394 } 6395 6396 } 6397 break; 6398 } 6399 case FINAL: 6400 case ABSTRACT: 6401 case STRICTFP: 6402 case SEMI: 6403 case RBRACK: 6404 case LITERAL_void: 6405 case LITERAL_boolean: 6406 case LITERAL_byte: 6407 case LITERAL_char: 6408 case LITERAL_short: 6409 case LITERAL_int: 6410 case LITERAL_float: 6411 case LITERAL_long: 6412 case LITERAL_double: 6413 case IDENT: 6414 case LITERAL_private: 6415 case LITERAL_public: 6416 case LITERAL_protected: 6417 case LITERAL_static: 6418 case LITERAL_transient: 6419 case LITERAL_native: 6420 case LITERAL_synchronized: 6421 case LITERAL_volatile: 6422 case LITERAL_class: 6423 case LITERAL_interface: 6424 case LCURLY: 6425 case RCURLY: 6426 case COMMA: 6427 case LPAREN: 6428 case RPAREN: 6429 case LITERAL_this: 6430 case LITERAL_super: 6431 case COLON: 6432 case LITERAL_if: 6433 case LITERAL_while: 6434 case LITERAL_do: 6435 case LITERAL_break: 6436 case LITERAL_continue: 6437 case LITERAL_return: 6438 case LITERAL_switch: 6439 case LITERAL_throw: 6440 case LITERAL_for: 6441 case LITERAL_else: 6442 case LITERAL_case: 6443 case LITERAL_default: 6444 case LITERAL_try: 6445 case LT: 6446 case PLUS: 6447 case MINUS: 6448 case INC: 6449 case DEC: 6450 case BNOT: 6451 case LNOT: 6452 case LITERAL_true: 6453 case LITERAL_false: 6454 case LITERAL_null: 6455 case LITERAL_new: 6456 case NUM_INT: 6457 case CHAR_LITERAL: 6458 case STRING_LITERAL: 6459 case NUM_FLOAT: 6460 case NUM_LONG: 6461 case NUM_DOUBLE: 6462 case ASSERT: 6463 case ENUM: 6464 case AT: 6465 { 6466 break; 6467 } 6468 default: 6469 { 6470 throw new NoViableAltException(LT(1), getFilename()); 6471 } 6472 } 6473 } 6474 assignmentExpression_AST = (AST)currentAST.root; 6475 returnAST = assignmentExpression_AST; 6476 } 6477 6478 public final void logicalOrExpression() throws RecognitionException, TokenStreamException { 6479 6480 returnAST = null; 6481 ASTPair currentAST = new ASTPair(); 6482 AST logicalOrExpression_AST = null; 6483 6484 logicalAndExpression(); 6485 astFactory.addASTChild(currentAST, returnAST); 6486 { 6487 _loop276: 6488 do { 6489 if ((LA(1)==LOR)) { 6490 AST tmp188_AST = null; 6491 tmp188_AST = astFactory.create(LT(1)); 6492 astFactory.makeASTRoot(currentAST, tmp188_AST); 6493 match(LOR); 6494 logicalAndExpression(); 6495 astFactory.addASTChild(currentAST, returnAST); 6496 } 6497 else { 6498 break _loop276; 6499 } 6500 6501 } while (true); 6502 } 6503 logicalOrExpression_AST = (AST)currentAST.root; 6504 returnAST = logicalOrExpression_AST; 6505 } 6506 6507 public final void logicalAndExpression() throws RecognitionException, TokenStreamException { 6508 6509 returnAST = null; 6510 ASTPair currentAST = new ASTPair(); 6511 AST logicalAndExpression_AST = null; 6512 6513 inclusiveOrExpression(); 6514 astFactory.addASTChild(currentAST, returnAST); 6515 { 6516 _loop279: 6517 do { 6518 if ((LA(1)==LAND)) { 6519 AST tmp189_AST = null; 6520 tmp189_AST = astFactory.create(LT(1)); 6521 astFactory.makeASTRoot(currentAST, tmp189_AST); 6522 match(LAND); 6523 inclusiveOrExpression(); 6524 astFactory.addASTChild(currentAST, returnAST); 6525 } 6526 else { 6527 break _loop279; 6528 } 6529 6530 } while (true); 6531 } 6532 logicalAndExpression_AST = (AST)currentAST.root; 6533 returnAST = logicalAndExpression_AST; 6534 } 6535 6536 public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException { 6537 6538 returnAST = null; 6539 ASTPair currentAST = new ASTPair(); 6540 AST inclusiveOrExpression_AST = null; 6541 6542 exclusiveOrExpression(); 6543 astFactory.addASTChild(currentAST, returnAST); 6544 { 6545 _loop282: 6546 do { 6547 if ((LA(1)==BOR)) { 6548 AST tmp190_AST = null; 6549 tmp190_AST = astFactory.create(LT(1)); 6550 astFactory.makeASTRoot(currentAST, tmp190_AST); 6551 match(BOR); 6552 exclusiveOrExpression(); 6553 astFactory.addASTChild(currentAST, returnAST); 6554 } 6555 else { 6556 break _loop282; 6557 } 6558 6559 } while (true); 6560 } 6561 inclusiveOrExpression_AST = (AST)currentAST.root; 6562 returnAST = inclusiveOrExpression_AST; 6563 } 6564 6565 public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException { 6566 6567 returnAST = null; 6568 ASTPair currentAST = new ASTPair(); 6569 AST exclusiveOrExpression_AST = null; 6570 6571 andExpression(); 6572 astFactory.addASTChild(currentAST, returnAST); 6573 { 6574 _loop285: 6575 do { 6576 if ((LA(1)==BXOR)) { 6577 AST tmp191_AST = null; 6578 tmp191_AST = astFactory.create(LT(1)); 6579 astFactory.makeASTRoot(currentAST, tmp191_AST); 6580 match(BXOR); 6581 andExpression(); 6582 astFactory.addASTChild(currentAST, returnAST); 6583 } 6584 else { 6585 break _loop285; 6586 } 6587 6588 } while (true); 6589 } 6590 exclusiveOrExpression_AST = (AST)currentAST.root; 6591 returnAST = exclusiveOrExpression_AST; 6592 } 6593 6594 public final void andExpression() throws RecognitionException, TokenStreamException { 6595 6596 returnAST = null; 6597 ASTPair currentAST = new ASTPair(); 6598 AST andExpression_AST = null; 6599 6600 equalityExpression(); 6601 astFactory.addASTChild(currentAST, returnAST); 6602 { 6603 _loop288: 6604 do { 6605 if ((LA(1)==BAND)) { 6606 AST tmp192_AST = null; 6607 tmp192_AST = astFactory.create(LT(1)); 6608 astFactory.makeASTRoot(currentAST, tmp192_AST); 6609 match(BAND); 6610 equalityExpression(); 6611 astFactory.addASTChild(currentAST, returnAST); 6612 } 6613 else { 6614 break _loop288; 6615 } 6616 6617 } while (true); 6618 } 6619 andExpression_AST = (AST)currentAST.root; 6620 returnAST = andExpression_AST; 6621 } 6622 6623 public final void equalityExpression() throws RecognitionException, TokenStreamException { 6624 6625 returnAST = null; 6626 ASTPair currentAST = new ASTPair(); 6627 AST equalityExpression_AST = null; 6628 6629 relationalExpression(); 6630 astFactory.addASTChild(currentAST, returnAST); 6631 { 6632 _loop292: 6633 do { 6634 if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) { 6635 { 6636 switch ( LA(1)) { 6637 case NOT_EQUAL: 6638 { 6639 AST tmp193_AST = null; 6640 tmp193_AST = astFactory.create(LT(1)); 6641 astFactory.makeASTRoot(currentAST, tmp193_AST); 6642 match(NOT_EQUAL); 6643 break; 6644 } 6645 case EQUAL: 6646 { 6647 AST tmp194_AST = null; 6648 tmp194_AST = astFactory.create(LT(1)); 6649 astFactory.makeASTRoot(currentAST, tmp194_AST); 6650 match(EQUAL); 6651 break; 6652 } 6653 default: 6654 { 6655 throw new NoViableAltException(LT(1), getFilename()); 6656 } 6657 } 6658 } 6659 relationalExpression(); 6660 astFactory.addASTChild(currentAST, returnAST); 6661 } 6662 else { 6663 break _loop292; 6664 } 6665 6666 } while (true); 6667 } 6668 equalityExpression_AST = (AST)currentAST.root; 6669 returnAST = equalityExpression_AST; 6670 } 6671 6672 public final void relationalExpression() throws RecognitionException, TokenStreamException { 6673 6674 returnAST = null; 6675 ASTPair currentAST = new ASTPair(); 6676 AST relationalExpression_AST = null; 6677 6678 shiftExpression(); 6679 astFactory.addASTChild(currentAST, returnAST); 6680 { 6681 switch ( LA(1)) { 6682 case LITERAL_instanceof: 6683 { 6684 AST tmp195_AST = null; 6685 tmp195_AST = astFactory.create(LT(1)); 6686 astFactory.makeASTRoot(currentAST, tmp195_AST); 6687 match(LITERAL_instanceof); 6688 typeSpec(true); 6689 astFactory.addASTChild(currentAST, returnAST); 6690 break; 6691 } 6692 case FINAL: 6693 case ABSTRACT: 6694 case STRICTFP: 6695 case SEMI: 6696 case RBRACK: 6697 case LITERAL_void: 6698 case LITERAL_boolean: 6699 case LITERAL_byte: 6700 case LITERAL_char: 6701 case LITERAL_short: 6702 case LITERAL_int: 6703 case LITERAL_float: 6704 case LITERAL_long: 6705 case LITERAL_double: 6706 case IDENT: 6707 case LITERAL_private: 6708 case LITERAL_public: 6709 case LITERAL_protected: 6710 case LITERAL_static: 6711 case LITERAL_transient: 6712 case LITERAL_native: 6713 case LITERAL_synchronized: 6714 case LITERAL_volatile: 6715 case LITERAL_class: 6716 case LITERAL_interface: 6717 case LCURLY: 6718 case RCURLY: 6719 case COMMA: 6720 case LPAREN: 6721 case RPAREN: 6722 case LITERAL_this: 6723 case LITERAL_super: 6724 case ASSIGN: 6725 case COLON: 6726 case LITERAL_if: 6727 case LITERAL_while: 6728 case LITERAL_do: 6729 case LITERAL_break: 6730 case LITERAL_continue: 6731 case LITERAL_return: 6732 case LITERAL_switch: 6733 case LITERAL_throw: 6734 case LITERAL_for: 6735 case LITERAL_else: 6736 case LITERAL_case: 6737 case LITERAL_default: 6738 case LITERAL_try: 6739 case PLUS_ASSIGN: 6740 case MINUS_ASSIGN: 6741 case STAR_ASSIGN: 6742 case DIV_ASSIGN: 6743 case MOD_ASSIGN: 6744 case SR_ASSIGN: 6745 case BSR_ASSIGN: 6746 case SL_ASSIGN: 6747 case BAND_ASSIGN: 6748 case BXOR_ASSIGN: 6749 case BOR_ASSIGN: 6750 case QUESTION: 6751 case LOR: 6752 case LAND: 6753 case BOR: 6754 case BXOR: 6755 case BAND: 6756 case NOT_EQUAL: 6757 case EQUAL: 6758 case LT: 6759 case GT: 6760 case LE: 6761 case GE: 6762 case PLUS: 6763 case MINUS: 6764 case INC: 6765 case DEC: 6766 case BNOT: 6767 case LNOT: 6768 case LITERAL_true: 6769 case LITERAL_false: 6770 case LITERAL_null: 6771 case LITERAL_new: 6772 case NUM_INT: 6773 case CHAR_LITERAL: 6774 case STRING_LITERAL: 6775 case NUM_FLOAT: 6776 case NUM_LONG: 6777 case NUM_DOUBLE: 6778 case ASSERT: 6779 case ENUM: 6780 case AT: 6781 { 6782 break; 6783 } 6784 default: 6785 { 6786 throw new NoViableAltException(LT(1), getFilename()); 6787 } 6788 } 6789 } 6790 { 6791 { 6792 _loop298: 6793 do { 6794 if (((LA(1) >= LT && LA(1) <= GE)) && (_tokenSet_16.member(LA(2)))) { 6795 { 6796 switch ( LA(1)) { 6797 case LT: 6798 { 6799 AST tmp196_AST = null; 6800 tmp196_AST = astFactory.create(LT(1)); 6801 astFactory.makeASTRoot(currentAST, tmp196_AST); 6802 match(LT); 6803 break; 6804 } 6805 case GT: 6806 { 6807 AST tmp197_AST = null; 6808 tmp197_AST = astFactory.create(LT(1)); 6809 astFactory.makeASTRoot(currentAST, tmp197_AST); 6810 match(GT); 6811 break; 6812 } 6813 case LE: 6814 { 6815 AST tmp198_AST = null; 6816 tmp198_AST = astFactory.create(LT(1)); 6817 astFactory.makeASTRoot(currentAST, tmp198_AST); 6818 match(LE); 6819 break; 6820 } 6821 case GE: 6822 { 6823 AST tmp199_AST = null; 6824 tmp199_AST = astFactory.create(LT(1)); 6825 astFactory.makeASTRoot(currentAST, tmp199_AST); 6826 match(GE); 6827 break; 6828 } 6829 default: 6830 { 6831 throw new NoViableAltException(LT(1), getFilename()); 6832 } 6833 } 6834 } 6835 shiftExpression(); 6836 astFactory.addASTChild(currentAST, returnAST); 6837 } 6838 else { 6839 break _loop298; 6840 } 6841 6842 } while (true); 6843 } 6844 } 6845 relationalExpression_AST = (AST)currentAST.root; 6846 returnAST = relationalExpression_AST; 6847 } 6848 6849 public final void shiftExpression() throws RecognitionException, TokenStreamException { 6850 6851 returnAST = null; 6852 ASTPair currentAST = new ASTPair(); 6853 AST shiftExpression_AST = null; 6854 6855 additiveExpression(); 6856 astFactory.addASTChild(currentAST, returnAST); 6857 { 6858 _loop302: 6859 do { 6860 if (((LA(1) >= SL && LA(1) <= BSR))) { 6861 { 6862 switch ( LA(1)) { 6863 case SL: 6864 { 6865 AST tmp200_AST = null; 6866 tmp200_AST = astFactory.create(LT(1)); 6867 astFactory.makeASTRoot(currentAST, tmp200_AST); 6868 match(SL); 6869 break; 6870 } 6871 case SR: 6872 { 6873 AST tmp201_AST = null; 6874 tmp201_AST = astFactory.create(LT(1)); 6875 astFactory.makeASTRoot(currentAST, tmp201_AST); 6876 match(SR); 6877 break; 6878 } 6879 case BSR: 6880 { 6881 AST tmp202_AST = null; 6882 tmp202_AST = astFactory.create(LT(1)); 6883 astFactory.makeASTRoot(currentAST, tmp202_AST); 6884 match(BSR); 6885 break; 6886 } 6887 default: 6888 { 6889 throw new NoViableAltException(LT(1), getFilename()); 6890 } 6891 } 6892 } 6893 additiveExpression(); 6894 astFactory.addASTChild(currentAST, returnAST); 6895 } 6896 else { 6897 break _loop302; 6898 } 6899 6900 } while (true); 6901 } 6902 shiftExpression_AST = (AST)currentAST.root; 6903 returnAST = shiftExpression_AST; 6904 } 6905 6906 public final void additiveExpression() throws RecognitionException, TokenStreamException { 6907 6908 returnAST = null; 6909 ASTPair currentAST = new ASTPair(); 6910 AST additiveExpression_AST = null; 6911 6912 multiplicativeExpression(); 6913 astFactory.addASTChild(currentAST, returnAST); 6914 { 6915 _loop306: 6916 do { 6917 if ((LA(1)==PLUS||LA(1)==MINUS) && (_tokenSet_16.member(LA(2)))) { 6918 { 6919 switch ( LA(1)) { 6920 case PLUS: 6921 { 6922 AST tmp203_AST = null; 6923 tmp203_AST = astFactory.create(LT(1)); 6924 astFactory.makeASTRoot(currentAST, tmp203_AST); 6925 match(PLUS); 6926 break; 6927 } 6928 case MINUS: 6929 { 6930 AST tmp204_AST = null; 6931 tmp204_AST = astFactory.create(LT(1)); 6932 astFactory.makeASTRoot(currentAST, tmp204_AST); 6933 match(MINUS); 6934 break; 6935 } 6936 default: 6937 { 6938 throw new NoViableAltException(LT(1), getFilename()); 6939 } 6940 } 6941 } 6942 multiplicativeExpression(); 6943 astFactory.addASTChild(currentAST, returnAST); 6944 } 6945 else { 6946 break _loop306; 6947 } 6948 6949 } while (true); 6950 } 6951 additiveExpression_AST = (AST)currentAST.root; 6952 returnAST = additiveExpression_AST; 6953 } 6954 6955 public final void multiplicativeExpression() throws RecognitionException, TokenStreamException { 6956 6957 returnAST = null; 6958 ASTPair currentAST = new ASTPair(); 6959 AST multiplicativeExpression_AST = null; 6960 6961 unaryExpression(); 6962 astFactory.addASTChild(currentAST, returnAST); 6963 { 6964 _loop310: 6965 do { 6966 if ((_tokenSet_61.member(LA(1)))) { 6967 { 6968 switch ( LA(1)) { 6969 case STAR: 6970 { 6971 AST tmp205_AST = null; 6972 tmp205_AST = astFactory.create(LT(1)); 6973 astFactory.makeASTRoot(currentAST, tmp205_AST); 6974 match(STAR); 6975 break; 6976 } 6977 case DIV: 6978 { 6979 AST tmp206_AST = null; 6980 tmp206_AST = astFactory.create(LT(1)); 6981 astFactory.makeASTRoot(currentAST, tmp206_AST); 6982 match(DIV); 6983 break; 6984 } 6985 case MOD: 6986 { 6987 AST tmp207_AST = null; 6988 tmp207_AST = astFactory.create(LT(1)); 6989 astFactory.makeASTRoot(currentAST, tmp207_AST); 6990 match(MOD); 6991 break; 6992 } 6993 default: 6994 { 6995 throw new NoViableAltException(LT(1), getFilename()); 6996 } 6997 } 6998 } 6999 unaryExpression(); 7000 astFactory.addASTChild(currentAST, returnAST); 7001 } 7002 else { 7003 break _loop310; 7004 } 7005 7006 } while (true); 7007 } 7008 multiplicativeExpression_AST = (AST)currentAST.root; 7009 returnAST = multiplicativeExpression_AST; 7010 } 7011 7012 public final void unaryExpression() throws RecognitionException, TokenStreamException { 7013 7014 returnAST = null; 7015 ASTPair currentAST = new ASTPair(); 7016 AST unaryExpression_AST = null; 7017 7018 switch ( LA(1)) { 7019 case INC: 7020 { 7021 AST tmp208_AST = null; 7022 tmp208_AST = astFactory.create(LT(1)); 7023 astFactory.makeASTRoot(currentAST, tmp208_AST); 7024 match(INC); 7025 unaryExpression(); 7026 astFactory.addASTChild(currentAST, returnAST); 7027 unaryExpression_AST = (AST)currentAST.root; 7028 break; 7029 } 7030 case DEC: 7031 { 7032 AST tmp209_AST = null; 7033 tmp209_AST = astFactory.create(LT(1)); 7034 astFactory.makeASTRoot(currentAST, tmp209_AST); 7035 match(DEC); 7036 unaryExpression(); 7037 astFactory.addASTChild(currentAST, returnAST); 7038 unaryExpression_AST = (AST)currentAST.root; 7039 break; 7040 } 7041 case MINUS: 7042 { 7043 AST tmp210_AST = null; 7044 tmp210_AST = astFactory.create(LT(1)); 7045 astFactory.makeASTRoot(currentAST, tmp210_AST); 7046 match(MINUS); 7047 if ( inputState.guessing==0 ) { 7048 tmp210_AST.setType(UNARY_MINUS); 7049 } 7050 unaryExpression(); 7051 astFactory.addASTChild(currentAST, returnAST); 7052 unaryExpression_AST = (AST)currentAST.root; 7053 break; 7054 } 7055 case PLUS: 7056 { 7057 AST tmp211_AST = null; 7058 tmp211_AST = astFactory.create(LT(1)); 7059 astFactory.makeASTRoot(currentAST, tmp211_AST); 7060 match(PLUS); 7061 if ( inputState.guessing==0 ) { 7062 tmp211_AST.setType(UNARY_PLUS); 7063 } 7064 unaryExpression(); 7065 astFactory.addASTChild(currentAST, returnAST); 7066 unaryExpression_AST = (AST)currentAST.root; 7067 break; 7068 } 7069 case LITERAL_void: 7070 case LITERAL_boolean: 7071 case LITERAL_byte: 7072 case LITERAL_char: 7073 case LITERAL_short: 7074 case LITERAL_int: 7075 case LITERAL_float: 7076 case LITERAL_long: 7077 case LITERAL_double: 7078 case IDENT: 7079 case LPAREN: 7080 case LITERAL_this: 7081 case LITERAL_super: 7082 case BNOT: 7083 case LNOT: 7084 case LITERAL_true: 7085 case LITERAL_false: 7086 case LITERAL_null: 7087 case LITERAL_new: 7088 case NUM_INT: 7089 case CHAR_LITERAL: 7090 case STRING_LITERAL: 7091 case NUM_FLOAT: 7092 case NUM_LONG: 7093 case NUM_DOUBLE: 7094 { 7095 unaryExpressionNotPlusMinus(); 7096 astFactory.addASTChild(currentAST, returnAST); 7097 unaryExpression_AST = (AST)currentAST.root; 7098 break; 7099 } 7100 default: 7101 { 7102 throw new NoViableAltException(LT(1), getFilename()); 7103 } 7104 } 7105 returnAST = unaryExpression_AST; 7106 } 7107 7108 public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException { 7109 7110 returnAST = null; 7111 ASTPair currentAST = new ASTPair(); 7112 AST unaryExpressionNotPlusMinus_AST = null; 7113 Token lpb = null; 7114 AST lpb_AST = null; 7115 Token lp = null; 7116 AST lp_AST = null; 7117 Token lpl = null; 7118 AST lpl_AST = null; 7119 7120 switch ( LA(1)) { 7121 case BNOT: 7122 { 7123 AST tmp212_AST = null; 7124 tmp212_AST = astFactory.create(LT(1)); 7125 astFactory.makeASTRoot(currentAST, tmp212_AST); 7126 match(BNOT); 7127 unaryExpression(); 7128 astFactory.addASTChild(currentAST, returnAST); 7129 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 7130 break; 7131 } 7132 case LNOT: 7133 { 7134 AST tmp213_AST = null; 7135 tmp213_AST = astFactory.create(LT(1)); 7136 astFactory.makeASTRoot(currentAST, tmp213_AST); 7137 match(LNOT); 7138 unaryExpression(); 7139 astFactory.addASTChild(currentAST, returnAST); 7140 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 7141 break; 7142 } 7143 case LITERAL_void: 7144 case LITERAL_boolean: 7145 case LITERAL_byte: 7146 case LITERAL_char: 7147 case LITERAL_short: 7148 case LITERAL_int: 7149 case LITERAL_float: 7150 case LITERAL_long: 7151 case LITERAL_double: 7152 case IDENT: 7153 case LPAREN: 7154 case LITERAL_this: 7155 case LITERAL_super: 7156 case LITERAL_true: 7157 case LITERAL_false: 7158 case LITERAL_null: 7159 case LITERAL_new: 7160 case NUM_INT: 7161 case CHAR_LITERAL: 7162 case STRING_LITERAL: 7163 case NUM_FLOAT: 7164 case NUM_LONG: 7165 case NUM_DOUBLE: 7166 { 7167 { 7168 boolean synPredMatched315 = false; 7169 if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) { 7170 int _m315 = mark(); 7171 synPredMatched315 = true; 7172 inputState.guessing++; 7173 try { 7174 { 7175 match(LPAREN); 7176 builtInTypeSpec(true); 7177 match(RPAREN); 7178 unaryExpression(); 7179 } 7180 } 7181 catch (RecognitionException pe) { 7182 synPredMatched315 = false; 7183 } 7184 rewind(_m315); 7185inputState.guessing--; 7186 } 7187 if ( synPredMatched315 ) { 7188 lpb = LT(1); 7189 lpb_AST = astFactory.create(lpb); 7190 astFactory.makeASTRoot(currentAST, lpb_AST); 7191 match(LPAREN); 7192 if ( inputState.guessing==0 ) { 7193 lpb_AST.setType(TYPECAST); 7194 } 7195 builtInTypeSpec(true); 7196 astFactory.addASTChild(currentAST, returnAST); 7197 AST tmp214_AST = null; 7198 tmp214_AST = astFactory.create(LT(1)); 7199 astFactory.addASTChild(currentAST, tmp214_AST); 7200 match(RPAREN); 7201 unaryExpression(); 7202 astFactory.addASTChild(currentAST, returnAST); 7203 } 7204 else { 7205 boolean synPredMatched317 = false; 7206 if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) { 7207 int _m317 = mark(); 7208 synPredMatched317 = true; 7209 inputState.guessing++; 7210 try { 7211 { 7212 match(LPAREN); 7213 typeCastParameters(); 7214 match(RPAREN); 7215 unaryExpressionNotPlusMinus(); 7216 } 7217 } 7218 catch (RecognitionException pe) { 7219 synPredMatched317 = false; 7220 } 7221 rewind(_m317); 7222inputState.guessing--; 7223 } 7224 if ( synPredMatched317 ) { 7225 lp = LT(1); 7226 lp_AST = astFactory.create(lp); 7227 astFactory.makeASTRoot(currentAST, lp_AST); 7228 match(LPAREN); 7229 if ( inputState.guessing==0 ) { 7230 lp_AST.setType(TYPECAST); 7231 } 7232 typeCastParameters(); 7233 astFactory.addASTChild(currentAST, returnAST); 7234 AST tmp215_AST = null; 7235 tmp215_AST = astFactory.create(LT(1)); 7236 astFactory.addASTChild(currentAST, tmp215_AST); 7237 match(RPAREN); 7238 unaryExpressionNotPlusMinus(); 7239 astFactory.addASTChild(currentAST, returnAST); 7240 } 7241 else { 7242 boolean synPredMatched319 = false; 7243 if (((LA(1)==LPAREN) && (LA(2)==IDENT||LA(2)==AT))) { 7244 int _m319 = mark(); 7245 synPredMatched319 = true; 7246 inputState.guessing++; 7247 try { 7248 { 7249 match(LPAREN); 7250 typeCastParameters(); 7251 match(RPAREN); 7252 lambdaExpression(); 7253 } 7254 } 7255 catch (RecognitionException pe) { 7256 synPredMatched319 = false; 7257 } 7258 rewind(_m319); 7259inputState.guessing--; 7260 } 7261 if ( synPredMatched319 ) { 7262 lpl = LT(1); 7263 lpl_AST = astFactory.create(lpl); 7264 astFactory.makeASTRoot(currentAST, lpl_AST); 7265 match(LPAREN); 7266 if ( inputState.guessing==0 ) { 7267 lpl_AST.setType(TYPECAST); 7268 } 7269 typeCastParameters(); 7270 astFactory.addASTChild(currentAST, returnAST); 7271 AST tmp216_AST = null; 7272 tmp216_AST = astFactory.create(LT(1)); 7273 astFactory.addASTChild(currentAST, tmp216_AST); 7274 match(RPAREN); 7275 lambdaExpression(); 7276 astFactory.addASTChild(currentAST, returnAST); 7277 } 7278 else if ((_tokenSet_43.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { 7279 postfixExpression(); 7280 astFactory.addASTChild(currentAST, returnAST); 7281 } 7282 else { 7283 throw new NoViableAltException(LT(1), getFilename()); 7284 } 7285 }} 7286 } 7287 unaryExpressionNotPlusMinus_AST = (AST)currentAST.root; 7288 break; 7289 } 7290 default: 7291 { 7292 throw new NoViableAltException(LT(1), getFilename()); 7293 } 7294 } 7295 returnAST = unaryExpressionNotPlusMinus_AST; 7296 } 7297 7298 public final void typeCastParameters() throws RecognitionException, TokenStreamException { 7299 7300 returnAST = null; 7301 ASTPair currentAST = new ASTPair(); 7302 AST typeCastParameters_AST = null; 7303 7304 classTypeSpec(true); 7305 astFactory.addASTChild(currentAST, returnAST); 7306 { 7307 _loop322: 7308 do { 7309 if ((LA(1)==BAND)) { 7310 AST tmp217_AST = null; 7311 tmp217_AST = astFactory.create(LT(1)); 7312 astFactory.makeASTRoot(currentAST, tmp217_AST); 7313 match(BAND); 7314 classTypeSpec(true); 7315 astFactory.addASTChild(currentAST, returnAST); 7316 } 7317 else { 7318 break _loop322; 7319 } 7320 7321 } while (true); 7322 } 7323 typeCastParameters_AST = (AST)currentAST.root; 7324 returnAST = typeCastParameters_AST; 7325 } 7326 7327 public final void postfixExpression() throws RecognitionException, TokenStreamException { 7328 7329 returnAST = null; 7330 ASTPair currentAST = new ASTPair(); 7331 AST postfixExpression_AST = null; 7332 Token dc = null; 7333 AST dc_AST = null; 7334 Token lbc = null; 7335 AST lbc_AST = null; 7336 Token lb = null; 7337 AST lb_AST = null; 7338 Token lp = null; 7339 AST lp_AST = null; 7340 Token in = null; 7341 AST in_AST = null; 7342 Token de = null; 7343 AST de_AST = null; 7344 7345 primaryExpression(); 7346 astFactory.addASTChild(currentAST, returnAST); 7347 { 7348 _loop334: 7349 do { 7350 switch ( LA(1)) { 7351 case DOT: 7352 { 7353 AST tmp218_AST = null; 7354 tmp218_AST = astFactory.create(LT(1)); 7355 astFactory.makeASTRoot(currentAST, tmp218_AST); 7356 match(DOT); 7357 { 7358 if ((_tokenSet_62.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { 7359 { 7360 switch ( LA(1)) { 7361 case LT: 7362 { 7363 typeArguments(false); 7364 astFactory.addASTChild(currentAST, returnAST); 7365 break; 7366 } 7367 case IDENT: 7368 case LITERAL_this: 7369 case LITERAL_super: 7370 { 7371 break; 7372 } 7373 default: 7374 { 7375 throw new NoViableAltException(LT(1), getFilename()); 7376 } 7377 } 7378 } 7379 { 7380 switch ( LA(1)) { 7381 case IDENT: 7382 { 7383 AST tmp219_AST = null; 7384 tmp219_AST = astFactory.create(LT(1)); 7385 astFactory.addASTChild(currentAST, tmp219_AST); 7386 match(IDENT); 7387 break; 7388 } 7389 case LITERAL_this: 7390 { 7391 AST tmp220_AST = null; 7392 tmp220_AST = astFactory.create(LT(1)); 7393 astFactory.addASTChild(currentAST, tmp220_AST); 7394 match(LITERAL_this); 7395 break; 7396 } 7397 case LITERAL_super: 7398 { 7399 AST tmp221_AST = null; 7400 tmp221_AST = astFactory.create(LT(1)); 7401 astFactory.addASTChild(currentAST, tmp221_AST); 7402 match(LITERAL_super); 7403 break; 7404 } 7405 default: 7406 { 7407 throw new NoViableAltException(LT(1), getFilename()); 7408 } 7409 } 7410 } 7411 } 7412 else if ((LA(1)==LITERAL_class) && (_tokenSet_18.member(LA(2)))) { 7413 AST tmp222_AST = null; 7414 tmp222_AST = astFactory.create(LT(1)); 7415 astFactory.addASTChild(currentAST, tmp222_AST); 7416 match(LITERAL_class); 7417 } 7418 else if ((LA(1)==LITERAL_new) && (_tokenSet_26.member(LA(2)))) { 7419 newExpression(); 7420 astFactory.addASTChild(currentAST, returnAST); 7421 } 7422 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 7423 annotations(); 7424 astFactory.addASTChild(currentAST, returnAST); 7425 } 7426 else { 7427 throw new NoViableAltException(LT(1), getFilename()); 7428 } 7429 7430 } 7431 break; 7432 } 7433 case DOUBLE_COLON: 7434 { 7435 dc = LT(1); 7436 dc_AST = astFactory.create(dc); 7437 astFactory.makeASTRoot(currentAST, dc_AST); 7438 match(DOUBLE_COLON); 7439 if ( inputState.guessing==0 ) { 7440 dc_AST.setType(METHOD_REF); 7441 } 7442 { 7443 { 7444 switch ( LA(1)) { 7445 case LT: 7446 { 7447 typeArguments(false); 7448 astFactory.addASTChild(currentAST, returnAST); 7449 break; 7450 } 7451 case IDENT: 7452 case LITERAL_new: 7453 { 7454 break; 7455 } 7456 default: 7457 { 7458 throw new NoViableAltException(LT(1), getFilename()); 7459 } 7460 } 7461 } 7462 { 7463 switch ( LA(1)) { 7464 case IDENT: 7465 { 7466 AST tmp223_AST = null; 7467 tmp223_AST = astFactory.create(LT(1)); 7468 astFactory.addASTChild(currentAST, tmp223_AST); 7469 match(IDENT); 7470 break; 7471 } 7472 case LITERAL_new: 7473 { 7474 AST tmp224_AST = null; 7475 tmp224_AST = astFactory.create(LT(1)); 7476 astFactory.addASTChild(currentAST, tmp224_AST); 7477 match(LITERAL_new); 7478 break; 7479 } 7480 default: 7481 { 7482 throw new NoViableAltException(LT(1), getFilename()); 7483 } 7484 } 7485 } 7486 } 7487 break; 7488 } 7489 default: 7490 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 7491 { 7492 int _cnt332=0; 7493 _loop332: 7494 do { 7495 if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) { 7496 lbc = LT(1); 7497 lbc_AST = astFactory.create(lbc); 7498 astFactory.makeASTRoot(currentAST, lbc_AST); 7499 match(LBRACK); 7500 if ( inputState.guessing==0 ) { 7501 lbc_AST.setType(ARRAY_DECLARATOR); 7502 } 7503 AST tmp225_AST = null; 7504 tmp225_AST = astFactory.create(LT(1)); 7505 astFactory.addASTChild(currentAST, tmp225_AST); 7506 match(RBRACK); 7507 } 7508 else { 7509 if ( _cnt332>=1 ) { break _loop332; } else {throw new NoViableAltException(LT(1), getFilename());} 7510 } 7511 7512 _cnt332++; 7513 } while (true); 7514 } 7515 { 7516 if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) { 7517 AST tmp226_AST = null; 7518 tmp226_AST = astFactory.create(LT(1)); 7519 astFactory.makeASTRoot(currentAST, tmp226_AST); 7520 match(DOT); 7521 AST tmp227_AST = null; 7522 tmp227_AST = astFactory.create(LT(1)); 7523 astFactory.addASTChild(currentAST, tmp227_AST); 7524 match(LITERAL_class); 7525 } 7526 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 7527 } 7528 else { 7529 throw new NoViableAltException(LT(1), getFilename()); 7530 } 7531 7532 } 7533 } 7534 else if ((LA(1)==LBRACK) && (_tokenSet_16.member(LA(2)))) { 7535 lb = LT(1); 7536 lb_AST = astFactory.create(lb); 7537 astFactory.makeASTRoot(currentAST, lb_AST); 7538 match(LBRACK); 7539 if ( inputState.guessing==0 ) { 7540 lb_AST.setType(INDEX_OP); 7541 } 7542 expression(); 7543 astFactory.addASTChild(currentAST, returnAST); 7544 AST tmp228_AST = null; 7545 tmp228_AST = astFactory.create(LT(1)); 7546 astFactory.addASTChild(currentAST, tmp228_AST); 7547 match(RBRACK); 7548 } 7549 else if ((LA(1)==LPAREN) && (_tokenSet_63.member(LA(2)))) { 7550 lp = LT(1); 7551 lp_AST = astFactory.create(lp); 7552 astFactory.makeASTRoot(currentAST, lp_AST); 7553 match(LPAREN); 7554 if ( inputState.guessing==0 ) { 7555 lp_AST.setType(METHOD_CALL); 7556 } 7557 argList(); 7558 astFactory.addASTChild(currentAST, returnAST); 7559 AST tmp229_AST = null; 7560 tmp229_AST = astFactory.create(LT(1)); 7561 astFactory.addASTChild(currentAST, tmp229_AST); 7562 match(RPAREN); 7563 } 7564 else { 7565 break _loop334; 7566 } 7567 } 7568 } while (true); 7569 } 7570 { 7571 if ((LA(1)==INC) && (_tokenSet_64.member(LA(2)))) { 7572 in = LT(1); 7573 in_AST = astFactory.create(in); 7574 astFactory.makeASTRoot(currentAST, in_AST); 7575 match(INC); 7576 if ( inputState.guessing==0 ) { 7577 in_AST.setType(POST_INC); 7578 } 7579 } 7580 else if ((LA(1)==DEC) && (_tokenSet_64.member(LA(2)))) { 7581 de = LT(1); 7582 de_AST = astFactory.create(de); 7583 astFactory.makeASTRoot(currentAST, de_AST); 7584 match(DEC); 7585 if ( inputState.guessing==0 ) { 7586 de_AST.setType(POST_DEC); 7587 } 7588 } 7589 else if ((_tokenSet_64.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 7590 } 7591 else { 7592 throw new NoViableAltException(LT(1), getFilename()); 7593 } 7594 7595 } 7596 postfixExpression_AST = (AST)currentAST.root; 7597 returnAST = postfixExpression_AST; 7598 } 7599 7600/** object instantiation. 7601 * Trees are built as illustrated by the following input/tree pairs: 7602 * 7603 * new T() 7604 * 7605 * new 7606 * | 7607 * T -- ELIST 7608 * | 7609 * arg1 -- arg2 -- .. -- argn 7610 * 7611 * new int[] 7612 * 7613 * new 7614 * | 7615 * int -- ARRAY_DECLARATOR 7616 * 7617 * new int[] {1,2} 7618 * 7619 * new 7620 * | 7621 * int -- ARRAY_DECLARATOR -- ARRAY_INIT 7622 * | 7623 * EXPR -- EXPR 7624 * | | 7625 * 1 2 7626 * 7627 * new int[3] 7628 * new 7629 * | 7630 * int -- ARRAY_DECLARATOR 7631 * | 7632 * EXPR 7633 * | 7634 * 3 7635 * 7636 * new int[1][2] 7637 * 7638 * new 7639 * | 7640 * int -- ARRAY_DECLARATOR 7641 * | 7642 * ARRAY_DECLARATOR -- EXPR 7643 * | | 7644 * EXPR 1 7645 * | 7646 * 2 7647 * 7648 */ 7649 public final void newExpression() throws RecognitionException, TokenStreamException { 7650 7651 returnAST = null; 7652 ASTPair currentAST = new ASTPair(); 7653 AST newExpression_AST = null; 7654 7655 AST tmp230_AST = null; 7656 tmp230_AST = astFactory.create(LT(1)); 7657 astFactory.makeASTRoot(currentAST, tmp230_AST); 7658 match(LITERAL_new); 7659 { 7660 switch ( LA(1)) { 7661 case LT: 7662 { 7663 typeArguments(false); 7664 astFactory.addASTChild(currentAST, returnAST); 7665 break; 7666 } 7667 case LITERAL_void: 7668 case LITERAL_boolean: 7669 case LITERAL_byte: 7670 case LITERAL_char: 7671 case LITERAL_short: 7672 case LITERAL_int: 7673 case LITERAL_float: 7674 case LITERAL_long: 7675 case LITERAL_double: 7676 case IDENT: 7677 case AT: 7678 { 7679 break; 7680 } 7681 default: 7682 { 7683 throw new NoViableAltException(LT(1), getFilename()); 7684 } 7685 } 7686 } 7687 type(); 7688 astFactory.addASTChild(currentAST, returnAST); 7689 { 7690 switch ( LA(1)) { 7691 case LPAREN: 7692 { 7693 AST tmp231_AST = null; 7694 tmp231_AST = astFactory.create(LT(1)); 7695 astFactory.addASTChild(currentAST, tmp231_AST); 7696 match(LPAREN); 7697 argList(); 7698 astFactory.addASTChild(currentAST, returnAST); 7699 AST tmp232_AST = null; 7700 tmp232_AST = astFactory.create(LT(1)); 7701 astFactory.addASTChild(currentAST, tmp232_AST); 7702 match(RPAREN); 7703 { 7704 if ((LA(1)==LCURLY) && (_tokenSet_29.member(LA(2)))) { 7705 classBlock(); 7706 astFactory.addASTChild(currentAST, returnAST); 7707 } 7708 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 7709 } 7710 else { 7711 throw new NoViableAltException(LT(1), getFilename()); 7712 } 7713 7714 } 7715 break; 7716 } 7717 case LBRACK: 7718 { 7719 newArrayDeclarator(); 7720 astFactory.addASTChild(currentAST, returnAST); 7721 { 7722 if ((LA(1)==LCURLY) && (_tokenSet_65.member(LA(2)))) { 7723 arrayInitializer(); 7724 astFactory.addASTChild(currentAST, returnAST); 7725 } 7726 else if ((_tokenSet_18.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 7727 } 7728 else { 7729 throw new NoViableAltException(LT(1), getFilename()); 7730 } 7731 7732 } 7733 break; 7734 } 7735 default: 7736 { 7737 throw new NoViableAltException(LT(1), getFilename()); 7738 } 7739 } 7740 } 7741 newExpression_AST = (AST)currentAST.root; 7742 returnAST = newExpression_AST; 7743 } 7744 7745 public final void constant() throws RecognitionException, TokenStreamException { 7746 7747 returnAST = null; 7748 ASTPair currentAST = new ASTPair(); 7749 AST constant_AST = null; 7750 7751 switch ( LA(1)) { 7752 case NUM_INT: 7753 { 7754 AST tmp233_AST = null; 7755 tmp233_AST = astFactory.create(LT(1)); 7756 astFactory.addASTChild(currentAST, tmp233_AST); 7757 match(NUM_INT); 7758 constant_AST = (AST)currentAST.root; 7759 break; 7760 } 7761 case NUM_LONG: 7762 { 7763 AST tmp234_AST = null; 7764 tmp234_AST = astFactory.create(LT(1)); 7765 astFactory.addASTChild(currentAST, tmp234_AST); 7766 match(NUM_LONG); 7767 constant_AST = (AST)currentAST.root; 7768 break; 7769 } 7770 case NUM_FLOAT: 7771 { 7772 AST tmp235_AST = null; 7773 tmp235_AST = astFactory.create(LT(1)); 7774 astFactory.addASTChild(currentAST, tmp235_AST); 7775 match(NUM_FLOAT); 7776 constant_AST = (AST)currentAST.root; 7777 break; 7778 } 7779 case NUM_DOUBLE: 7780 { 7781 AST tmp236_AST = null; 7782 tmp236_AST = astFactory.create(LT(1)); 7783 astFactory.addASTChild(currentAST, tmp236_AST); 7784 match(NUM_DOUBLE); 7785 constant_AST = (AST)currentAST.root; 7786 break; 7787 } 7788 case CHAR_LITERAL: 7789 { 7790 AST tmp237_AST = null; 7791 tmp237_AST = astFactory.create(LT(1)); 7792 astFactory.addASTChild(currentAST, tmp237_AST); 7793 match(CHAR_LITERAL); 7794 constant_AST = (AST)currentAST.root; 7795 break; 7796 } 7797 case STRING_LITERAL: 7798 { 7799 AST tmp238_AST = null; 7800 tmp238_AST = astFactory.create(LT(1)); 7801 astFactory.addASTChild(currentAST, tmp238_AST); 7802 match(STRING_LITERAL); 7803 constant_AST = (AST)currentAST.root; 7804 break; 7805 } 7806 default: 7807 { 7808 throw new NoViableAltException(LT(1), getFilename()); 7809 } 7810 } 7811 returnAST = constant_AST; 7812 } 7813 7814 public final void newArrayDeclarator() throws RecognitionException, TokenStreamException { 7815 7816 returnAST = null; 7817 ASTPair currentAST = new ASTPair(); 7818 AST newArrayDeclarator_AST = null; 7819 Token lb = null; 7820 AST lb_AST = null; 7821 7822 { 7823 int _cnt356=0; 7824 _loop356: 7825 do { 7826 if ((LA(1)==LBRACK) && (_tokenSet_66.member(LA(2)))) { 7827 lb = LT(1); 7828 lb_AST = astFactory.create(lb); 7829 astFactory.makeASTRoot(currentAST, lb_AST); 7830 match(LBRACK); 7831 if ( inputState.guessing==0 ) { 7832 lb_AST.setType(ARRAY_DECLARATOR); 7833 } 7834 { 7835 switch ( LA(1)) { 7836 case LITERAL_void: 7837 case LITERAL_boolean: 7838 case LITERAL_byte: 7839 case LITERAL_char: 7840 case LITERAL_short: 7841 case LITERAL_int: 7842 case LITERAL_float: 7843 case LITERAL_long: 7844 case LITERAL_double: 7845 case IDENT: 7846 case LPAREN: 7847 case LITERAL_this: 7848 case LITERAL_super: 7849 case PLUS: 7850 case MINUS: 7851 case INC: 7852 case DEC: 7853 case BNOT: 7854 case LNOT: 7855 case LITERAL_true: 7856 case LITERAL_false: 7857 case LITERAL_null: 7858 case LITERAL_new: 7859 case NUM_INT: 7860 case CHAR_LITERAL: 7861 case STRING_LITERAL: 7862 case NUM_FLOAT: 7863 case NUM_LONG: 7864 case NUM_DOUBLE: 7865 { 7866 expression(); 7867 astFactory.addASTChild(currentAST, returnAST); 7868 break; 7869 } 7870 case RBRACK: 7871 { 7872 break; 7873 } 7874 default: 7875 { 7876 throw new NoViableAltException(LT(1), getFilename()); 7877 } 7878 } 7879 } 7880 AST tmp239_AST = null; 7881 tmp239_AST = astFactory.create(LT(1)); 7882 astFactory.addASTChild(currentAST, tmp239_AST); 7883 match(RBRACK); 7884 } 7885 else { 7886 if ( _cnt356>=1 ) { break _loop356; } else {throw new NoViableAltException(LT(1), getFilename());} 7887 } 7888 7889 _cnt356++; 7890 } while (true); 7891 } 7892 newArrayDeclarator_AST = (AST)currentAST.root; 7893 returnAST = newArrayDeclarator_AST; 7894 } 7895 7896 public final void lambdaParameters() throws RecognitionException, TokenStreamException { 7897 7898 returnAST = null; 7899 ASTPair currentAST = new ASTPair(); 7900 AST lambdaParameters_AST = null; 7901 7902 if ((LA(1)==IDENT)) { 7903 AST tmp240_AST = null; 7904 tmp240_AST = astFactory.create(LT(1)); 7905 astFactory.addASTChild(currentAST, tmp240_AST); 7906 match(IDENT); 7907 lambdaParameters_AST = (AST)currentAST.root; 7908 } 7909 else if ((LA(1)==LPAREN) && (_tokenSet_67.member(LA(2)))) { 7910 AST tmp241_AST = null; 7911 tmp241_AST = astFactory.create(LT(1)); 7912 astFactory.addASTChild(currentAST, tmp241_AST); 7913 match(LPAREN); 7914 { 7915 if ((_tokenSet_67.member(LA(1))) && (_tokenSet_68.member(LA(2)))) { 7916 parameterDeclarationList(); 7917 astFactory.addASTChild(currentAST, returnAST); 7918 } 7919 else if ((LA(1)==RPAREN) && (LA(2)==LAMBDA)) { 7920 } 7921 else { 7922 throw new NoViableAltException(LT(1), getFilename()); 7923 } 7924 7925 } 7926 AST tmp242_AST = null; 7927 tmp242_AST = astFactory.create(LT(1)); 7928 astFactory.addASTChild(currentAST, tmp242_AST); 7929 match(RPAREN); 7930 lambdaParameters_AST = (AST)currentAST.root; 7931 } 7932 else if ((LA(1)==LPAREN) && (LA(2)==IDENT)) { 7933 AST tmp243_AST = null; 7934 tmp243_AST = astFactory.create(LT(1)); 7935 astFactory.addASTChild(currentAST, tmp243_AST); 7936 match(LPAREN); 7937 inferredParameterList(); 7938 astFactory.addASTChild(currentAST, returnAST); 7939 AST tmp244_AST = null; 7940 tmp244_AST = astFactory.create(LT(1)); 7941 astFactory.addASTChild(currentAST, tmp244_AST); 7942 match(RPAREN); 7943 lambdaParameters_AST = (AST)currentAST.root; 7944 } 7945 else { 7946 throw new NoViableAltException(LT(1), getFilename()); 7947 } 7948 7949 returnAST = lambdaParameters_AST; 7950 } 7951 7952 public final void lambdaBody() throws RecognitionException, TokenStreamException { 7953 7954 returnAST = null; 7955 ASTPair currentAST = new ASTPair(); 7956 AST lambdaBody_AST = null; 7957 7958 { 7959 if ((_tokenSet_16.member(LA(1))) && (_tokenSet_69.member(LA(2)))) { 7960 expression(); 7961 astFactory.addASTChild(currentAST, returnAST); 7962 } 7963 else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_69.member(LA(2)))) { 7964 statement(); 7965 astFactory.addASTChild(currentAST, returnAST); 7966 } 7967 else { 7968 throw new NoViableAltException(LT(1), getFilename()); 7969 } 7970 7971 } 7972 lambdaBody_AST = (AST)currentAST.root; 7973 returnAST = lambdaBody_AST; 7974 } 7975 7976 public final void inferredParameterList() throws RecognitionException, TokenStreamException { 7977 7978 returnAST = null; 7979 ASTPair currentAST = new ASTPair(); 7980 AST inferredParameterList_AST = null; 7981 7982 AST tmp245_AST = null; 7983 tmp245_AST = astFactory.create(LT(1)); 7984 astFactory.addASTChild(currentAST, tmp245_AST); 7985 match(IDENT); 7986 { 7987 _loop365: 7988 do { 7989 if ((LA(1)==COMMA)) { 7990 AST tmp246_AST = null; 7991 tmp246_AST = astFactory.create(LT(1)); 7992 astFactory.addASTChild(currentAST, tmp246_AST); 7993 match(COMMA); 7994 AST tmp247_AST = null; 7995 tmp247_AST = astFactory.create(LT(1)); 7996 astFactory.addASTChild(currentAST, tmp247_AST); 7997 match(IDENT); 7998 } 7999 else { 8000 break _loop365; 8001 } 8002 8003 } while (true); 8004 } 8005 inferredParameterList_AST = (AST)currentAST.root; 8006 returnAST = inferredParameterList_AST; 8007 } 8008 8009 8010 public static final String[] _tokenNames = { 8011 "<0>", 8012 "EOF", 8013 "<2>", 8014 "NULL_TREE_LOOKAHEAD", 8015 "BLOCK", 8016 "MODIFIERS", 8017 "OBJBLOCK", 8018 "SLIST", 8019 "CTOR_DEF", 8020 "METHOD_DEF", 8021 "VARIABLE_DEF", 8022 "INSTANCE_INIT", 8023 "STATIC_INIT", 8024 "TYPE", 8025 "CLASS_DEF", 8026 "INTERFACE_DEF", 8027 "PACKAGE_DEF", 8028 "ARRAY_DECLARATOR", 8029 "EXTENDS_CLAUSE", 8030 "IMPLEMENTS_CLAUSE", 8031 "PARAMETERS", 8032 "PARAMETER_DEF", 8033 "LABELED_STAT", 8034 "TYPECAST", 8035 "INDEX_OP", 8036 "POST_INC", 8037 "POST_DEC", 8038 "METHOD_CALL", 8039 "METHOD_REF", 8040 "EXPR", 8041 "ARRAY_INIT", 8042 "IMPORT", 8043 "UNARY_MINUS", 8044 "UNARY_PLUS", 8045 "CASE_GROUP", 8046 "ELIST", 8047 "FOR_INIT", 8048 "FOR_CONDITION", 8049 "FOR_ITERATOR", 8050 "EMPTY_STAT", 8051 "\"final\"", 8052 "\"abstract\"", 8053 "\"strictfp\"", 8054 "SUPER_CTOR_CALL", 8055 "CTOR_CALL", 8056 "\"package\"", 8057 "SEMI", 8058 "\"import\"", 8059 "LBRACK", 8060 "RBRACK", 8061 "\"void\"", 8062 "\"boolean\"", 8063 "\"byte\"", 8064 "\"char\"", 8065 "\"short\"", 8066 "\"int\"", 8067 "\"float\"", 8068 "\"long\"", 8069 "\"double\"", 8070 "IDENT", 8071 "DOT", 8072 "STAR", 8073 "\"private\"", 8074 "\"public\"", 8075 "\"protected\"", 8076 "\"static\"", 8077 "\"transient\"", 8078 "\"native\"", 8079 "\"synchronized\"", 8080 "\"volatile\"", 8081 "\"class\"", 8082 "\"extends\"", 8083 "\"interface\"", 8084 "LCURLY", 8085 "RCURLY", 8086 "COMMA", 8087 "\"implements\"", 8088 "LPAREN", 8089 "RPAREN", 8090 "\"this\"", 8091 "\"super\"", 8092 "ASSIGN", 8093 "\"throws\"", 8094 "COLON", 8095 "DOUBLE_COLON", 8096 "\"if\"", 8097 "\"while\"", 8098 "\"do\"", 8099 "\"break\"", 8100 "\"continue\"", 8101 "\"return\"", 8102 "\"switch\"", 8103 "\"throw\"", 8104 "\"for\"", 8105 "\"else\"", 8106 "\"case\"", 8107 "\"default\"", 8108 "\"try\"", 8109 "\"catch\"", 8110 "\"finally\"", 8111 "PLUS_ASSIGN", 8112 "MINUS_ASSIGN", 8113 "STAR_ASSIGN", 8114 "DIV_ASSIGN", 8115 "MOD_ASSIGN", 8116 "SR_ASSIGN", 8117 "BSR_ASSIGN", 8118 "SL_ASSIGN", 8119 "BAND_ASSIGN", 8120 "BXOR_ASSIGN", 8121 "BOR_ASSIGN", 8122 "QUESTION", 8123 "LOR", 8124 "LAND", 8125 "BOR", 8126 "BXOR", 8127 "BAND", 8128 "NOT_EQUAL", 8129 "EQUAL", 8130 "LT", 8131 "GT", 8132 "LE", 8133 "GE", 8134 "\"instanceof\"", 8135 "SL", 8136 "SR", 8137 "BSR", 8138 "PLUS", 8139 "MINUS", 8140 "DIV", 8141 "MOD", 8142 "INC", 8143 "DEC", 8144 "BNOT", 8145 "LNOT", 8146 "\"true\"", 8147 "\"false\"", 8148 "\"null\"", 8149 "\"new\"", 8150 "NUM_INT", 8151 "CHAR_LITERAL", 8152 "STRING_LITERAL", 8153 "NUM_FLOAT", 8154 "NUM_LONG", 8155 "NUM_DOUBLE", 8156 "WS", 8157 "SL_COMMENT", 8158 "ML_COMMENT", 8159 "ESC", 8160 "HEX_DIGIT", 8161 "VOCAB", 8162 "EXPONENT", 8163 "FLOAT_SUFFIX", 8164 "ASSERT", 8165 "STATIC_IMPORT", 8166 "ENUM", 8167 "ENUM_DEF", 8168 "ENUM_CONSTANT_DEF", 8169 "FOR_EACH_CLAUSE", 8170 "ANNOTATION_DEF", 8171 "ANNOTATIONS", 8172 "ANNOTATION", 8173 "ANNOTATION_MEMBER_VALUE_PAIR", 8174 "ANNOTATION_FIELD_DEF", 8175 "ANNOTATION_ARRAY_INIT", 8176 "TYPE_ARGUMENTS", 8177 "TYPE_ARGUMENT", 8178 "TYPE_PARAMETERS", 8179 "TYPE_PARAMETER", 8180 "WILDCARD_TYPE", 8181 "TYPE_UPPER_BOUNDS", 8182 "TYPE_LOWER_BOUNDS", 8183 "AT", 8184 "ELLIPSIS", 8185 "GENERIC_START", 8186 "GENERIC_END", 8187 "TYPE_EXTENSION_AND", 8188 "DO_WHILE", 8189 "RESOURCE_SPECIFICATION", 8190 "RESOURCES", 8191 "RESOURCE", 8192 "LAMBDA", 8193 "STD_ESC", 8194 "BINARY_DIGIT", 8195 "ID_START", 8196 "ID_PART", 8197 "INT_LITERAL", 8198 "LONG_LITERAL", 8199 "FLOAT_LITERAL", 8200 "DOUBLE_LITERAL", 8201 "HEX_FLOAT_LITERAL", 8202 "HEX_DOUBLE_LITERAL", 8203 "SIGNED_INTEGER", 8204 "BINARY_EXPONENT" 8205 }; 8206 8207 protected void buildTokenTypeASTClassMap() { 8208 tokenTypeToASTClassMap=null; 8209 }; 8210 8211 private static final long[] mk_tokenSet_0() { 8212 long[] data = { -4611467215613460478L, 4294967679L, 17592320262144L, 0L, 0L, 0L}; 8213 return data; 8214 } 8215 public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0()); 8216 private static final long[] mk_tokenSet_1() { 8217 long[] data = { -4035006463310036990L, 4294967679L, 17592320262144L, 0L, 0L, 0L}; 8218 return data; 8219 } 8220 public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1()); 8221 private static final long[] mk_tokenSet_2() { 8222 long[] data = { -4611607953101815808L, 4294967679L, 17592320262144L, 0L, 0L, 0L}; 8223 return data; 8224 } 8225 public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2()); 8226 private static final long[] mk_tokenSet_3() { 8227 long[] data = { -4611607953101815806L, 4294967679L, 17592320262144L, 0L, 0L, 0L}; 8228 return data; 8229 } 8230 public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3()); 8231 private static final long[] mk_tokenSet_4() { 8232 long[] data = { -4611678321845993472L, 4294967359L, 0L, 0L}; 8233 return data; 8234 } 8235 public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4()); 8236 private static final long[] mk_tokenSet_5() { 8237 long[] data = { -203409651138560L, -51539869697L, 52776726036479L, 0L, 0L, 0L}; 8238 return data; 8239 } 8240 public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5()); 8241 private static final long[] mk_tokenSet_6() { 8242 long[] data = { -168225279049726L, -262145L, 9059975980777471L, 0L, 0L, 0L}; 8243 return data; 8244 } 8245 public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6()); 8246 private static final long[] mk_tokenSet_7() { 8247 long[] data = { 1151795604700004352L, 140737488355328L, 17592186044416L, 0L, 0L, 0L}; 8248 return data; 8249 } 8250 public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7()); 8251 private static final long[] mk_tokenSet_8() { 8252 long[] data = { 0L, 6989586621679009792L, 0L, 0L}; 8253 return data; 8254 } 8255 public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8()); 8256 private static final long[] mk_tokenSet_9() { 8257 long[] data = { 1151795604700004352L, 0L, 17592186044416L, 0L, 0L, 0L}; 8258 return data; 8259 } 8260 public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9()); 8261 private static final long[] mk_tokenSet_10() { 8262 long[] data = { 1151795604700004352L, -9223372036854652416L, 17592186175481L, 0L, 0L, 0L}; 8263 return data; 8264 } 8265 public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10()); 8266 private static final long[] mk_tokenSet_11() { 8267 long[] data = { -168225279049728L, -51539873921L, 17592353947647L, 0L, 0L, 0L}; 8268 return data; 8269 } 8270 public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11()); 8271 private static final long[] mk_tokenSet_12() { 8272 long[] data = { 1151795604700004352L, -9223372036854668800L, 17592186175481L, 0L, 0L, 0L}; 8273 return data; 8274 } 8275 public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12()); 8276 private static final long[] mk_tokenSet_13() { 8277 long[] data = { 4610841593497255936L, -140737487182848L, 17592186175487L, 0L, 0L, 0L}; 8278 return data; 8279 } 8280 public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13()); 8281 private static final long[] mk_tokenSet_14() { 8282 long[] data = { 1151795604700004352L, -9223372036854669312L, 17592186175481L, 0L, 0L, 0L}; 8283 return data; 8284 } 8285 public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14()); 8286 private static final long[] mk_tokenSet_15() { 8287 long[] data = { 1151796704211632128L, 16384L, 9024791440785408L, 0L, 0L, 0L}; 8288 return data; 8289 } 8290 public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15()); 8291 private static final long[] mk_tokenSet_16() { 8292 long[] data = { 1151795604700004352L, -9223372036854669312L, 131065L, 0L, 0L, 0L}; 8293 return data; 8294 } 8295 public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16()); 8296 private static final long[] mk_tokenSet_17() { 8297 long[] data = { 4610841593497255936L, -68717666304L, 17592186175487L, 0L, 0L, 0L}; 8298 return data; 8299 } 8300 public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17()); 8301 private static final long[] mk_tokenSet_18() { 8302 long[] data = { -203409651138560L, -51539873921L, 17592353947647L, 0L, 0L, 0L}; 8303 return data; 8304 } 8305 public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18()); 8306 private static final long[] mk_tokenSet_19() { 8307 long[] data = { 1151795604700004352L, 6989586621679016576L, 17592186044416L, 0L, 0L, 0L}; 8308 return data; 8309 } 8310 public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19()); 8311 private static final long[] mk_tokenSet_20() { 8312 long[] data = { -2306609368818253824L, 36028801313945599L, 17592320262144L, 0L, 0L, 0L}; 8313 return data; 8314 } 8315 public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20()); 8316 private static final long[] mk_tokenSet_21() { 8317 long[] data = { 0L, 320L, 17592320262144L, 0L, 0L, 0L}; 8318 return data; 8319 } 8320 public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21()); 8321 private static final long[] mk_tokenSet_22() { 8322 long[] data = { 1729663731886981120L, 36028797018963968L, 0L, 0L}; 8323 return data; 8324 } 8325 public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22()); 8326 private static final long[] mk_tokenSet_23() { 8327 long[] data = { 351843720888320L, 133120L, 0L, 0L}; 8328 return data; 8329 } 8330 public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23()); 8331 private static final long[] mk_tokenSet_24() { 8332 long[] data = { -3459882717145989120L, 36028801313931647L, 17592320262144L, 0L, 0L, 0L}; 8333 return data; 8334 } 8335 public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24()); 8336 private static final long[] mk_tokenSet_25() { 8337 long[] data = { -2306679737562431488L, 36028801313939839L, 17592320262144L, 0L, 0L, 0L}; 8338 return data; 8339 } 8340 public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25()); 8341 private static final long[] mk_tokenSet_26() { 8342 long[] data = { 1151795604700004352L, 36028797018963968L, 17592186044416L, 0L, 0L, 0L}; 8343 return data; 8344 } 8345 public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26()); 8346 private static final long[] mk_tokenSet_27() { 8347 long[] data = { 1729663731886981120L, 36028797018972160L, 0L, 0L}; 8348 return data; 8349 } 8350 public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27()); 8351 private static final long[] mk_tokenSet_28() { 8352 long[] data = { -3459530873425100800L, 36028801314066303L, 17592320262144L, 0L, 0L, 0L}; 8353 return data; 8354 } 8355 public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28()); 8356 private static final long[] mk_tokenSet_29() { 8357 long[] data = { -3459812348401811456L, 36028801313933183L, 17592320262144L, 0L, 0L, 0L}; 8358 return data; 8359 } 8360 public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29()); 8361 private static final long[] mk_tokenSet_30() { 8362 long[] data = { -203409651138558L, -51539873921L, 17592353947647L, 0L, 0L, 0L}; 8363 return data; 8364 } 8365 public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30()); 8366 private static final long[] mk_tokenSet_31() { 8367 long[] data = { 1151796704211632128L, 0L, 17592186044416L, 0L, 0L, 0L}; 8368 return data; 8369 } 8370 public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31()); 8371 private static final long[] mk_tokenSet_32() { 8372 long[] data = { 2304998584283561984L, 36028797018982400L, 17592186044416L, 0L, 0L, 0L}; 8373 return data; 8374 } 8375 public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32()); 8376 private static final long[] mk_tokenSet_33() { 8377 long[] data = { 2304998584283561984L, 36028797018963968L, 52776558133248L, 0L, 0L, 0L}; 8378 return data; 8379 } 8380 public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33()); 8381 private static final long[] mk_tokenSet_34() { 8382 long[] data = { 1729452625654448128L, 2560L, 0L, 0L}; 8383 return data; 8384 } 8385 public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34()); 8386 private static final long[] mk_tokenSet_35() { 8387 long[] data = { 1152991873351024640L, 2560L, 0L, 0L}; 8388 return data; 8389 } 8390 public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35()); 8391 private static final long[] mk_tokenSet_36() { 8392 long[] data = { -3459812348401811456L, -9223372022898122113L, 17592219729913L, 0L, 0L, 0L}; 8393 return data; 8394 } 8395 public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36()); 8396 private static final long[] mk_tokenSet_37() { 8397 long[] data = { 1151795604700004352L, 36028797019070464L, 130944L, 0L, 0L, 0L}; 8398 return data; 8399 } 8400 public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37()); 8401 private static final long[] mk_tokenSet_38() { 8402 long[] data = { 2304998584283561984L, -2197615880668340224L, 17592186175481L, 0L, 0L, 0L}; 8403 return data; 8404 } 8405 public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38()); 8406 private static final long[] mk_tokenSet_39() { 8407 long[] data = { -3459812348401811456L, -9223372022898121089L, 17592219729913L, 0L, 0L, 0L}; 8408 return data; 8409 } 8410 public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39()); 8411 private static final long[] mk_tokenSet_40() { 8412 long[] data = { -766359604559872L, -54761101441L, 9024791608688639L, 0L, 0L, 0L}; 8413 return data; 8414 } 8415 public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40()); 8416 private static final long[] mk_tokenSet_41() { 8417 long[] data = { 0L, 36028797019062272L, 0L, 0L}; 8418 return data; 8419 } 8420 public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41()); 8421 private static final long[] mk_tokenSet_42() { 8422 long[] data = { 1151795604700004352L, 6989727359167471616L, 17592186044416L, 0L, 0L, 0L}; 8423 return data; 8424 } 8425 public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42()); 8426 private static final long[] mk_tokenSet_43() { 8427 long[] data = { 1151795604700004352L, 106496L, 130944L, 0L, 0L, 0L}; 8428 return data; 8429 } 8430 public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43()); 8431 private static final long[] mk_tokenSet_44() { 8432 long[] data = { 2304998584283561984L, -9187343239835705344L, 17592186175481L, 0L, 0L, 0L}; 8433 return data; 8434 } 8435 public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44()); 8436 private static final long[] mk_tokenSet_45() { 8437 long[] data = { -168225279049726L, -266369L, 9024791608688639L, 0L, 0L, 0L}; 8438 return data; 8439 } 8440 public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45()); 8441 private static final long[] mk_tokenSet_46() { 8442 long[] data = { 4610841593497255936L, -68718174208L, 17592186175487L, 0L, 0L, 0L}; 8443 return data; 8444 } 8445 public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46()); 8446 private static final long[] mk_tokenSet_47() { 8447 long[] data = { 1151795604700004352L, -9223372036854668800L, 131065L, 0L, 0L, 0L}; 8448 return data; 8449 } 8450 public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47()); 8451 private static final long[] mk_tokenSet_48() { 8452 long[] data = { 281474976710656L, 18432L, 0L, 0L}; 8453 return data; 8454 } 8455 public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48()); 8456 private static final long[] mk_tokenSet_49() { 8457 long[] data = { -3459812348401811456L, -9223372019676354945L, 17592219729913L, 0L, 0L, 0L}; 8458 return data; 8459 } 8460 public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49()); 8461 private static final long[] mk_tokenSet_50() { 8462 long[] data = { -203409651138560L, -266369L, 9024791608688639L, 0L, 0L, 0L}; 8463 return data; 8464 } 8465 public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50()); 8466 private static final long[] mk_tokenSet_51() { 8467 long[] data = { -3459882717145989120L, 4294967359L, 17592186044416L, 0L, 0L, 0L}; 8468 return data; 8469 } 8470 public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51()); 8471 private static final long[] mk_tokenSet_52() { 8472 long[] data = { -2306679737562431488L, 36028801313931327L, 17592186044416L, 0L, 0L, 0L}; 8473 return data; 8474 } 8475 public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52()); 8476 private static final long[] mk_tokenSet_53() { 8477 long[] data = { -766359604559872L, -51539876225L, 9024791474470911L, 0L, 0L, 0L}; 8478 return data; 8479 } 8480 public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53()); 8481 private static final long[] mk_tokenSet_54() { 8482 long[] data = { -4611678321845993472L, 4294967423L, 17592186044416L, 0L, 0L, 0L}; 8483 return data; 8484 } 8485 public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54()); 8486 private static final long[] mk_tokenSet_55() { 8487 long[] data = { -4035217569542569984L, 4294967423L, 17592186044416L, 0L, 0L, 0L}; 8488 return data; 8489 } 8490 public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55()); 8491 private static final long[] mk_tokenSet_56() { 8492 long[] data = { -3459812348401811456L, -9223372032559701953L, 17592186175481L, 0L, 0L, 0L}; 8493 return data; 8494 } 8495 public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56()); 8496 private static final long[] mk_tokenSet_57() { 8497 long[] data = { -766359604559872L, -64423204801L, 9024791440916479L, 0L, 0L, 0L}; 8498 return data; 8499 } 8500 public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57()); 8501 private static final long[] mk_tokenSet_58() { 8502 long[] data = { 1151795604700004352L, -9223372036854145024L, 131065L, 0L, 0L, 0L}; 8503 return data; 8504 } 8505 public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58()); 8506 private static final long[] mk_tokenSet_59() { 8507 long[] data = { 4610913061753061376L, -68718172160L, 9024791440916479L, 0L, 0L, 0L}; 8508 return data; 8509 } 8510 public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59()); 8511 private static final long[] mk_tokenSet_60() { 8512 long[] data = { -766359604559872L, -52613618049L, 9024791474470911L, 0L, 0L, 0L}; 8513 return data; 8514 } 8515 public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60()); 8516 private static final long[] mk_tokenSet_61() { 8517 long[] data = { 2305843009213693952L, 0L, 6L, 0L, 0L, 0L}; 8518 return data; 8519 } 8520 public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61()); 8521 private static final long[] mk_tokenSet_62() { 8522 long[] data = { 576460752303423488L, 36028797019062272L, 0L, 0L}; 8523 return data; 8524 } 8525 public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62()); 8526 private static final long[] mk_tokenSet_63() { 8527 long[] data = { 1151795604700004352L, -9223372036854652928L, 131065L, 0L, 0L, 0L}; 8528 return data; 8529 } 8530 public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63()); 8531 private static final long[] mk_tokenSet_64() { 8532 long[] data = { -1153406389234696192L, -51540922497L, 17592353947647L, 0L, 0L, 0L}; 8533 return data; 8534 } 8535 public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64()); 8536 private static final long[] mk_tokenSet_65() { 8537 long[] data = { 1151795604700004352L, -9223372036854665728L, 131065L, 0L, 0L, 0L}; 8538 return data; 8539 } 8540 public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65()); 8541 private static final long[] mk_tokenSet_66() { 8542 long[] data = { 1152358554653425664L, -9223372036854669312L, 131065L, 0L, 0L, 0L}; 8543 return data; 8544 } 8545 public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66()); 8546 private static final long[] mk_tokenSet_67() { 8547 long[] data = { 1151796704211632128L, 16384L, 17592186044416L, 0L, 0L, 0L}; 8548 return data; 8549 } 8550 public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67()); 8551 private static final long[] mk_tokenSet_68() { 8552 long[] data = { 2304998584283561984L, 36028797018982400L, 9059975812874240L, 0L, 0L, 0L}; 8553 return data; 8554 } 8555 public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68()); 8556 private static final long[] mk_tokenSet_69() { 8557 long[] data = { -203409651138560L, -51539873921L, 9024791608688639L, 0L, 0L, 0L}; 8558 return data; 8559 } 8560 public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69()); 8561 8562 }