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