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