View Javadoc
1 /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */ 2 package net.sourceforge.pmd.ast; 3 public class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/ 4 protected JJTJavaParserState jjtree = new JJTJavaParserState(); 5 private boolean usingAssertAsIdentifier; 6 7 public void setAssertAsIdentifier() { 8 this.usingAssertAsIdentifier = true; 9 } 10 11 private void checkForBadAssertUsage(String in, String usage) { 12 if (!usingAssertAsIdentifier && in.equals("assert")) { 13 throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!"); 14 } 15 } 16 17 // This is a semantic LOOKAHEAD to determine if we're dealing with an assert 18 // Note that this can't be replaced with a syntactic lookahead since "assert" isn't a string literal token 19 private boolean isNextTokenAnAssert() { 20 return getToken(1).image.equals("assert"); 21 } 22 23 /****************************************** 24 * THE JAVA LANGUAGE GRAMMAR STARTS HERE * 25 *****************************************/ 26 27 /* 28 * Program structuring syntax follows. 29 */ 30 final public ASTCompilationUnit CompilationUnit() throws ParseException { 31 /*@bgen(jjtree) CompilationUnit */ 32 ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT); 33 boolean jjtc000 = true; 34 jjtree.openNodeScope(jjtn000); 35 try { 36 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 37 case PACKAGE: 38 PackageDeclaration(); 39 break; 40 default: 41 jj_la1[0] = jj_gen; 42 ; 43 } 44 label_1: 45 while (true) { 46 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 47 case IMPORT: 48 ; 49 break; 50 default: 51 jj_la1[1] = jj_gen; 52 break label_1; 53 } 54 ImportDeclaration(); 55 } 56 label_2: 57 while (true) { 58 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 59 case ABSTRACT: 60 case CLASS: 61 case FINAL: 62 case INTERFACE: 63 case PUBLIC: 64 case STRICTFP: 65 case SEMICOLON: 66 ; 67 break; 68 default: 69 jj_la1[2] = jj_gen; 70 break label_2; 71 } 72 TypeDeclaration(); 73 } 74 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 75 case 120: 76 jj_consume_token(120); 77 break; 78 default: 79 jj_la1[3] = jj_gen; 80 ; 81 } 82 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 83 case 121: 84 jj_consume_token(121); 85 break; 86 default: 87 jj_la1[4] = jj_gen; 88 ; 89 } 90 jj_consume_token(0); 91 jjtree.closeNodeScope(jjtn000, true); 92 jjtc000 = false; 93 {if (true) return jjtn000;} 94 } catch (Throwable jjte000) { 95 if (jjtc000) { 96 jjtree.clearNodeScope(jjtn000); 97 jjtc000 = false; 98 } else { 99 jjtree.popNode(); 100 } 101 if (jjte000 instanceof RuntimeException) { 102 {if (true) throw (RuntimeException)jjte000;} 103 } 104 if (jjte000 instanceof ParseException) { 105 {if (true) throw (ParseException)jjte000;} 106 } 107 {if (true) throw (RuntimeException)jjte000;} 108 } finally { 109 if (jjtc000) { 110 jjtree.closeNodeScope(jjtn000, true); 111 } 112 } 113 throw new RuntimeException("Missing return statement in function"); 114 } 115 116 final public void PackageDeclaration() throws ParseException { 117 /*@bgen(jjtree) PackageDeclaration */ 118 ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION); 119 boolean jjtc000 = true; 120 jjtree.openNodeScope(jjtn000); 121 try { 122 jj_consume_token(PACKAGE); 123 Name(); 124 jj_consume_token(SEMICOLON); 125 } catch (Throwable jjte000) { 126 if (jjtc000) { 127 jjtree.clearNodeScope(jjtn000); 128 jjtc000 = false; 129 } else { 130 jjtree.popNode(); 131 } 132 if (jjte000 instanceof RuntimeException) { 133 {if (true) throw (RuntimeException)jjte000;} 134 } 135 if (jjte000 instanceof ParseException) { 136 {if (true) throw (ParseException)jjte000;} 137 } 138 {if (true) throw (RuntimeException)jjte000;} 139 } finally { 140 if (jjtc000) { 141 jjtree.closeNodeScope(jjtn000, true); 142 } 143 } 144 } 145 146 final public void ImportDeclaration() throws ParseException { 147 /*@bgen(jjtree) ImportDeclaration */ 148 ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION); 149 boolean jjtc000 = true; 150 jjtree.openNodeScope(jjtn000); 151 try { 152 jj_consume_token(IMPORT); 153 Name(); 154 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 155 case DOT: 156 jj_consume_token(DOT); 157 jj_consume_token(STAR); 158 jjtn000.setImportOnDemand(); 159 break; 160 default: 161 jj_la1[5] = jj_gen; 162 ; 163 } 164 jj_consume_token(SEMICOLON); 165 } catch (Throwable jjte000) { 166 if (jjtc000) { 167 jjtree.clearNodeScope(jjtn000); 168 jjtc000 = false; 169 } else { 170 jjtree.popNode(); 171 } 172 if (jjte000 instanceof RuntimeException) { 173 {if (true) throw (RuntimeException)jjte000;} 174 } 175 if (jjte000 instanceof ParseException) { 176 {if (true) throw (ParseException)jjte000;} 177 } 178 {if (true) throw (RuntimeException)jjte000;} 179 } finally { 180 if (jjtc000) { 181 jjtree.closeNodeScope(jjtn000, true); 182 } 183 } 184 } 185 186 final public void TypeDeclaration() throws ParseException { 187 /*@bgen(jjtree) TypeDeclaration */ 188 ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION); 189 boolean jjtc000 = true; 190 jjtree.openNodeScope(jjtn000); 191 try { 192 if (jj_2_1(2147483647)) { 193 ClassDeclaration(); 194 } else { 195 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 196 case ABSTRACT: 197 case INTERFACE: 198 case PUBLIC: 199 case STRICTFP: 200 InterfaceDeclaration(); 201 break; 202 case SEMICOLON: 203 jj_consume_token(SEMICOLON); 204 break; 205 default: 206 jj_la1[6] = jj_gen; 207 jj_consume_token(-1); 208 throw new ParseException(); 209 } 210 } 211 } catch (Throwable jjte000) { 212 if (jjtc000) { 213 jjtree.clearNodeScope(jjtn000); 214 jjtc000 = false; 215 } else { 216 jjtree.popNode(); 217 } 218 if (jjte000 instanceof RuntimeException) { 219 {if (true) throw (RuntimeException)jjte000;} 220 } 221 if (jjte000 instanceof ParseException) { 222 {if (true) throw (ParseException)jjte000;} 223 } 224 {if (true) throw (RuntimeException)jjte000;} 225 } finally { 226 if (jjtc000) { 227 jjtree.closeNodeScope(jjtn000, true); 228 } 229 } 230 } 231 232 /* 233 * Declaration syntax follows. 234 */ 235 final public void ClassDeclaration() throws ParseException { 236 /*@bgen(jjtree) ClassDeclaration */ 237 ASTClassDeclaration jjtn000 = new ASTClassDeclaration(this, JJTCLASSDECLARATION); 238 boolean jjtc000 = true; 239 jjtree.openNodeScope(jjtn000); 240 try { 241 label_3: 242 while (true) { 243 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 244 case ABSTRACT: 245 case FINAL: 246 case PUBLIC: 247 case STRICTFP: 248 ; 249 break; 250 default: 251 jj_la1[7] = jj_gen; 252 break label_3; 253 } 254 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 255 case ABSTRACT: 256 jj_consume_token(ABSTRACT); 257 jjtn000.setAbstract(); 258 break; 259 case FINAL: 260 jj_consume_token(FINAL); 261 jjtn000.setFinal(); 262 break; 263 case PUBLIC: 264 jj_consume_token(PUBLIC); 265 jjtn000.setPublic(); 266 break; 267 case STRICTFP: 268 jj_consume_token(STRICTFP); 269 jjtn000.setStrict(); 270 break; 271 default: 272 jj_la1[8] = jj_gen; 273 jj_consume_token(-1); 274 throw new ParseException(); 275 } 276 } 277 UnmodifiedClassDeclaration(); 278 } catch (Throwable jjte000) { 279 if (jjtc000) { 280 jjtree.clearNodeScope(jjtn000); 281 jjtc000 = false; 282 } else { 283 jjtree.popNode(); 284 } 285 if (jjte000 instanceof RuntimeException) { 286 {if (true) throw (RuntimeException)jjte000;} 287 } 288 if (jjte000 instanceof ParseException) { 289 {if (true) throw (ParseException)jjte000;} 290 } 291 {if (true) throw (RuntimeException)jjte000;} 292 } finally { 293 if (jjtc000) { 294 jjtree.closeNodeScope(jjtn000, true); 295 } 296 } 297 } 298 299 final public void UnmodifiedClassDeclaration() throws ParseException { 300 /*@bgen(jjtree) UnmodifiedClassDeclaration */ 301 ASTUnmodifiedClassDeclaration jjtn000 = new ASTUnmodifiedClassDeclaration(this, JJTUNMODIFIEDCLASSDECLARATION); 302 boolean jjtc000 = true; 303 jjtree.openNodeScope(jjtn000);Token t = null; 304 try { 305 jj_consume_token(CLASS); 306 t = jj_consume_token(IDENTIFIER); 307 jjtn000.setImage( t.image ); 308 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 309 case EXTENDS: 310 jj_consume_token(EXTENDS); 311 jjtn000.setHasExplicitExtends(); 312 Name(); 313 break; 314 default: 315 jj_la1[9] = jj_gen; 316 ; 317 } 318 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 319 case IMPLEMENTS: 320 jj_consume_token(IMPLEMENTS); 321 jjtn000.setHasExplicitImplements(); 322 NameList(); 323 break; 324 default: 325 jj_la1[10] = jj_gen; 326 ; 327 } 328 ClassBody(); 329 } catch (Throwable jjte000) { 330 if (jjtc000) { 331 jjtree.clearNodeScope(jjtn000); 332 jjtc000 = false; 333 } else { 334 jjtree.popNode(); 335 } 336 if (jjte000 instanceof RuntimeException) { 337 {if (true) throw (RuntimeException)jjte000;} 338 } 339 if (jjte000 instanceof ParseException) { 340 {if (true) throw (ParseException)jjte000;} 341 } 342 {if (true) throw (RuntimeException)jjte000;} 343 } finally { 344 if (jjtc000) { 345 jjtree.closeNodeScope(jjtn000, true); 346 } 347 } 348 } 349 350 final public void ClassBody() throws ParseException { 351 /*@bgen(jjtree) ClassBody */ 352 ASTClassBody jjtn000 = new ASTClassBody(this, JJTCLASSBODY); 353 boolean jjtc000 = true; 354 jjtree.openNodeScope(jjtn000); 355 try { 356 jj_consume_token(LBRACE); 357 label_4: 358 while (true) { 359 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 360 case ABSTRACT: 361 case BOOLEAN: 362 case BYTE: 363 case CHAR: 364 case CLASS: 365 case DOUBLE: 366 case FINAL: 367 case FLOAT: 368 case INT: 369 case INTERFACE: 370 case LONG: 371 case NATIVE: 372 case PRIVATE: 373 case PROTECTED: 374 case PUBLIC: 375 case SHORT: 376 case STATIC: 377 case SYNCHRONIZED: 378 case TRANSIENT: 379 case VOID: 380 case VOLATILE: 381 case STRICTFP: 382 case IDENTIFIER: 383 case LBRACE: 384 case SEMICOLON: 385 ; 386 break; 387 default: 388 jj_la1[11] = jj_gen; 389 break label_4; 390 } 391 ClassBodyDeclaration(); 392 } 393 jj_consume_token(RBRACE); 394 } catch (Throwable jjte000) { 395 if (jjtc000) { 396 jjtree.clearNodeScope(jjtn000); 397 jjtc000 = false; 398 } else { 399 jjtree.popNode(); 400 } 401 if (jjte000 instanceof RuntimeException) { 402 {if (true) throw (RuntimeException)jjte000;} 403 } 404 if (jjte000 instanceof ParseException) { 405 {if (true) throw (ParseException)jjte000;} 406 } 407 {if (true) throw (RuntimeException)jjte000;} 408 } finally { 409 if (jjtc000) { 410 jjtree.closeNodeScope(jjtn000, true); 411 } 412 } 413 } 414 415 final public void NestedClassDeclaration() throws ParseException { 416 /*@bgen(jjtree) NestedClassDeclaration */ 417 ASTNestedClassDeclaration jjtn000 = new ASTNestedClassDeclaration(this, JJTNESTEDCLASSDECLARATION); 418 boolean jjtc000 = true; 419 jjtree.openNodeScope(jjtn000); 420 try { 421 label_5: 422 while (true) { 423 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 424 case ABSTRACT: 425 case FINAL: 426 case PRIVATE: 427 case PROTECTED: 428 case PUBLIC: 429 case STATIC: 430 case STRICTFP: 431 ; 432 break; 433 default: 434 jj_la1[12] = jj_gen; 435 break label_5; 436 } 437 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 438 case STATIC: 439 jj_consume_token(STATIC); 440 jjtn000.setStatic(); 441 break; 442 case ABSTRACT: 443 jj_consume_token(ABSTRACT); 444 jjtn000.setAbstract(); 445 break; 446 case FINAL: 447 jj_consume_token(FINAL); 448 jjtn000.setFinal(); 449 break; 450 case PUBLIC: 451 jj_consume_token(PUBLIC); 452 jjtn000.setPublic(); 453 break; 454 case PROTECTED: 455 jj_consume_token(PROTECTED); 456 jjtn000.setProtected(); 457 break; 458 case PRIVATE: 459 jj_consume_token(PRIVATE); 460 jjtn000.setPrivate(); 461 break; 462 case STRICTFP: 463 jj_consume_token(STRICTFP); 464 jjtn000.setStrict(); 465 break; 466 default: 467 jj_la1[13] = jj_gen; 468 jj_consume_token(-1); 469 throw new ParseException(); 470 } 471 } 472 UnmodifiedClassDeclaration(); 473 } catch (Throwable jjte000) { 474 if (jjtc000) { 475 jjtree.clearNodeScope(jjtn000); 476 jjtc000 = false; 477 } else { 478 jjtree.popNode(); 479 } 480 if (jjte000 instanceof RuntimeException) { 481 {if (true) throw (RuntimeException)jjte000;} 482 } 483 if (jjte000 instanceof ParseException) { 484 {if (true) throw (ParseException)jjte000;} 485 } 486 {if (true) throw (RuntimeException)jjte000;} 487 } finally { 488 if (jjtc000) { 489 jjtree.closeNodeScope(jjtn000, true); 490 } 491 } 492 } 493 494 final public void ClassBodyDeclaration() throws ParseException { 495 /*@bgen(jjtree) ClassBodyDeclaration */ 496 ASTClassBodyDeclaration jjtn000 = new ASTClassBodyDeclaration(this, JJTCLASSBODYDECLARATION); 497 boolean jjtc000 = true; 498 jjtree.openNodeScope(jjtn000); 499 try { 500 if (jj_2_2(2)) { 501 Initializer(); 502 } else if (jj_2_3(2147483647)) { 503 NestedClassDeclaration(); 504 } else if (jj_2_4(2147483647)) { 505 NestedInterfaceDeclaration(); 506 } else if (jj_2_5(2147483647)) { 507 ConstructorDeclaration(); 508 } else if (jj_2_6(2147483647)) { 509 MethodDeclaration(); 510 } else { 511 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 512 case BOOLEAN: 513 case BYTE: 514 case CHAR: 515 case DOUBLE: 516 case FINAL: 517 case FLOAT: 518 case INT: 519 case LONG: 520 case PRIVATE: 521 case PROTECTED: 522 case PUBLIC: 523 case SHORT: 524 case STATIC: 525 case TRANSIENT: 526 case VOLATILE: 527 case IDENTIFIER: 528 FieldDeclaration(); 529 break; 530 case SEMICOLON: 531 jj_consume_token(SEMICOLON); 532 break; 533 default: 534 jj_la1[14] = jj_gen; 535 jj_consume_token(-1); 536 throw new ParseException(); 537 } 538 } 539 } catch (Throwable jjte000) { 540 if (jjtc000) { 541 jjtree.clearNodeScope(jjtn000); 542 jjtc000 = false; 543 } else { 544 jjtree.popNode(); 545 } 546 if (jjte000 instanceof RuntimeException) { 547 {if (true) throw (RuntimeException)jjte000;} 548 } 549 if (jjte000 instanceof ParseException) { 550 {if (true) throw (ParseException)jjte000;} 551 } 552 {if (true) throw (RuntimeException)jjte000;} 553 } finally { 554 if (jjtc000) { 555 jjtree.closeNodeScope(jjtn000, true); 556 } 557 } 558 } 559 560 // This production is to determine lookahead only. 561 final public void MethodDeclarationLookahead() throws ParseException { 562 /*@bgen(jjtree) MethodDeclarationLookahead */ 563 ASTMethodDeclarationLookahead jjtn000 = new ASTMethodDeclarationLookahead(this, JJTMETHODDECLARATIONLOOKAHEAD); 564 boolean jjtc000 = true; 565 jjtree.openNodeScope(jjtn000); 566 try { 567 label_6: 568 while (true) { 569 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 570 case ABSTRACT: 571 case FINAL: 572 case NATIVE: 573 case PRIVATE: 574 case PROTECTED: 575 case PUBLIC: 576 case STATIC: 577 case SYNCHRONIZED: 578 case STRICTFP: 579 ; 580 break; 581 default: 582 jj_la1[15] = jj_gen; 583 break label_6; 584 } 585 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 586 case PUBLIC: 587 jj_consume_token(PUBLIC); 588 break; 589 case PROTECTED: 590 jj_consume_token(PROTECTED); 591 break; 592 case PRIVATE: 593 jj_consume_token(PRIVATE); 594 break; 595 case STATIC: 596 jj_consume_token(STATIC); 597 break; 598 case ABSTRACT: 599 jj_consume_token(ABSTRACT); 600 break; 601 case FINAL: 602 jj_consume_token(FINAL); 603 break; 604 case NATIVE: 605 jj_consume_token(NATIVE); 606 break; 607 case SYNCHRONIZED: 608 jj_consume_token(SYNCHRONIZED); 609 break; 610 case STRICTFP: 611 jj_consume_token(STRICTFP); 612 break; 613 default: 614 jj_la1[16] = jj_gen; 615 jj_consume_token(-1); 616 throw new ParseException(); 617 } 618 } 619 ResultType(); 620 jj_consume_token(IDENTIFIER); 621 jj_consume_token(LPAREN); 622 } catch (Throwable jjte000) { 623 if (jjtc000) { 624 jjtree.clearNodeScope(jjtn000); 625 jjtc000 = false; 626 } else { 627 jjtree.popNode(); 628 } 629 if (jjte000 instanceof RuntimeException) { 630 {if (true) throw (RuntimeException)jjte000;} 631 } 632 if (jjte000 instanceof ParseException) { 633 {if (true) throw (ParseException)jjte000;} 634 } 635 {if (true) throw (RuntimeException)jjte000;} 636 } finally { 637 if (jjtc000) { 638 jjtree.closeNodeScope(jjtn000, true); 639 } 640 } 641 } 642 643 final public void InterfaceDeclaration() throws ParseException { 644 /*@bgen(jjtree) InterfaceDeclaration */ 645 ASTInterfaceDeclaration jjtn000 = new ASTInterfaceDeclaration(this, JJTINTERFACEDECLARATION); 646 boolean jjtc000 = true; 647 jjtree.openNodeScope(jjtn000); 648 try { 649 label_7: 650 while (true) { 651 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 652 case ABSTRACT: 653 case PUBLIC: 654 case STRICTFP: 655 ; 656 break; 657 default: 658 jj_la1[17] = jj_gen; 659 break label_7; 660 } 661 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 662 case ABSTRACT: 663 jj_consume_token(ABSTRACT); 664 jjtn000.setAbstract(); 665 break; 666 case PUBLIC: 667 jj_consume_token(PUBLIC); 668 jjtn000.setPublic(); 669 break; 670 case STRICTFP: 671 jj_consume_token(STRICTFP); 672 jjtn000.setStrict(); 673 break; 674 default: 675 jj_la1[18] = jj_gen; 676 jj_consume_token(-1); 677 throw new ParseException(); 678 } 679 } 680 UnmodifiedInterfaceDeclaration(); 681 } catch (Throwable jjte000) { 682 if (jjtc000) { 683 jjtree.clearNodeScope(jjtn000); 684 jjtc000 = false; 685 } else { 686 jjtree.popNode(); 687 } 688 if (jjte000 instanceof RuntimeException) { 689 {if (true) throw (RuntimeException)jjte000;} 690 } 691 if (jjte000 instanceof ParseException) { 692 {if (true) throw (ParseException)jjte000;} 693 } 694 {if (true) throw (RuntimeException)jjte000;} 695 } finally { 696 if (jjtc000) { 697 jjtree.closeNodeScope(jjtn000, true); 698 } 699 } 700 } 701 702 final public void NestedInterfaceDeclaration() throws ParseException { 703 /*@bgen(jjtree) NestedInterfaceDeclaration */ 704 ASTNestedInterfaceDeclaration jjtn000 = new ASTNestedInterfaceDeclaration(this, JJTNESTEDINTERFACEDECLARATION); 705 boolean jjtc000 = true; 706 jjtree.openNodeScope(jjtn000); 707 try { 708 label_8: 709 while (true) { 710 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 711 case ABSTRACT: 712 case FINAL: 713 case PRIVATE: 714 case PROTECTED: 715 case PUBLIC: 716 case STATIC: 717 case STRICTFP: 718 ; 719 break; 720 default: 721 jj_la1[19] = jj_gen; 722 break label_8; 723 } 724 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 725 case STATIC: 726 jj_consume_token(STATIC); 727 jjtn000.setStatic(); 728 break; 729 case ABSTRACT: 730 jj_consume_token(ABSTRACT); 731 jjtn000.setAbstract(); 732 break; 733 case FINAL: 734 jj_consume_token(FINAL); 735 jjtn000.setFinal(); 736 break; 737 case PUBLIC: 738 jj_consume_token(PUBLIC); 739 jjtn000.setPublic(); 740 break; 741 case PROTECTED: 742 jj_consume_token(PROTECTED); 743 jjtn000.setProtected(); 744 break; 745 case PRIVATE: 746 jj_consume_token(PRIVATE); 747 jjtn000.setPrivate(); 748 break; 749 case STRICTFP: 750 jj_consume_token(STRICTFP); 751 jjtn000.setStrict(); 752 break; 753 default: 754 jj_la1[20] = jj_gen; 755 jj_consume_token(-1); 756 throw new ParseException(); 757 } 758 } 759 UnmodifiedInterfaceDeclaration(); 760 } catch (Throwable jjte000) { 761 if (jjtc000) { 762 jjtree.clearNodeScope(jjtn000); 763 jjtc000 = false; 764 } else { 765 jjtree.popNode(); 766 } 767 if (jjte000 instanceof RuntimeException) { 768 {if (true) throw (RuntimeException)jjte000;} 769 } 770 if (jjte000 instanceof ParseException) { 771 {if (true) throw (ParseException)jjte000;} 772 } 773 {if (true) throw (RuntimeException)jjte000;} 774 } finally { 775 if (jjtc000) { 776 jjtree.closeNodeScope(jjtn000, true); 777 } 778 } 779 } 780 781 final public void UnmodifiedInterfaceDeclaration() throws ParseException { 782 /*@bgen(jjtree) UnmodifiedInterfaceDeclaration */ 783 ASTUnmodifiedInterfaceDeclaration jjtn000 = new ASTUnmodifiedInterfaceDeclaration(this, JJTUNMODIFIEDINTERFACEDECLARATION); 784 boolean jjtc000 = true; 785 jjtree.openNodeScope(jjtn000);Token t = null; 786 try { 787 jj_consume_token(INTERFACE); 788 t = jj_consume_token(IDENTIFIER); 789 jjtn000.setImage( t.image ); 790 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 791 case EXTENDS: 792 jj_consume_token(EXTENDS); 793 NameList(); 794 break; 795 default: 796 jj_la1[21] = jj_gen; 797 ; 798 } 799 jj_consume_token(LBRACE); 800 label_9: 801 while (true) { 802 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 803 case ABSTRACT: 804 case BOOLEAN: 805 case BYTE: 806 case CHAR: 807 case CLASS: 808 case DOUBLE: 809 case FINAL: 810 case FLOAT: 811 case INT: 812 case INTERFACE: 813 case LONG: 814 case NATIVE: 815 case PRIVATE: 816 case PROTECTED: 817 case PUBLIC: 818 case SHORT: 819 case STATIC: 820 case SYNCHRONIZED: 821 case TRANSIENT: 822 case VOID: 823 case VOLATILE: 824 case STRICTFP: 825 case IDENTIFIER: 826 case SEMICOLON: 827 ; 828 break; 829 default: 830 jj_la1[22] = jj_gen; 831 break label_9; 832 } 833 InterfaceMemberDeclaration(); 834 } 835 jj_consume_token(RBRACE); 836 } catch (Throwable jjte000) { 837 if (jjtc000) { 838 jjtree.clearNodeScope(jjtn000); 839 jjtc000 = false; 840 } else { 841 jjtree.popNode(); 842 } 843 if (jjte000 instanceof RuntimeException) { 844 {if (true) throw (RuntimeException)jjte000;} 845 } 846 if (jjte000 instanceof ParseException) { 847 {if (true) throw (ParseException)jjte000;} 848 } 849 {if (true) throw (RuntimeException)jjte000;} 850 } finally { 851 if (jjtc000) { 852 jjtree.closeNodeScope(jjtn000, true); 853 } 854 } 855 } 856 857 final public void InterfaceMemberDeclaration() throws ParseException { 858 /*@bgen(jjtree) InterfaceMemberDeclaration */ 859 ASTInterfaceMemberDeclaration jjtn000 = new ASTInterfaceMemberDeclaration(this, JJTINTERFACEMEMBERDECLARATION); 860 boolean jjtc000 = true; 861 jjtree.openNodeScope(jjtn000); 862 try { 863 if (jj_2_7(2147483647)) { 864 NestedClassDeclaration(); 865 } else if (jj_2_8(2147483647)) { 866 NestedInterfaceDeclaration(); 867 } else if (jj_2_9(2147483647)) { 868 MethodDeclaration(); 869 } else { 870 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 871 case BOOLEAN: 872 case BYTE: 873 case CHAR: 874 case DOUBLE: 875 case FINAL: 876 case FLOAT: 877 case INT: 878 case LONG: 879 case PRIVATE: 880 case PROTECTED: 881 case PUBLIC: 882 case SHORT: 883 case STATIC: 884 case TRANSIENT: 885 case VOLATILE: 886 case IDENTIFIER: 887 FieldDeclaration(); 888 break; 889 case SEMICOLON: 890 jj_consume_token(SEMICOLON); 891 break; 892 default: 893 jj_la1[23] = jj_gen; 894 jj_consume_token(-1); 895 throw new ParseException(); 896 } 897 } 898 } catch (Throwable jjte000) { 899 if (jjtc000) { 900 jjtree.clearNodeScope(jjtn000); 901 jjtc000 = false; 902 } else { 903 jjtree.popNode(); 904 } 905 if (jjte000 instanceof RuntimeException) { 906 {if (true) throw (RuntimeException)jjte000;} 907 } 908 if (jjte000 instanceof ParseException) { 909 {if (true) throw (ParseException)jjte000;} 910 } 911 {if (true) throw (RuntimeException)jjte000;} 912 } finally { 913 if (jjtc000) { 914 jjtree.closeNodeScope(jjtn000, true); 915 } 916 } 917 } 918 919 final public void FieldDeclaration() throws ParseException { 920 /*@bgen(jjtree) FieldDeclaration */ 921 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION); 922 boolean jjtc000 = true; 923 jjtree.openNodeScope(jjtn000); 924 try { 925 label_10: 926 while (true) { 927 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 928 case FINAL: 929 case PRIVATE: 930 case PROTECTED: 931 case PUBLIC: 932 case STATIC: 933 case TRANSIENT: 934 case VOLATILE: 935 ; 936 break; 937 default: 938 jj_la1[24] = jj_gen; 939 break label_10; 940 } 941 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 942 case PUBLIC: 943 jj_consume_token(PUBLIC); 944 jjtn000.setPublic(); 945 break; 946 case PROTECTED: 947 jj_consume_token(PROTECTED); 948 jjtn000.setProtected(); 949 break; 950 case PRIVATE: 951 jj_consume_token(PRIVATE); 952 jjtn000.setPrivate(); 953 break; 954 case STATIC: 955 jj_consume_token(STATIC); 956 jjtn000.setStatic(); 957 break; 958 case FINAL: 959 jj_consume_token(FINAL); 960 jjtn000.setFinal(); 961 break; 962 case TRANSIENT: 963 jj_consume_token(TRANSIENT); 964 jjtn000.setTransient(); 965 break; 966 case VOLATILE: 967 jj_consume_token(VOLATILE); 968 jjtn000.setVolatile(); 969 break; 970 default: 971 jj_la1[25] = jj_gen; 972 jj_consume_token(-1); 973 throw new ParseException(); 974 } 975 } 976 Type(); 977 VariableDeclarator(); 978 label_11: 979 while (true) { 980 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 981 case COMMA: 982 ; 983 break; 984 default: 985 jj_la1[26] = jj_gen; 986 break label_11; 987 } 988 jj_consume_token(COMMA); 989 VariableDeclarator(); 990 } 991 jj_consume_token(SEMICOLON); 992 } catch (Throwable jjte000) { 993 if (jjtc000) { 994 jjtree.clearNodeScope(jjtn000); 995 jjtc000 = false; 996 } else { 997 jjtree.popNode(); 998 } 999 if (jjte000 instanceof RuntimeException) { 1000 {if (true) throw (RuntimeException)jjte000;} 1001 } 1002 if (jjte000 instanceof ParseException) { 1003 {if (true) throw (ParseException)jjte000;} 1004 } 1005 {if (true) throw (RuntimeException)jjte000;} 1006 } finally { 1007 if (jjtc000) { 1008 jjtree.closeNodeScope(jjtn000, true); 1009 } 1010 } 1011 } 1012 1013 final public void VariableDeclarator() throws ParseException { 1014 /*@bgen(jjtree) VariableDeclarator */ 1015 ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR); 1016 boolean jjtc000 = true; 1017 jjtree.openNodeScope(jjtn000); 1018 try { 1019 VariableDeclaratorId(); 1020 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1021 case ASSIGN: 1022 jj_consume_token(ASSIGN); 1023 VariableInitializer(); 1024 break; 1025 default: 1026 jj_la1[27] = jj_gen; 1027 ; 1028 } 1029 } catch (Throwable jjte000) { 1030 if (jjtc000) { 1031 jjtree.clearNodeScope(jjtn000); 1032 jjtc000 = false; 1033 } else { 1034 jjtree.popNode(); 1035 } 1036 if (jjte000 instanceof RuntimeException) { 1037 {if (true) throw (RuntimeException)jjte000;} 1038 } 1039 if (jjte000 instanceof ParseException) { 1040 {if (true) throw (ParseException)jjte000;} 1041 } 1042 {if (true) throw (RuntimeException)jjte000;} 1043 } finally { 1044 if (jjtc000) { 1045 jjtree.closeNodeScope(jjtn000, true); 1046 } 1047 } 1048 } 1049 1050 final public void VariableDeclaratorId() throws ParseException { 1051 /*@bgen(jjtree) VariableDeclaratorId */ 1052 ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID); 1053 boolean jjtc000 = true; 1054 jjtree.openNodeScope(jjtn000);String s = null; 1055 Token t = null; 1056 try { 1057 t = jj_consume_token(IDENTIFIER); 1058 s = t.image; 1059 label_12: 1060 while (true) { 1061 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1062 case LBRACKET: 1063 ; 1064 break; 1065 default: 1066 jj_la1[28] = jj_gen; 1067 break label_12; 1068 } 1069 jj_consume_token(LBRACKET); 1070 jj_consume_token(RBRACKET); 1071 } 1072 jjtree.closeNodeScope(jjtn000, true); 1073 jjtc000 = false; 1074 checkForBadAssertUsage(t.image, "a variable name"); 1075 jjtn000.setImage( s ); 1076 } finally { 1077 if (jjtc000) { 1078 jjtree.closeNodeScope(jjtn000, true); 1079 } 1080 } 1081 } 1082 1083 final public void VariableInitializer() throws ParseException { 1084 /*@bgen(jjtree) VariableInitializer */ 1085 ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER); 1086 boolean jjtc000 = true; 1087 jjtree.openNodeScope(jjtn000); 1088 try { 1089 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1090 case LBRACE: 1091 ArrayInitializer(); 1092 break; 1093 case BOOLEAN: 1094 case BYTE: 1095 case CHAR: 1096 case DOUBLE: 1097 case FALSE: 1098 case FLOAT: 1099 case INT: 1100 case LONG: 1101 case NEW: 1102 case NULL: 1103 case SHORT: 1104 case SUPER: 1105 case THIS: 1106 case TRUE: 1107 case VOID: 1108 case INTEGER_LITERAL: 1109 case FLOATING_POINT_LITERAL: 1110 case CHARACTER_LITERAL: 1111 case STRING_LITERAL: 1112 case IDENTIFIER: 1113 case LPAREN: 1114 case BANG: 1115 case TILDE: 1116 case INCR: 1117 case DECR: 1118 case PLUS: 1119 case MINUS: 1120 Expression(); 1121 break; 1122 default: 1123 jj_la1[29] = jj_gen; 1124 jj_consume_token(-1); 1125 throw new ParseException(); 1126 } 1127 } catch (Throwable jjte000) { 1128 if (jjtc000) { 1129 jjtree.clearNodeScope(jjtn000); 1130 jjtc000 = false; 1131 } else { 1132 jjtree.popNode(); 1133 } 1134 if (jjte000 instanceof RuntimeException) { 1135 {if (true) throw (RuntimeException)jjte000;} 1136 } 1137 if (jjte000 instanceof ParseException) { 1138 {if (true) throw (ParseException)jjte000;} 1139 } 1140 {if (true) throw (RuntimeException)jjte000;} 1141 } finally { 1142 if (jjtc000) { 1143 jjtree.closeNodeScope(jjtn000, true); 1144 } 1145 } 1146 } 1147 1148 final public void ArrayInitializer() throws ParseException { 1149 /*@bgen(jjtree) ArrayInitializer */ 1150 ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER); 1151 boolean jjtc000 = true; 1152 jjtree.openNodeScope(jjtn000); 1153 try { 1154 jj_consume_token(LBRACE); 1155 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1156 case BOOLEAN: 1157 case BYTE: 1158 case CHAR: 1159 case DOUBLE: 1160 case FALSE: 1161 case FLOAT: 1162 case INT: 1163 case LONG: 1164 case NEW: 1165 case NULL: 1166 case SHORT: 1167 case SUPER: 1168 case THIS: 1169 case TRUE: 1170 case VOID: 1171 case INTEGER_LITERAL: 1172 case FLOATING_POINT_LITERAL: 1173 case CHARACTER_LITERAL: 1174 case STRING_LITERAL: 1175 case IDENTIFIER: 1176 case LPAREN: 1177 case LBRACE: 1178 case BANG: 1179 case TILDE: 1180 case INCR: 1181 case DECR: 1182 case PLUS: 1183 case MINUS: 1184 VariableInitializer(); 1185 label_13: 1186 while (true) { 1187 if (jj_2_10(2)) { 1188 ; 1189 } else { 1190 break label_13; 1191 } 1192 jj_consume_token(COMMA); 1193 VariableInitializer(); 1194 } 1195 break; 1196 default: 1197 jj_la1[30] = jj_gen; 1198 ; 1199 } 1200 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1201 case COMMA: 1202 jj_consume_token(COMMA); 1203 break; 1204 default: 1205 jj_la1[31] = jj_gen; 1206 ; 1207 } 1208 jj_consume_token(RBRACE); 1209 } catch (Throwable jjte000) { 1210 if (jjtc000) { 1211 jjtree.clearNodeScope(jjtn000); 1212 jjtc000 = false; 1213 } else { 1214 jjtree.popNode(); 1215 } 1216 if (jjte000 instanceof RuntimeException) { 1217 {if (true) throw (RuntimeException)jjte000;} 1218 } 1219 if (jjte000 instanceof ParseException) { 1220 {if (true) throw (ParseException)jjte000;} 1221 } 1222 {if (true) throw (RuntimeException)jjte000;} 1223 } finally { 1224 if (jjtc000) { 1225 jjtree.closeNodeScope(jjtn000, true); 1226 } 1227 } 1228 } 1229 1230 final public void MethodDeclaration() throws ParseException { 1231 /*@bgen(jjtree) MethodDeclaration */ 1232 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION); 1233 boolean jjtc000 = true; 1234 jjtree.openNodeScope(jjtn000); 1235 try { 1236 label_14: 1237 while (true) { 1238 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1239 case ABSTRACT: 1240 case FINAL: 1241 case NATIVE: 1242 case PRIVATE: 1243 case PROTECTED: 1244 case PUBLIC: 1245 case STATIC: 1246 case SYNCHRONIZED: 1247 case STRICTFP: 1248 ; 1249 break; 1250 default: 1251 jj_la1[32] = jj_gen; 1252 break label_14; 1253 } 1254 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1255 case PUBLIC: 1256 jj_consume_token(PUBLIC); 1257 jjtn000.setPublic(); 1258 break; 1259 case PROTECTED: 1260 jj_consume_token(PROTECTED); 1261 jjtn000.setProtected(); 1262 break; 1263 case PRIVATE: 1264 jj_consume_token(PRIVATE); 1265 jjtn000.setPrivate(); 1266 break; 1267 case STATIC: 1268 jj_consume_token(STATIC); 1269 jjtn000.setStatic(); 1270 break; 1271 case ABSTRACT: 1272 jj_consume_token(ABSTRACT); 1273 jjtn000.setAbstract(); 1274 break; 1275 case FINAL: 1276 jj_consume_token(FINAL); 1277 jjtn000.setFinal(); 1278 break; 1279 case NATIVE: 1280 jj_consume_token(NATIVE); 1281 jjtn000.setNative(); 1282 break; 1283 case SYNCHRONIZED: 1284 jj_consume_token(SYNCHRONIZED); 1285 jjtn000.setSynchronized(); 1286 break; 1287 case STRICTFP: 1288 jj_consume_token(STRICTFP); 1289 jjtn000.setStrict(); 1290 break; 1291 default: 1292 jj_la1[33] = jj_gen; 1293 jj_consume_token(-1); 1294 throw new ParseException(); 1295 } 1296 } 1297 ResultType(); 1298 MethodDeclarator(); 1299 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1300 case THROWS: 1301 jj_consume_token(THROWS); 1302 NameList(); 1303 break; 1304 default: 1305 jj_la1[34] = jj_gen; 1306 ; 1307 } 1308 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1309 case LBRACE: 1310 Block(); 1311 break; 1312 case SEMICOLON: 1313 jj_consume_token(SEMICOLON); 1314 break; 1315 default: 1316 jj_la1[35] = jj_gen; 1317 jj_consume_token(-1); 1318 throw new ParseException(); 1319 } 1320 } catch (Throwable jjte000) { 1321 if (jjtc000) { 1322 jjtree.clearNodeScope(jjtn000); 1323 jjtc000 = false; 1324 } else { 1325 jjtree.popNode(); 1326 } 1327 if (jjte000 instanceof RuntimeException) { 1328 {if (true) throw (RuntimeException)jjte000;} 1329 } 1330 if (jjte000 instanceof ParseException) { 1331 {if (true) throw (ParseException)jjte000;} 1332 } 1333 {if (true) throw (RuntimeException)jjte000;} 1334 } finally { 1335 if (jjtc000) { 1336 jjtree.closeNodeScope(jjtn000, true); 1337 } 1338 } 1339 } 1340 1341 final public void MethodDeclarator() throws ParseException { 1342 /*@bgen(jjtree) MethodDeclarator */ 1343 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR); 1344 boolean jjtc000 = true; 1345 jjtree.openNodeScope(jjtn000);Token t = null; 1346 try { 1347 t = jj_consume_token(IDENTIFIER); 1348 checkForBadAssertUsage(t.image, "a method name"); 1349 jjtn000.setImage( t.image ); 1350 FormalParameters(); 1351 label_15: 1352 while (true) { 1353 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1354 case LBRACKET: 1355 ; 1356 break; 1357 default: 1358 jj_la1[36] = jj_gen; 1359 break label_15; 1360 } 1361 jj_consume_token(LBRACKET); 1362 jj_consume_token(RBRACKET); 1363 } 1364 } catch (Throwable jjte000) { 1365 if (jjtc000) { 1366 jjtree.clearNodeScope(jjtn000); 1367 jjtc000 = false; 1368 } else { 1369 jjtree.popNode(); 1370 } 1371 if (jjte000 instanceof RuntimeException) { 1372 {if (true) throw (RuntimeException)jjte000;} 1373 } 1374 if (jjte000 instanceof ParseException) { 1375 {if (true) throw (ParseException)jjte000;} 1376 } 1377 {if (true) throw (RuntimeException)jjte000;} 1378 } finally { 1379 if (jjtc000) { 1380 jjtree.closeNodeScope(jjtn000, true); 1381 } 1382 } 1383 } 1384 1385 final public void FormalParameters() throws ParseException { 1386 /*@bgen(jjtree) FormalParameters */ 1387 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS); 1388 boolean jjtc000 = true; 1389 jjtree.openNodeScope(jjtn000); 1390 try { 1391 jj_consume_token(LPAREN); 1392 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1393 case BOOLEAN: 1394 case BYTE: 1395 case CHAR: 1396 case DOUBLE: 1397 case FINAL: 1398 case FLOAT: 1399 case INT: 1400 case LONG: 1401 case SHORT: 1402 case IDENTIFIER: 1403 FormalParameter(); 1404 label_16: 1405 while (true) { 1406 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1407 case COMMA: 1408 ; 1409 break; 1410 default: 1411 jj_la1[37] = jj_gen; 1412 break label_16; 1413 } 1414 jj_consume_token(COMMA); 1415 FormalParameter(); 1416 } 1417 break; 1418 default: 1419 jj_la1[38] = jj_gen; 1420 ; 1421 } 1422 jj_consume_token(RPAREN); 1423 } catch (Throwable jjte000) { 1424 if (jjtc000) { 1425 jjtree.clearNodeScope(jjtn000); 1426 jjtc000 = false; 1427 } else { 1428 jjtree.popNode(); 1429 } 1430 if (jjte000 instanceof RuntimeException) { 1431 {if (true) throw (RuntimeException)jjte000;} 1432 } 1433 if (jjte000 instanceof ParseException) { 1434 {if (true) throw (ParseException)jjte000;} 1435 } 1436 {if (true) throw (RuntimeException)jjte000;} 1437 } finally { 1438 if (jjtc000) { 1439 jjtree.closeNodeScope(jjtn000, true); 1440 } 1441 } 1442 } 1443 1444 final public void FormalParameter() throws ParseException { 1445 /*@bgen(jjtree) FormalParameter */ 1446 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER); 1447 boolean jjtc000 = true; 1448 jjtree.openNodeScope(jjtn000); 1449 try { 1450 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1451 case FINAL: 1452 jj_consume_token(FINAL); 1453 jjtn000.setFinal(); 1454 break; 1455 default: 1456 jj_la1[39] = jj_gen; 1457 ; 1458 } 1459 Type(); 1460 VariableDeclaratorId(); 1461 } catch (Throwable jjte000) { 1462 if (jjtc000) { 1463 jjtree.clearNodeScope(jjtn000); 1464 jjtc000 = false; 1465 } else { 1466 jjtree.popNode(); 1467 } 1468 if (jjte000 instanceof RuntimeException) { 1469 {if (true) throw (RuntimeException)jjte000;} 1470 } 1471 if (jjte000 instanceof ParseException) { 1472 {if (true) throw (ParseException)jjte000;} 1473 } 1474 {if (true) throw (RuntimeException)jjte000;} 1475 } finally { 1476 if (jjtc000) { 1477 jjtree.closeNodeScope(jjtn000, true); 1478 } 1479 } 1480 } 1481 1482 final public void ConstructorDeclaration() throws ParseException { 1483 /*@bgen(jjtree) ConstructorDeclaration */ 1484 ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION); 1485 boolean jjtc000 = true; 1486 jjtree.openNodeScope(jjtn000); 1487 try { 1488 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1489 case PRIVATE: 1490 case PROTECTED: 1491 case PUBLIC: 1492 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1493 case PUBLIC: 1494 jj_consume_token(PUBLIC); 1495 jjtn000.setPublic(); 1496 break; 1497 case PROTECTED: 1498 jj_consume_token(PROTECTED); 1499 jjtn000.setProtected(); 1500 break; 1501 case PRIVATE: 1502 jj_consume_token(PRIVATE); 1503 jjtn000.setPrivate(); 1504 break; 1505 default: 1506 jj_la1[40] = jj_gen; 1507 jj_consume_token(-1); 1508 throw new ParseException(); 1509 } 1510 break; 1511 default: 1512 jj_la1[41] = jj_gen; 1513 ; 1514 } 1515 jj_consume_token(IDENTIFIER); 1516 FormalParameters(); 1517 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1518 case THROWS: 1519 jj_consume_token(THROWS); 1520 NameList(); 1521 break; 1522 default: 1523 jj_la1[42] = jj_gen; 1524 ; 1525 } 1526 jj_consume_token(LBRACE); 1527 if (jj_2_11(2147483647)) { 1528 ExplicitConstructorInvocation(); 1529 } else { 1530 ; 1531 } 1532 label_17: 1533 while (true) { 1534 if (jj_2_12(1)) { 1535 ; 1536 } else { 1537 break label_17; 1538 } 1539 BlockStatement(); 1540 } 1541 jj_consume_token(RBRACE); 1542 } catch (Throwable jjte000) { 1543 if (jjtc000) { 1544 jjtree.clearNodeScope(jjtn000); 1545 jjtc000 = false; 1546 } else { 1547 jjtree.popNode(); 1548 } 1549 if (jjte000 instanceof RuntimeException) { 1550 {if (true) throw (RuntimeException)jjte000;} 1551 } 1552 if (jjte000 instanceof ParseException) { 1553 {if (true) throw (ParseException)jjte000;} 1554 } 1555 {if (true) throw (RuntimeException)jjte000;} 1556 } finally { 1557 if (jjtc000) { 1558 jjtree.closeNodeScope(jjtn000, true); 1559 } 1560 } 1561 } 1562 1563 final public void ExplicitConstructorInvocation() throws ParseException { 1564 /*@bgen(jjtree) ExplicitConstructorInvocation */ 1565 ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION); 1566 boolean jjtc000 = true; 1567 jjtree.openNodeScope(jjtn000); 1568 try { 1569 if (jj_2_14(2147483647)) { 1570 jj_consume_token(THIS); 1571 ((ASTExplicitConstructorInvocation)jjtn000).setIsThis(); 1572 Arguments(); 1573 jj_consume_token(SEMICOLON); 1574 } else { 1575 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1576 case BOOLEAN: 1577 case BYTE: 1578 case CHAR: 1579 case DOUBLE: 1580 case FALSE: 1581 case FLOAT: 1582 case INT: 1583 case LONG: 1584 case NEW: 1585 case NULL: 1586 case SHORT: 1587 case SUPER: 1588 case THIS: 1589 case TRUE: 1590 case VOID: 1591 case INTEGER_LITERAL: 1592 case FLOATING_POINT_LITERAL: 1593 case CHARACTER_LITERAL: 1594 case STRING_LITERAL: 1595 case IDENTIFIER: 1596 case LPAREN: 1597 if (jj_2_13(2)) { 1598 PrimaryExpression(); 1599 jj_consume_token(DOT); 1600 } else { 1601 ; 1602 } 1603 jj_consume_token(SUPER); 1604 ((ASTExplicitConstructorInvocation)jjtn000).setIsSuper(); 1605 Arguments(); 1606 jj_consume_token(SEMICOLON); 1607 break; 1608 default: 1609 jj_la1[43] = jj_gen; 1610 jj_consume_token(-1); 1611 throw new ParseException(); 1612 } 1613 } 1614 } catch (Throwable jjte000) { 1615 if (jjtc000) { 1616 jjtree.clearNodeScope(jjtn000); 1617 jjtc000 = false; 1618 } else { 1619 jjtree.popNode(); 1620 } 1621 if (jjte000 instanceof RuntimeException) { 1622 {if (true) throw (RuntimeException)jjte000;} 1623 } 1624 if (jjte000 instanceof ParseException) { 1625 {if (true) throw (ParseException)jjte000;} 1626 } 1627 {if (true) throw (RuntimeException)jjte000;} 1628 } finally { 1629 if (jjtc000) { 1630 jjtree.closeNodeScope(jjtn000, true); 1631 } 1632 } 1633 } 1634 1635 final public void Initializer() throws ParseException { 1636 /*@bgen(jjtree) Initializer */ 1637 ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER); 1638 boolean jjtc000 = true; 1639 jjtree.openNodeScope(jjtn000); 1640 try { 1641 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1642 case STATIC: 1643 jj_consume_token(STATIC); 1644 jjtn000.setStatic(); 1645 break; 1646 default: 1647 jj_la1[44] = jj_gen; 1648 ; 1649 } 1650 Block(); 1651 } catch (Throwable jjte000) { 1652 if (jjtc000) { 1653 jjtree.clearNodeScope(jjtn000); 1654 jjtc000 = false; 1655 } else { 1656 jjtree.popNode(); 1657 } 1658 if (jjte000 instanceof RuntimeException) { 1659 {if (true) throw (RuntimeException)jjte000;} 1660 } 1661 if (jjte000 instanceof ParseException) { 1662 {if (true) throw (ParseException)jjte000;} 1663 } 1664 {if (true) throw (RuntimeException)jjte000;} 1665 } finally { 1666 if (jjtc000) { 1667 jjtree.closeNodeScope(jjtn000, true); 1668 } 1669 } 1670 } 1671 1672 /* 1673 * Type, name and expression syntax follows. 1674 */ 1675 final public void Type() throws ParseException { 1676 /*@bgen(jjtree) Type */ 1677 ASTType jjtn000 = new ASTType(this, JJTTYPE); 1678 boolean jjtc000 = true; 1679 jjtree.openNodeScope(jjtn000); 1680 try { 1681 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1682 case BOOLEAN: 1683 case BYTE: 1684 case CHAR: 1685 case DOUBLE: 1686 case FLOAT: 1687 case INT: 1688 case LONG: 1689 case SHORT: 1690 PrimitiveType(); 1691 break; 1692 case IDENTIFIER: 1693 Name(); 1694 break; 1695 default: 1696 jj_la1[45] = jj_gen; 1697 jj_consume_token(-1); 1698 throw new ParseException(); 1699 } 1700 label_18: 1701 while (true) { 1702 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1703 case LBRACKET: 1704 ; 1705 break; 1706 default: 1707 jj_la1[46] = jj_gen; 1708 break label_18; 1709 } 1710 jj_consume_token(LBRACKET); 1711 jj_consume_token(RBRACKET); 1712 jjtn000.addDimension(); 1713 jjtn000.setIsArray(); 1714 } 1715 } catch (Throwable jjte000) { 1716 if (jjtc000) { 1717 jjtree.clearNodeScope(jjtn000); 1718 jjtc000 = false; 1719 } else { 1720 jjtree.popNode(); 1721 } 1722 if (jjte000 instanceof RuntimeException) { 1723 {if (true) throw (RuntimeException)jjte000;} 1724 } 1725 if (jjte000 instanceof ParseException) { 1726 {if (true) throw (ParseException)jjte000;} 1727 } 1728 {if (true) throw (RuntimeException)jjte000;} 1729 } finally { 1730 if (jjtc000) { 1731 jjtree.closeNodeScope(jjtn000, true); 1732 } 1733 } 1734 } 1735 1736 final public void PrimitiveType() throws ParseException { 1737 /*@bgen(jjtree) PrimitiveType */ 1738 ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE); 1739 boolean jjtc000 = true; 1740 jjtree.openNodeScope(jjtn000); 1741 try { 1742 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1743 case BOOLEAN: 1744 jj_consume_token(BOOLEAN); 1745 jjtree.closeNodeScope(jjtn000, true); 1746 jjtc000 = false; 1747 jjtn000.setImage("boolean"); 1748 break; 1749 case CHAR: 1750 jj_consume_token(CHAR); 1751 jjtree.closeNodeScope(jjtn000, true); 1752 jjtc000 = false; 1753 jjtn000.setImage("char"); 1754 break; 1755 case BYTE: 1756 jj_consume_token(BYTE); 1757 jjtree.closeNodeScope(jjtn000, true); 1758 jjtc000 = false; 1759 jjtn000.setImage("byte"); 1760 break; 1761 case SHORT: 1762 jj_consume_token(SHORT); 1763 jjtree.closeNodeScope(jjtn000, true); 1764 jjtc000 = false; 1765 jjtn000.setImage("short"); 1766 break; 1767 case INT: 1768 jj_consume_token(INT); 1769 jjtree.closeNodeScope(jjtn000, true); 1770 jjtc000 = false; 1771 jjtn000.setImage("int"); 1772 break; 1773 case LONG: 1774 jj_consume_token(LONG); 1775 jjtree.closeNodeScope(jjtn000, true); 1776 jjtc000 = false; 1777 jjtn000.setImage("long"); 1778 break; 1779 case FLOAT: 1780 jj_consume_token(FLOAT); 1781 jjtree.closeNodeScope(jjtn000, true); 1782 jjtc000 = false; 1783 jjtn000.setImage("float"); 1784 break; 1785 case DOUBLE: 1786 jj_consume_token(DOUBLE); 1787 jjtree.closeNodeScope(jjtn000, true); 1788 jjtc000 = false; 1789 jjtn000.setImage("double"); 1790 break; 1791 default: 1792 jj_la1[47] = jj_gen; 1793 jj_consume_token(-1); 1794 throw new ParseException(); 1795 } 1796 } finally { 1797 if (jjtc000) { 1798 jjtree.closeNodeScope(jjtn000, true); 1799 } 1800 } 1801 } 1802 1803 final public void ResultType() throws ParseException { 1804 /*@bgen(jjtree) ResultType */ 1805 ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE); 1806 boolean jjtc000 = true; 1807 jjtree.openNodeScope(jjtn000); 1808 try { 1809 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1810 case VOID: 1811 jj_consume_token(VOID); 1812 break; 1813 case BOOLEAN: 1814 case BYTE: 1815 case CHAR: 1816 case DOUBLE: 1817 case FLOAT: 1818 case INT: 1819 case LONG: 1820 case SHORT: 1821 case IDENTIFIER: 1822 Type(); 1823 break; 1824 default: 1825 jj_la1[48] = jj_gen; 1826 jj_consume_token(-1); 1827 throw new ParseException(); 1828 } 1829 } catch (Throwable jjte000) { 1830 if (jjtc000) { 1831 jjtree.clearNodeScope(jjtn000); 1832 jjtc000 = false; 1833 } else { 1834 jjtree.popNode(); 1835 } 1836 if (jjte000 instanceof RuntimeException) { 1837 {if (true) throw (RuntimeException)jjte000;} 1838 } 1839 if (jjte000 instanceof ParseException) { 1840 {if (true) throw (ParseException)jjte000;} 1841 } 1842 {if (true) throw (RuntimeException)jjte000;} 1843 } finally { 1844 if (jjtc000) { 1845 jjtree.closeNodeScope(jjtn000, true); 1846 } 1847 } 1848 } 1849 1850 final public void Name() throws ParseException { 1851 /*@bgen(jjtree) Name */ 1852 ASTName jjtn000 = new ASTName(this, JJTNAME); 1853 boolean jjtc000 = true; 1854 jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer(); 1855 Token t = null; 1856 try { 1857 t = jj_consume_token(IDENTIFIER); 1858 jjtn000.testingOnly__setBeginLine( t.beginLine); 1859 jjtn000.testingOnly__setBeginColumn( t.beginColumn); 1860 s.append(t.image); 1861 label_19: 1862 while (true) { 1863 if (jj_2_15(2)) { 1864 ; 1865 } else { 1866 break label_19; 1867 } 1868 jj_consume_token(DOT); 1869 t = jj_consume_token(IDENTIFIER); 1870 s.append("."); 1871 s.append(t.image); 1872 } 1873 jjtree.closeNodeScope(jjtn000, true); 1874 jjtc000 = false; 1875 jjtn000.setImage( s.toString() ); 1876 } finally { 1877 if (jjtc000) { 1878 jjtree.closeNodeScope(jjtn000, true); 1879 } 1880 } 1881 } 1882 1883 final public void NameList() throws ParseException { 1884 /*@bgen(jjtree) NameList */ 1885 ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST); 1886 boolean jjtc000 = true; 1887 jjtree.openNodeScope(jjtn000); 1888 try { 1889 Name(); 1890 label_20: 1891 while (true) { 1892 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1893 case COMMA: 1894 ; 1895 break; 1896 default: 1897 jj_la1[49] = jj_gen; 1898 break label_20; 1899 } 1900 jj_consume_token(COMMA); 1901 Name(); 1902 } 1903 } catch (Throwable jjte000) { 1904 if (jjtc000) { 1905 jjtree.clearNodeScope(jjtn000); 1906 jjtc000 = false; 1907 } else { 1908 jjtree.popNode(); 1909 } 1910 if (jjte000 instanceof RuntimeException) { 1911 {if (true) throw (RuntimeException)jjte000;} 1912 } 1913 if (jjte000 instanceof ParseException) { 1914 {if (true) throw (ParseException)jjte000;} 1915 } 1916 {if (true) throw (RuntimeException)jjte000;} 1917 } finally { 1918 if (jjtc000) { 1919 jjtree.closeNodeScope(jjtn000, true); 1920 } 1921 } 1922 } 1923 1924 /* 1925 * Expression syntax follows. 1926 */ 1927 final public void Expression() throws ParseException { 1928 /*@bgen(jjtree) Expression */ 1929 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION); 1930 boolean jjtc000 = true; 1931 jjtree.openNodeScope(jjtn000); 1932 try { 1933 ConditionalExpression(); 1934 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1935 case ASSIGN: 1936 case PLUSASSIGN: 1937 case MINUSASSIGN: 1938 case STARASSIGN: 1939 case SLASHASSIGN: 1940 case ANDASSIGN: 1941 case ORASSIGN: 1942 case XORASSIGN: 1943 case REMASSIGN: 1944 case LSHIFTASSIGN: 1945 case RSIGNEDSHIFTASSIGN: 1946 case RUNSIGNEDSHIFTASSIGN: 1947 AssignmentOperator(); 1948 Expression(); 1949 break; 1950 default: 1951 jj_la1[50] = jj_gen; 1952 ; 1953 } 1954 } catch (Throwable jjte000) { 1955 if (jjtc000) { 1956 jjtree.clearNodeScope(jjtn000); 1957 jjtc000 = false; 1958 } else { 1959 jjtree.popNode(); 1960 } 1961 if (jjte000 instanceof RuntimeException) { 1962 {if (true) throw (RuntimeException)jjte000;} 1963 } 1964 if (jjte000 instanceof ParseException) { 1965 {if (true) throw (ParseException)jjte000;} 1966 } 1967 {if (true) throw (RuntimeException)jjte000;} 1968 } finally { 1969 if (jjtc000) { 1970 jjtree.closeNodeScope(jjtn000, true); 1971 } 1972 } 1973 } 1974 1975 final public void AssignmentOperator() throws ParseException { 1976 /*@bgen(jjtree) AssignmentOperator */ 1977 ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR); 1978 boolean jjtc000 = true; 1979 jjtree.openNodeScope(jjtn000); 1980 try { 1981 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 1982 case ASSIGN: 1983 jj_consume_token(ASSIGN); 1984 jjtree.closeNodeScope(jjtn000, true); 1985 jjtc000 = false; 1986 jjtn000.setImage("="); 1987 break; 1988 case STARASSIGN: 1989 jj_consume_token(STARASSIGN); 1990 jjtree.closeNodeScope(jjtn000, true); 1991 jjtc000 = false; 1992 jjtn000.setImage("*="); 1993 break; 1994 case SLASHASSIGN: 1995 jj_consume_token(SLASHASSIGN); 1996 jjtree.closeNodeScope(jjtn000, true); 1997 jjtc000 = false; 1998 jjtn000.setImage("/="); 1999 break; 2000 case REMASSIGN: 2001 jj_consume_token(REMASSIGN); 2002 jjtree.closeNodeScope(jjtn000, true); 2003 jjtc000 = false; 2004 jjtn000.setImage("%="); 2005 break; 2006 case PLUSASSIGN: 2007 jj_consume_token(PLUSASSIGN); 2008 jjtree.closeNodeScope(jjtn000, true); 2009 jjtc000 = false; 2010 jjtn000.setImage("+="); 2011 break; 2012 case MINUSASSIGN: 2013 jj_consume_token(MINUSASSIGN); 2014 jjtree.closeNodeScope(jjtn000, true); 2015 jjtc000 = false; 2016 jjtn000.setImage("-="); 2017 break; 2018 case LSHIFTASSIGN: 2019 jj_consume_token(LSHIFTASSIGN); 2020 jjtree.closeNodeScope(jjtn000, true); 2021 jjtc000 = false; 2022 jjtn000.setImage("<<="); 2023 break; 2024 case RSIGNEDSHIFTASSIGN: 2025 jj_consume_token(RSIGNEDSHIFTASSIGN); 2026 jjtree.closeNodeScope(jjtn000, true); 2027 jjtc000 = false; 2028 jjtn000.setImage(">>="); 2029 break; 2030 case RUNSIGNEDSHIFTASSIGN: 2031 jj_consume_token(RUNSIGNEDSHIFTASSIGN); 2032 jjtree.closeNodeScope(jjtn000, true); 2033 jjtc000 = false; 2034 jjtn000.setImage(">>>="); 2035 break; 2036 case ANDASSIGN: 2037 jj_consume_token(ANDASSIGN); 2038 jjtree.closeNodeScope(jjtn000, true); 2039 jjtc000 = false; 2040 jjtn000.setImage("&="); 2041 break; 2042 case XORASSIGN: 2043 jj_consume_token(XORASSIGN); 2044 jjtree.closeNodeScope(jjtn000, true); 2045 jjtc000 = false; 2046 jjtn000.setImage("^="); 2047 break; 2048 case ORASSIGN: 2049 jj_consume_token(ORASSIGN); 2050 jjtree.closeNodeScope(jjtn000, true); 2051 jjtc000 = false; 2052 jjtn000.setImage("|="); 2053 break; 2054 default: 2055 jj_la1[51] = jj_gen; 2056 jj_consume_token(-1); 2057 throw new ParseException(); 2058 } 2059 } finally { 2060 if (jjtc000) { 2061 jjtree.closeNodeScope(jjtn000, true); 2062 } 2063 } 2064 } 2065 2066 final public void ConditionalExpression() throws ParseException { 2067 ConditionalOrExpression(); 2068 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2069 case HOOK: 2070 jj_consume_token(HOOK); 2071 Expression(); 2072 jj_consume_token(COLON); 2073 ConditionalExpression(); 2074 break; 2075 default: 2076 jj_la1[52] = jj_gen; 2077 ; 2078 } 2079 } 2080 2081 final public void ConditionalOrExpression() throws ParseException { 2082 ConditionalAndExpression(); 2083 label_21: 2084 while (true) { 2085 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2086 case SC_OR: 2087 ; 2088 break; 2089 default: 2090 jj_la1[53] = jj_gen; 2091 break label_21; 2092 } 2093 jj_consume_token(SC_OR); 2094 ConditionalAndExpression(); 2095 } 2096 } 2097 2098 final public void ConditionalAndExpression() throws ParseException { 2099 /*@bgen(jjtree) ConditionalAndExpression */ 2100 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION); 2101 boolean jjtc000 = true; 2102 jjtree.openNodeScope(jjtn000); 2103 try { 2104 InclusiveOrExpression(); 2105 label_22: 2106 while (true) { 2107 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2108 case SC_AND: 2109 ; 2110 break; 2111 default: 2112 jj_la1[54] = jj_gen; 2113 break label_22; 2114 } 2115 jj_consume_token(SC_AND); 2116 InclusiveOrExpression(); 2117 } 2118 } catch (Throwable jjte000) { 2119 if (jjtc000) { 2120 jjtree.clearNodeScope(jjtn000); 2121 jjtc000 = false; 2122 } else { 2123 jjtree.popNode(); 2124 } 2125 if (jjte000 instanceof RuntimeException) { 2126 {if (true) throw (RuntimeException)jjte000;} 2127 } 2128 if (jjte000 instanceof ParseException) { 2129 {if (true) throw (ParseException)jjte000;} 2130 } 2131 {if (true) throw (RuntimeException)jjte000;} 2132 } finally { 2133 if (jjtc000) { 2134 jjtree.closeNodeScope(jjtn000, true); 2135 } 2136 } 2137 } 2138 2139 final public void InclusiveOrExpression() throws ParseException { 2140 ExclusiveOrExpression(); 2141 label_23: 2142 while (true) { 2143 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2144 case BIT_OR: 2145 ; 2146 break; 2147 default: 2148 jj_la1[55] = jj_gen; 2149 break label_23; 2150 } 2151 jj_consume_token(BIT_OR); 2152 ExclusiveOrExpression(); 2153 } 2154 } 2155 2156 final public void ExclusiveOrExpression() throws ParseException { 2157 AndExpression(); 2158 label_24: 2159 while (true) { 2160 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2161 case XOR: 2162 ; 2163 break; 2164 default: 2165 jj_la1[56] = jj_gen; 2166 break label_24; 2167 } 2168 jj_consume_token(XOR); 2169 AndExpression(); 2170 } 2171 } 2172 2173 final public void AndExpression() throws ParseException { 2174 EqualityExpression(); 2175 label_25: 2176 while (true) { 2177 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2178 case BIT_AND: 2179 ; 2180 break; 2181 default: 2182 jj_la1[57] = jj_gen; 2183 break label_25; 2184 } 2185 jj_consume_token(BIT_AND); 2186 EqualityExpression(); 2187 } 2188 } 2189 2190 final public void EqualityExpression() throws ParseException { 2191 InstanceOfExpression(); 2192 label_26: 2193 while (true) { 2194 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2195 case EQ: 2196 case NE: 2197 ; 2198 break; 2199 default: 2200 jj_la1[58] = jj_gen; 2201 break label_26; 2202 } 2203 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2204 case EQ: 2205 jj_consume_token(EQ); 2206 break; 2207 case NE: 2208 jj_consume_token(NE); 2209 break; 2210 default: 2211 jj_la1[59] = jj_gen; 2212 jj_consume_token(-1); 2213 throw new ParseException(); 2214 } 2215 InstanceOfExpression(); 2216 } 2217 } 2218 2219 final public void InstanceOfExpression() throws ParseException { 2220 /*@bgen(jjtree) InstanceOfExpression */ 2221 ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION); 2222 boolean jjtc000 = true; 2223 jjtree.openNodeScope(jjtn000); 2224 try { 2225 RelationalExpression(); 2226 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2227 case INSTANCEOF: 2228 jj_consume_token(INSTANCEOF); 2229 Type(); 2230 break; 2231 default: 2232 jj_la1[60] = jj_gen; 2233 ; 2234 } 2235 } catch (Throwable jjte000) { 2236 if (jjtc000) { 2237 jjtree.clearNodeScope(jjtn000); 2238 jjtc000 = false; 2239 } else { 2240 jjtree.popNode(); 2241 } 2242 if (jjte000 instanceof RuntimeException) { 2243 {if (true) throw (RuntimeException)jjte000;} 2244 } 2245 if (jjte000 instanceof ParseException) { 2246 {if (true) throw (ParseException)jjte000;} 2247 } 2248 {if (true) throw (RuntimeException)jjte000;} 2249 } finally { 2250 if (jjtc000) { 2251 jjtree.closeNodeScope(jjtn000, true); 2252 } 2253 } 2254 } 2255 2256 final public void RelationalExpression() throws ParseException { 2257 ShiftExpression(); 2258 label_27: 2259 while (true) { 2260 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2261 case GT: 2262 case LT: 2263 case LE: 2264 case GE: 2265 ; 2266 break; 2267 default: 2268 jj_la1[61] = jj_gen; 2269 break label_27; 2270 } 2271 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2272 case LT: 2273 jj_consume_token(LT); 2274 break; 2275 case GT: 2276 jj_consume_token(GT); 2277 break; 2278 case LE: 2279 jj_consume_token(LE); 2280 break; 2281 case GE: 2282 jj_consume_token(GE); 2283 break; 2284 default: 2285 jj_la1[62] = jj_gen; 2286 jj_consume_token(-1); 2287 throw new ParseException(); 2288 } 2289 ShiftExpression(); 2290 } 2291 } 2292 2293 final public void ShiftExpression() throws ParseException { 2294 AdditiveExpression(); 2295 label_28: 2296 while (true) { 2297 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2298 case LSHIFT: 2299 case RSIGNEDSHIFT: 2300 case RUNSIGNEDSHIFT: 2301 ; 2302 break; 2303 default: 2304 jj_la1[63] = jj_gen; 2305 break label_28; 2306 } 2307 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2308 case LSHIFT: 2309 jj_consume_token(LSHIFT); 2310 break; 2311 case RSIGNEDSHIFT: 2312 jj_consume_token(RSIGNEDSHIFT); 2313 break; 2314 case RUNSIGNEDSHIFT: 2315 jj_consume_token(RUNSIGNEDSHIFT); 2316 break; 2317 default: 2318 jj_la1[64] = jj_gen; 2319 jj_consume_token(-1); 2320 throw new ParseException(); 2321 } 2322 AdditiveExpression(); 2323 } 2324 } 2325 2326 final public void AdditiveExpression() throws ParseException { 2327 MultiplicativeExpression(); 2328 label_29: 2329 while (true) { 2330 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2331 case PLUS: 2332 case MINUS: 2333 ; 2334 break; 2335 default: 2336 jj_la1[65] = jj_gen; 2337 break label_29; 2338 } 2339 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2340 case PLUS: 2341 jj_consume_token(PLUS); 2342 break; 2343 case MINUS: 2344 jj_consume_token(MINUS); 2345 break; 2346 default: 2347 jj_la1[66] = jj_gen; 2348 jj_consume_token(-1); 2349 throw new ParseException(); 2350 } 2351 MultiplicativeExpression(); 2352 } 2353 } 2354 2355 final public void MultiplicativeExpression() throws ParseException { 2356 UnaryExpression(); 2357 label_30: 2358 while (true) { 2359 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2360 case STAR: 2361 case SLASH: 2362 case REM: 2363 ; 2364 break; 2365 default: 2366 jj_la1[67] = jj_gen; 2367 break label_30; 2368 } 2369 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2370 case STAR: 2371 jj_consume_token(STAR); 2372 break; 2373 case SLASH: 2374 jj_consume_token(SLASH); 2375 break; 2376 case REM: 2377 jj_consume_token(REM); 2378 break; 2379 default: 2380 jj_la1[68] = jj_gen; 2381 jj_consume_token(-1); 2382 throw new ParseException(); 2383 } 2384 UnaryExpression(); 2385 } 2386 } 2387 2388 final public void UnaryExpression() throws ParseException { 2389 /*@bgen(jjtree) UnaryExpression */ 2390 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION); 2391 boolean jjtc000 = true; 2392 jjtree.openNodeScope(jjtn000); 2393 try { 2394 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2395 case PLUS: 2396 case MINUS: 2397 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2398 case PLUS: 2399 jj_consume_token(PLUS); 2400 jjtn000.setPositive(); 2401 break; 2402 case MINUS: 2403 jj_consume_token(MINUS); 2404 jjtn000.setNegative(); 2405 break; 2406 default: 2407 jj_la1[69] = jj_gen; 2408 jj_consume_token(-1); 2409 throw new ParseException(); 2410 } 2411 UnaryExpression(); 2412 break; 2413 case INCR: 2414 PreIncrementExpression(); 2415 break; 2416 case DECR: 2417 PreDecrementExpression(); 2418 break; 2419 case BOOLEAN: 2420 case BYTE: 2421 case CHAR: 2422 case DOUBLE: 2423 case FALSE: 2424 case FLOAT: 2425 case INT: 2426 case LONG: 2427 case NEW: 2428 case NULL: 2429 case SHORT: 2430 case SUPER: 2431 case THIS: 2432 case TRUE: 2433 case VOID: 2434 case INTEGER_LITERAL: 2435 case FLOATING_POINT_LITERAL: 2436 case CHARACTER_LITERAL: 2437 case STRING_LITERAL: 2438 case IDENTIFIER: 2439 case LPAREN: 2440 case BANG: 2441 case TILDE: 2442 UnaryExpressionNotPlusMinus(); 2443 break; 2444 default: 2445 jj_la1[70] = jj_gen; 2446 jj_consume_token(-1); 2447 throw new ParseException(); 2448 } 2449 } catch (Throwable jjte000) { 2450 if (jjtc000) { 2451 jjtree.clearNodeScope(jjtn000); 2452 jjtc000 = false; 2453 } else { 2454 jjtree.popNode(); 2455 } 2456 if (jjte000 instanceof RuntimeException) { 2457 {if (true) throw (RuntimeException)jjte000;} 2458 } 2459 if (jjte000 instanceof ParseException) { 2460 {if (true) throw (ParseException)jjte000;} 2461 } 2462 {if (true) throw (RuntimeException)jjte000;} 2463 } finally { 2464 if (jjtc000) { 2465 jjtree.closeNodeScope(jjtn000, true); 2466 } 2467 } 2468 } 2469 2470 final public void PreIncrementExpression() throws ParseException { 2471 /*@bgen(jjtree) PreIncrementExpression */ 2472 ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION); 2473 boolean jjtc000 = true; 2474 jjtree.openNodeScope(jjtn000); 2475 try { 2476 jj_consume_token(INCR); 2477 PrimaryExpression(); 2478 } catch (Throwable jjte000) { 2479 if (jjtc000) { 2480 jjtree.clearNodeScope(jjtn000); 2481 jjtc000 = false; 2482 } else { 2483 jjtree.popNode(); 2484 } 2485 if (jjte000 instanceof RuntimeException) { 2486 {if (true) throw (RuntimeException)jjte000;} 2487 } 2488 if (jjte000 instanceof ParseException) { 2489 {if (true) throw (ParseException)jjte000;} 2490 } 2491 {if (true) throw (RuntimeException)jjte000;} 2492 } finally { 2493 if (jjtc000) { 2494 jjtree.closeNodeScope(jjtn000, true); 2495 } 2496 } 2497 } 2498 2499 final public void PreDecrementExpression() throws ParseException { 2500 /*@bgen(jjtree) PreDecrementExpression */ 2501 ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION); 2502 boolean jjtc000 = true; 2503 jjtree.openNodeScope(jjtn000); 2504 try { 2505 jj_consume_token(DECR); 2506 PrimaryExpression(); 2507 } catch (Throwable jjte000) { 2508 if (jjtc000) { 2509 jjtree.clearNodeScope(jjtn000); 2510 jjtc000 = false; 2511 } else { 2512 jjtree.popNode(); 2513 } 2514 if (jjte000 instanceof RuntimeException) { 2515 {if (true) throw (RuntimeException)jjte000;} 2516 } 2517 if (jjte000 instanceof ParseException) { 2518 {if (true) throw (ParseException)jjte000;} 2519 } 2520 {if (true) throw (RuntimeException)jjte000;} 2521 } finally { 2522 if (jjtc000) { 2523 jjtree.closeNodeScope(jjtn000, true); 2524 } 2525 } 2526 } 2527 2528 final public void UnaryExpressionNotPlusMinus() throws ParseException { 2529 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2530 case BANG: 2531 case TILDE: 2532 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2533 case TILDE: 2534 jj_consume_token(TILDE); 2535 break; 2536 case BANG: 2537 jj_consume_token(BANG); 2538 break; 2539 default: 2540 jj_la1[71] = jj_gen; 2541 jj_consume_token(-1); 2542 throw new ParseException(); 2543 } 2544 UnaryExpression(); 2545 break; 2546 default: 2547 jj_la1[72] = jj_gen; 2548 if (jj_2_16(2147483647)) { 2549 CastExpression(); 2550 } else { 2551 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2552 case BOOLEAN: 2553 case BYTE: 2554 case CHAR: 2555 case DOUBLE: 2556 case FALSE: 2557 case FLOAT: 2558 case INT: 2559 case LONG: 2560 case NEW: 2561 case NULL: 2562 case SHORT: 2563 case SUPER: 2564 case THIS: 2565 case TRUE: 2566 case VOID: 2567 case INTEGER_LITERAL: 2568 case FLOATING_POINT_LITERAL: 2569 case CHARACTER_LITERAL: 2570 case STRING_LITERAL: 2571 case IDENTIFIER: 2572 case LPAREN: 2573 PostfixExpression(); 2574 break; 2575 default: 2576 jj_la1[73] = jj_gen; 2577 jj_consume_token(-1); 2578 throw new ParseException(); 2579 } 2580 } 2581 } 2582 } 2583 2584 // This production is to determine lookahead only. The LOOKAHEAD specifications 2585 // below are not used, but they are there just to indicate that we know about 2586 // this. 2587 final public void CastLookahead() throws ParseException { 2588 /*@bgen(jjtree) CastLookahead */ 2589 ASTCastLookahead jjtn000 = new ASTCastLookahead(this, JJTCASTLOOKAHEAD); 2590 boolean jjtc000 = true; 2591 jjtree.openNodeScope(jjtn000); 2592 try { 2593 if (jj_2_17(2)) { 2594 jj_consume_token(LPAREN); 2595 PrimitiveType(); 2596 } else if (jj_2_18(2147483647)) { 2597 jj_consume_token(LPAREN); 2598 Name(); 2599 jj_consume_token(LBRACKET); 2600 jj_consume_token(RBRACKET); 2601 } else { 2602 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2603 case LPAREN: 2604 jj_consume_token(LPAREN); 2605 Name(); 2606 jj_consume_token(RPAREN); 2607 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2608 case TILDE: 2609 jj_consume_token(TILDE); 2610 break; 2611 case BANG: 2612 jj_consume_token(BANG); 2613 break; 2614 case LPAREN: 2615 jj_consume_token(LPAREN); 2616 break; 2617 case IDENTIFIER: 2618 jj_consume_token(IDENTIFIER); 2619 break; 2620 case THIS: 2621 jj_consume_token(THIS); 2622 break; 2623 case SUPER: 2624 jj_consume_token(SUPER); 2625 break; 2626 case NEW: 2627 jj_consume_token(NEW); 2628 break; 2629 case FALSE: 2630 case NULL: 2631 case TRUE: 2632 case INTEGER_LITERAL: 2633 case FLOATING_POINT_LITERAL: 2634 case CHARACTER_LITERAL: 2635 case STRING_LITERAL: 2636 Literal(); 2637 break; 2638 default: 2639 jj_la1[74] = jj_gen; 2640 jj_consume_token(-1); 2641 throw new ParseException(); 2642 } 2643 break; 2644 default: 2645 jj_la1[75] = jj_gen; 2646 jj_consume_token(-1); 2647 throw new ParseException(); 2648 } 2649 } 2650 } catch (Throwable jjte000) { 2651 if (jjtc000) { 2652 jjtree.clearNodeScope(jjtn000); 2653 jjtc000 = false; 2654 } else { 2655 jjtree.popNode(); 2656 } 2657 if (jjte000 instanceof RuntimeException) { 2658 {if (true) throw (RuntimeException)jjte000;} 2659 } 2660 if (jjte000 instanceof ParseException) { 2661 {if (true) throw (ParseException)jjte000;} 2662 } 2663 {if (true) throw (RuntimeException)jjte000;} 2664 } finally { 2665 if (jjtc000) { 2666 jjtree.closeNodeScope(jjtn000, true); 2667 } 2668 } 2669 } 2670 2671 final public void PostfixExpression() throws ParseException { 2672 PrimaryExpression(); 2673 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2674 case INCR: 2675 case DECR: 2676 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2677 case INCR: 2678 jj_consume_token(INCR); 2679 break; 2680 case DECR: 2681 jj_consume_token(DECR); 2682 break; 2683 default: 2684 jj_la1[76] = jj_gen; 2685 jj_consume_token(-1); 2686 throw new ParseException(); 2687 } 2688 break; 2689 default: 2690 jj_la1[77] = jj_gen; 2691 ; 2692 } 2693 } 2694 2695 final public void CastExpression() throws ParseException { 2696 /*@bgen(jjtree) CastExpression */ 2697 ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION); 2698 boolean jjtc000 = true; 2699 jjtree.openNodeScope(jjtn000); 2700 try { 2701 if (jj_2_19(2147483647)) { 2702 jj_consume_token(LPAREN); 2703 Type(); 2704 jj_consume_token(RPAREN); 2705 UnaryExpression(); 2706 } else { 2707 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2708 case LPAREN: 2709 jj_consume_token(LPAREN); 2710 Type(); 2711 jj_consume_token(RPAREN); 2712 UnaryExpressionNotPlusMinus(); 2713 break; 2714 default: 2715 jj_la1[78] = jj_gen; 2716 jj_consume_token(-1); 2717 throw new ParseException(); 2718 } 2719 } 2720 } catch (Throwable jjte000) { 2721 if (jjtc000) { 2722 jjtree.clearNodeScope(jjtn000); 2723 jjtc000 = false; 2724 } else { 2725 jjtree.popNode(); 2726 } 2727 if (jjte000 instanceof RuntimeException) { 2728 {if (true) throw (RuntimeException)jjte000;} 2729 } 2730 if (jjte000 instanceof ParseException) { 2731 {if (true) throw (ParseException)jjte000;} 2732 } 2733 {if (true) throw (RuntimeException)jjte000;} 2734 } finally { 2735 if (jjtc000) { 2736 jjtree.closeNodeScope(jjtn000, true); 2737 } 2738 } 2739 } 2740 2741 final public void PrimaryExpression() throws ParseException { 2742 /*@bgen(jjtree) PrimaryExpression */ 2743 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION); 2744 boolean jjtc000 = true; 2745 jjtree.openNodeScope(jjtn000); 2746 try { 2747 PrimaryPrefix(); 2748 label_31: 2749 while (true) { 2750 if (jj_2_20(2)) { 2751 ; 2752 } else { 2753 break label_31; 2754 } 2755 PrimarySuffix(); 2756 } 2757 } catch (Throwable jjte000) { 2758 if (jjtc000) { 2759 jjtree.clearNodeScope(jjtn000); 2760 jjtc000 = false; 2761 } else { 2762 jjtree.popNode(); 2763 } 2764 if (jjte000 instanceof RuntimeException) { 2765 {if (true) throw (RuntimeException)jjte000;} 2766 } 2767 if (jjte000 instanceof ParseException) { 2768 {if (true) throw (ParseException)jjte000;} 2769 } 2770 {if (true) throw (RuntimeException)jjte000;} 2771 } finally { 2772 if (jjtc000) { 2773 jjtree.closeNodeScope(jjtn000, true); 2774 } 2775 } 2776 } 2777 2778 final public void PrimaryPrefix() throws ParseException { 2779 /*@bgen(jjtree) PrimaryPrefix */ 2780 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX); 2781 boolean jjtc000 = true; 2782 jjtree.openNodeScope(jjtn000);Token t = null; 2783 try { 2784 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2785 case FALSE: 2786 case NULL: 2787 case TRUE: 2788 case INTEGER_LITERAL: 2789 case FLOATING_POINT_LITERAL: 2790 case CHARACTER_LITERAL: 2791 case STRING_LITERAL: 2792 Literal(); 2793 break; 2794 case THIS: 2795 jj_consume_token(THIS); 2796 jjtree.closeNodeScope(jjtn000, true); 2797 jjtc000 = false; 2798 jjtn000.setUsesThisModifier(); 2799 break; 2800 case SUPER: 2801 jj_consume_token(SUPER); 2802 jjtn000.setUsesSuperModifier(); 2803 jj_consume_token(DOT); 2804 t = jj_consume_token(IDENTIFIER); 2805 jjtree.closeNodeScope(jjtn000, true); 2806 jjtc000 = false; 2807 jjtn000.setImage(t.image); 2808 break; 2809 case LPAREN: 2810 jj_consume_token(LPAREN); 2811 Expression(); 2812 jj_consume_token(RPAREN); 2813 break; 2814 case NEW: 2815 AllocationExpression(); 2816 break; 2817 default: 2818 jj_la1[79] = jj_gen; 2819 if (jj_2_21(2147483647)) { 2820 ResultType(); 2821 jj_consume_token(DOT); 2822 jj_consume_token(CLASS); 2823 } else { 2824 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2825 case IDENTIFIER: 2826 Name(); 2827 break; 2828 default: 2829 jj_la1[80] = jj_gen; 2830 jj_consume_token(-1); 2831 throw new ParseException(); 2832 } 2833 } 2834 } 2835 } catch (Throwable jjte000) { 2836 if (jjtc000) { 2837 jjtree.clearNodeScope(jjtn000); 2838 jjtc000 = false; 2839 } else { 2840 jjtree.popNode(); 2841 } 2842 if (jjte000 instanceof RuntimeException) { 2843 {if (true) throw (RuntimeException)jjte000;} 2844 } 2845 if (jjte000 instanceof ParseException) { 2846 {if (true) throw (ParseException)jjte000;} 2847 } 2848 {if (true) throw (RuntimeException)jjte000;} 2849 } finally { 2850 if (jjtc000) { 2851 jjtree.closeNodeScope(jjtn000, true); 2852 } 2853 } 2854 } 2855 2856 final public void PrimarySuffix() throws ParseException { 2857 /*@bgen(jjtree) PrimarySuffix */ 2858 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX); 2859 boolean jjtc000 = true; 2860 jjtree.openNodeScope(jjtn000);String s = null; 2861 Token t = null; 2862 try { 2863 if (jj_2_22(2)) { 2864 jj_consume_token(DOT); 2865 jj_consume_token(THIS); 2866 } else if (jj_2_23(2)) { 2867 jj_consume_token(DOT); 2868 jj_consume_token(SUPER); 2869 } else if (jj_2_24(2)) { 2870 jj_consume_token(DOT); 2871 AllocationExpression(); 2872 } else { 2873 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2874 case LBRACKET: 2875 jj_consume_token(LBRACKET); 2876 Expression(); 2877 jj_consume_token(RBRACKET); 2878 break; 2879 case DOT: 2880 jj_consume_token(DOT); 2881 t = jj_consume_token(IDENTIFIER); 2882 s = t.image; 2883 jjtree.closeNodeScope(jjtn000, true); 2884 jjtc000 = false; 2885 jjtn000.setImage(s); 2886 break; 2887 case LPAREN: 2888 Arguments(); 2889 jjtree.closeNodeScope(jjtn000, true); 2890 jjtc000 = false; 2891 jjtn000.setIsArguments(); 2892 break; 2893 default: 2894 jj_la1[81] = jj_gen; 2895 jj_consume_token(-1); 2896 throw new ParseException(); 2897 } 2898 } 2899 } catch (Throwable jjte000) { 2900 if (jjtc000) { 2901 jjtree.clearNodeScope(jjtn000); 2902 jjtc000 = false; 2903 } else { 2904 jjtree.popNode(); 2905 } 2906 if (jjte000 instanceof RuntimeException) { 2907 {if (true) throw (RuntimeException)jjte000;} 2908 } 2909 if (jjte000 instanceof ParseException) { 2910 {if (true) throw (ParseException)jjte000;} 2911 } 2912 {if (true) throw (RuntimeException)jjte000;} 2913 } finally { 2914 if (jjtc000) { 2915 jjtree.closeNodeScope(jjtn000, true); 2916 } 2917 } 2918 } 2919 2920 final public void Literal() throws ParseException { 2921 /*@bgen(jjtree) Literal */ 2922 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL); 2923 boolean jjtc000 = true; 2924 jjtree.openNodeScope(jjtn000); 2925 try { 2926 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2927 case INTEGER_LITERAL: 2928 Token t = null; 2929 t = jj_consume_token(INTEGER_LITERAL); 2930 jjtree.closeNodeScope(jjtn000, true); 2931 jjtc000 = false; 2932 jjtn000.setImage(t.image); 2933 break; 2934 case FLOATING_POINT_LITERAL: 2935 t = jj_consume_token(FLOATING_POINT_LITERAL); 2936 jjtree.closeNodeScope(jjtn000, true); 2937 jjtc000 = false; 2938 jjtn000.setImage(t.image); 2939 break; 2940 case CHARACTER_LITERAL: 2941 t = jj_consume_token(CHARACTER_LITERAL); 2942 jjtree.closeNodeScope(jjtn000, true); 2943 jjtc000 = false; 2944 jjtn000.setImage(t.image); 2945 break; 2946 case STRING_LITERAL: 2947 t = jj_consume_token(STRING_LITERAL); 2948 jjtree.closeNodeScope(jjtn000, true); 2949 jjtc000 = false; 2950 jjtn000.setImage(t.image); 2951 break; 2952 case FALSE: 2953 case TRUE: 2954 BooleanLiteral(); 2955 break; 2956 case NULL: 2957 NullLiteral(); 2958 break; 2959 default: 2960 jj_la1[82] = jj_gen; 2961 jj_consume_token(-1); 2962 throw new ParseException(); 2963 } 2964 } catch (Throwable jjte000) { 2965 if (jjtc000) { 2966 jjtree.clearNodeScope(jjtn000); 2967 jjtc000 = false; 2968 } else { 2969 jjtree.popNode(); 2970 } 2971 if (jjte000 instanceof RuntimeException) { 2972 {if (true) throw (RuntimeException)jjte000;} 2973 } 2974 if (jjte000 instanceof ParseException) { 2975 {if (true) throw (ParseException)jjte000;} 2976 } 2977 {if (true) throw (RuntimeException)jjte000;} 2978 } finally { 2979 if (jjtc000) { 2980 jjtree.closeNodeScope(jjtn000, true); 2981 } 2982 } 2983 } 2984 2985 final public void BooleanLiteral() throws ParseException { 2986 /*@bgen(jjtree) BooleanLiteral */ 2987 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL); 2988 boolean jjtc000 = true; 2989 jjtree.openNodeScope(jjtn000); 2990 try { 2991 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 2992 case TRUE: 2993 jj_consume_token(TRUE); 2994 jjtree.closeNodeScope(jjtn000, true); 2995 jjtc000 = false; 2996 jjtn000.setTrue(); 2997 break; 2998 case FALSE: 2999 jj_consume_token(FALSE); 3000 break; 3001 default: 3002 jj_la1[83] = jj_gen; 3003 jj_consume_token(-1); 3004 throw new ParseException(); 3005 } 3006 } finally { 3007 if (jjtc000) { 3008 jjtree.closeNodeScope(jjtn000, true); 3009 } 3010 } 3011 } 3012 3013 final public void NullLiteral() throws ParseException { 3014 /*@bgen(jjtree) NullLiteral */ 3015 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL); 3016 boolean jjtc000 = true; 3017 jjtree.openNodeScope(jjtn000); 3018 try { 3019 jj_consume_token(NULL); 3020 } finally { 3021 if (jjtc000) { 3022 jjtree.closeNodeScope(jjtn000, true); 3023 } 3024 } 3025 } 3026 3027 final public void Arguments() throws ParseException { 3028 /*@bgen(jjtree) Arguments */ 3029 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS); 3030 boolean jjtc000 = true; 3031 jjtree.openNodeScope(jjtn000); 3032 try { 3033 jj_consume_token(LPAREN); 3034 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3035 case BOOLEAN: 3036 case BYTE: 3037 case CHAR: 3038 case DOUBLE: 3039 case FALSE: 3040 case FLOAT: 3041 case INT: 3042 case LONG: 3043 case NEW: 3044 case NULL: 3045 case SHORT: 3046 case SUPER: 3047 case THIS: 3048 case TRUE: 3049 case VOID: 3050 case INTEGER_LITERAL: 3051 case FLOATING_POINT_LITERAL: 3052 case CHARACTER_LITERAL: 3053 case STRING_LITERAL: 3054 case IDENTIFIER: 3055 case LPAREN: 3056 case BANG: 3057 case TILDE: 3058 case INCR: 3059 case DECR: 3060 case PLUS: 3061 case MINUS: 3062 ArgumentList(); 3063 break; 3064 default: 3065 jj_la1[84] = jj_gen; 3066 ; 3067 } 3068 jj_consume_token(RPAREN); 3069 } catch (Throwable jjte000) { 3070 if (jjtc000) { 3071 jjtree.clearNodeScope(jjtn000); 3072 jjtc000 = false; 3073 } else { 3074 jjtree.popNode(); 3075 } 3076 if (jjte000 instanceof RuntimeException) { 3077 {if (true) throw (RuntimeException)jjte000;} 3078 } 3079 if (jjte000 instanceof ParseException) { 3080 {if (true) throw (ParseException)jjte000;} 3081 } 3082 {if (true) throw (RuntimeException)jjte000;} 3083 } finally { 3084 if (jjtc000) { 3085 jjtree.closeNodeScope(jjtn000, true); 3086 } 3087 } 3088 } 3089 3090 final public void ArgumentList() throws ParseException { 3091 /*@bgen(jjtree) ArgumentList */ 3092 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST); 3093 boolean jjtc000 = true; 3094 jjtree.openNodeScope(jjtn000); 3095 try { 3096 Expression(); 3097 label_32: 3098 while (true) { 3099 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3100 case COMMA: 3101 ; 3102 break; 3103 default: 3104 jj_la1[85] = jj_gen; 3105 break label_32; 3106 } 3107 jj_consume_token(COMMA); 3108 Expression(); 3109 } 3110 } catch (Throwable jjte000) { 3111 if (jjtc000) { 3112 jjtree.clearNodeScope(jjtn000); 3113 jjtc000 = false; 3114 } else { 3115 jjtree.popNode(); 3116 } 3117 if (jjte000 instanceof RuntimeException) { 3118 {if (true) throw (RuntimeException)jjte000;} 3119 } 3120 if (jjte000 instanceof ParseException) { 3121 {if (true) throw (ParseException)jjte000;} 3122 } 3123 {if (true) throw (RuntimeException)jjte000;} 3124 } finally { 3125 if (jjtc000) { 3126 jjtree.closeNodeScope(jjtn000, true); 3127 } 3128 } 3129 } 3130 3131 final public void AllocationExpression() throws ParseException { 3132 /*@bgen(jjtree) AllocationExpression */ 3133 ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION); 3134 boolean jjtc000 = true; 3135 jjtree.openNodeScope(jjtn000); 3136 try { 3137 if (jj_2_25(2)) { 3138 jj_consume_token(NEW); 3139 PrimitiveType(); 3140 ArrayDimsAndInits(); 3141 } else { 3142 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3143 case NEW: 3144 jj_consume_token(NEW); 3145 Name(); 3146 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3147 case LBRACKET: 3148 ArrayDimsAndInits(); 3149 break; 3150 case LPAREN: 3151 Arguments(); 3152 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3153 case LBRACE: 3154 ClassBody(); 3155 break; 3156 default: 3157 jj_la1[86] = jj_gen; 3158 ; 3159 } 3160 break; 3161 default: 3162 jj_la1[87] = jj_gen; 3163 jj_consume_token(-1); 3164 throw new ParseException(); 3165 } 3166 break; 3167 default: 3168 jj_la1[88] = jj_gen; 3169 jj_consume_token(-1); 3170 throw new ParseException(); 3171 } 3172 } 3173 } catch (Throwable jjte000) { 3174 if (jjtc000) { 3175 jjtree.clearNodeScope(jjtn000); 3176 jjtc000 = false; 3177 } else { 3178 jjtree.popNode(); 3179 } 3180 if (jjte000 instanceof RuntimeException) { 3181 {if (true) throw (RuntimeException)jjte000;} 3182 } 3183 if (jjte000 instanceof ParseException) { 3184 {if (true) throw (ParseException)jjte000;} 3185 } 3186 {if (true) throw (RuntimeException)jjte000;} 3187 } finally { 3188 if (jjtc000) { 3189 jjtree.closeNodeScope(jjtn000, true); 3190 } 3191 } 3192 } 3193 3194 /* 3195 * The second LOOKAHEAD specification below is to parse to PrimarySuffix 3196 * if there is an expression between the "[...]". 3197 */ 3198 final public void ArrayDimsAndInits() throws ParseException { 3199 /*@bgen(jjtree) ArrayDimsAndInits */ 3200 ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS); 3201 boolean jjtc000 = true; 3202 jjtree.openNodeScope(jjtn000); 3203 try { 3204 if (jj_2_28(2)) { 3205 label_33: 3206 while (true) { 3207 jj_consume_token(LBRACKET); 3208 Expression(); 3209 jj_consume_token(RBRACKET); 3210 if (jj_2_26(2)) { 3211 ; 3212 } else { 3213 break label_33; 3214 } 3215 } 3216 label_34: 3217 while (true) { 3218 if (jj_2_27(2)) { 3219 ; 3220 } else { 3221 break label_34; 3222 } 3223 jj_consume_token(LBRACKET); 3224 jj_consume_token(RBRACKET); 3225 } 3226 } else { 3227 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3228 case LBRACKET: 3229 label_35: 3230 while (true) { 3231 jj_consume_token(LBRACKET); 3232 jj_consume_token(RBRACKET); 3233 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3234 case LBRACKET: 3235 ; 3236 break; 3237 default: 3238 jj_la1[89] = jj_gen; 3239 break label_35; 3240 } 3241 } 3242 ArrayInitializer(); 3243 break; 3244 default: 3245 jj_la1[90] = jj_gen; 3246 jj_consume_token(-1); 3247 throw new ParseException(); 3248 } 3249 } 3250 } catch (Throwable jjte000) { 3251 if (jjtc000) { 3252 jjtree.clearNodeScope(jjtn000); 3253 jjtc000 = false; 3254 } else { 3255 jjtree.popNode(); 3256 } 3257 if (jjte000 instanceof RuntimeException) { 3258 {if (true) throw (RuntimeException)jjte000;} 3259 } 3260 if (jjte000 instanceof ParseException) { 3261 {if (true) throw (ParseException)jjte000;} 3262 } 3263 {if (true) throw (RuntimeException)jjte000;} 3264 } finally { 3265 if (jjtc000) { 3266 jjtree.closeNodeScope(jjtn000, true); 3267 } 3268 } 3269 } 3270 3271 /* 3272 * Statement syntax follows. 3273 */ 3274 final public void Statement() throws ParseException { 3275 /*@bgen(jjtree) Statement */ 3276 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT); 3277 boolean jjtc000 = true; 3278 jjtree.openNodeScope(jjtn000); 3279 try { 3280 if (isNextTokenAnAssert()) { 3281 AssertStatement(); 3282 } else if (jj_2_29(2)) { 3283 LabeledStatement(); 3284 } else { 3285 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3286 case LBRACE: 3287 Block(); 3288 break; 3289 case SEMICOLON: 3290 EmptyStatement(); 3291 break; 3292 case BOOLEAN: 3293 case BYTE: 3294 case CHAR: 3295 case DOUBLE: 3296 case FALSE: 3297 case FLOAT: 3298 case INT: 3299 case LONG: 3300 case NEW: 3301 case NULL: 3302 case SHORT: 3303 case SUPER: 3304 case THIS: 3305 case TRUE: 3306 case VOID: 3307 case INTEGER_LITERAL: 3308 case FLOATING_POINT_LITERAL: 3309 case CHARACTER_LITERAL: 3310 case STRING_LITERAL: 3311 case IDENTIFIER: 3312 case LPAREN: 3313 case INCR: 3314 case DECR: 3315 StatementExpression(); 3316 jj_consume_token(SEMICOLON); 3317 break; 3318 case SWITCH: 3319 SwitchStatement(); 3320 break; 3321 case IF: 3322 IfStatement(); 3323 break; 3324 case WHILE: 3325 WhileStatement(); 3326 break; 3327 case DO: 3328 DoStatement(); 3329 break; 3330 case FOR: 3331 ForStatement(); 3332 break; 3333 case BREAK: 3334 BreakStatement(); 3335 break; 3336 case CONTINUE: 3337 ContinueStatement(); 3338 break; 3339 case RETURN: 3340 ReturnStatement(); 3341 break; 3342 case THROW: 3343 ThrowStatement(); 3344 break; 3345 case SYNCHRONIZED: 3346 SynchronizedStatement(); 3347 break; 3348 case TRY: 3349 TryStatement(); 3350 break; 3351 default: 3352 jj_la1[91] = jj_gen; 3353 jj_consume_token(-1); 3354 throw new ParseException(); 3355 } 3356 } 3357 } catch (Throwable jjte000) { 3358 if (jjtc000) { 3359 jjtree.clearNodeScope(jjtn000); 3360 jjtc000 = false; 3361 } else { 3362 jjtree.popNode(); 3363 } 3364 if (jjte000 instanceof RuntimeException) { 3365 {if (true) throw (RuntimeException)jjte000;} 3366 } 3367 if (jjte000 instanceof ParseException) { 3368 {if (true) throw (ParseException)jjte000;} 3369 } 3370 {if (true) throw (RuntimeException)jjte000;} 3371 } finally { 3372 if (jjtc000) { 3373 jjtree.closeNodeScope(jjtn000, true); 3374 } 3375 } 3376 } 3377 3378 final public void LabeledStatement() throws ParseException { 3379 /*@bgen(jjtree) LabeledStatement */ 3380 ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT); 3381 boolean jjtc000 = true; 3382 jjtree.openNodeScope(jjtn000); 3383 try { 3384 jj_consume_token(IDENTIFIER); 3385 jj_consume_token(COLON); 3386 Statement(); 3387 } catch (Throwable jjte000) { 3388 if (jjtc000) { 3389 jjtree.clearNodeScope(jjtn000); 3390 jjtc000 = false; 3391 } else { 3392 jjtree.popNode(); 3393 } 3394 if (jjte000 instanceof RuntimeException) { 3395 {if (true) throw (RuntimeException)jjte000;} 3396 } 3397 if (jjte000 instanceof ParseException) { 3398 {if (true) throw (ParseException)jjte000;} 3399 } 3400 {if (true) throw (RuntimeException)jjte000;} 3401 } finally { 3402 if (jjtc000) { 3403 jjtree.closeNodeScope(jjtn000, true); 3404 } 3405 } 3406 } 3407 3408 final public void Block() throws ParseException { 3409 /*@bgen(jjtree) Block */ 3410 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK); 3411 boolean jjtc000 = true; 3412 jjtree.openNodeScope(jjtn000); 3413 try { 3414 jj_consume_token(LBRACE); 3415 label_36: 3416 while (true) { 3417 if (jj_2_30(1)) { 3418 ; 3419 } else { 3420 break label_36; 3421 } 3422 BlockStatement(); 3423 } 3424 jj_consume_token(RBRACE); 3425 } catch (Throwable jjte000) { 3426 if (jjtc000) { 3427 jjtree.clearNodeScope(jjtn000); 3428 jjtc000 = false; 3429 } else { 3430 jjtree.popNode(); 3431 } 3432 if (jjte000 instanceof RuntimeException) { 3433 {if (true) throw (RuntimeException)jjte000;} 3434 } 3435 if (jjte000 instanceof ParseException) { 3436 {if (true) throw (ParseException)jjte000;} 3437 } 3438 {if (true) throw (RuntimeException)jjte000;} 3439 } finally { 3440 if (jjtc000) { 3441 jjtree.closeNodeScope(jjtn000, true); 3442 } 3443 } 3444 } 3445 3446 final public void BlockStatement() throws ParseException { 3447 /*@bgen(jjtree) BlockStatement */ 3448 ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT); 3449 boolean jjtc000 = true; 3450 jjtree.openNodeScope(jjtn000); 3451 try { 3452 if (isNextTokenAnAssert()) { 3453 Statement(); 3454 } else if (jj_2_31(2147483647)) { 3455 LocalVariableDeclaration(); 3456 jj_consume_token(SEMICOLON); 3457 } else { 3458 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3459 case FINAL: 3460 jj_consume_token(FINAL); 3461 TypeDeclaration(); 3462 break; 3463 default: 3464 jj_la1[92] = jj_gen; 3465 if (jj_2_32(1)) { 3466 Statement(); 3467 } else { 3468 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3469 case CLASS: 3470 UnmodifiedClassDeclaration(); 3471 break; 3472 case INTERFACE: 3473 UnmodifiedInterfaceDeclaration(); 3474 break; 3475 default: 3476 jj_la1[93] = jj_gen; 3477 jj_consume_token(-1); 3478 throw new ParseException(); 3479 } 3480 } 3481 } 3482 } 3483 } catch (Throwable jjte000) { 3484 if (jjtc000) { 3485 jjtree.clearNodeScope(jjtn000); 3486 jjtc000 = false; 3487 } else { 3488 jjtree.popNode(); 3489 } 3490 if (jjte000 instanceof RuntimeException) { 3491 {if (true) throw (RuntimeException)jjte000;} 3492 } 3493 if (jjte000 instanceof ParseException) { 3494 {if (true) throw (ParseException)jjte000;} 3495 } 3496 {if (true) throw (RuntimeException)jjte000;} 3497 } finally { 3498 if (jjtc000) { 3499 jjtree.closeNodeScope(jjtn000, true); 3500 } 3501 } 3502 } 3503 3504 final public void LocalVariableDeclaration() throws ParseException { 3505 /*@bgen(jjtree) LocalVariableDeclaration */ 3506 ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION); 3507 boolean jjtc000 = true; 3508 jjtree.openNodeScope(jjtn000); 3509 try { 3510 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3511 case FINAL: 3512 jj_consume_token(FINAL); 3513 jjtn000.setFinal(); 3514 break; 3515 default: 3516 jj_la1[94] = jj_gen; 3517 ; 3518 } 3519 Type(); 3520 VariableDeclarator(); 3521 label_37: 3522 while (true) { 3523 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3524 case COMMA: 3525 ; 3526 break; 3527 default: 3528 jj_la1[95] = jj_gen; 3529 break label_37; 3530 } 3531 jj_consume_token(COMMA); 3532 VariableDeclarator(); 3533 } 3534 } catch (Throwable jjte000) { 3535 if (jjtc000) { 3536 jjtree.clearNodeScope(jjtn000); 3537 jjtc000 = false; 3538 } else { 3539 jjtree.popNode(); 3540 } 3541 if (jjte000 instanceof RuntimeException) { 3542 {if (true) throw (RuntimeException)jjte000;} 3543 } 3544 if (jjte000 instanceof ParseException) { 3545 {if (true) throw (ParseException)jjte000;} 3546 } 3547 {if (true) throw (RuntimeException)jjte000;} 3548 } finally { 3549 if (jjtc000) { 3550 jjtree.closeNodeScope(jjtn000, true); 3551 } 3552 } 3553 } 3554 3555 final public void EmptyStatement() throws ParseException { 3556 /*@bgen(jjtree) EmptyStatement */ 3557 ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT); 3558 boolean jjtc000 = true; 3559 jjtree.openNodeScope(jjtn000); 3560 try { 3561 jj_consume_token(SEMICOLON); 3562 } finally { 3563 if (jjtc000) { 3564 jjtree.closeNodeScope(jjtn000, true); 3565 } 3566 } 3567 } 3568 3569 final public void StatementExpression() throws ParseException { 3570 /*@bgen(jjtree) StatementExpression */ 3571 ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION); 3572 boolean jjtc000 = true; 3573 jjtree.openNodeScope(jjtn000); 3574 try { 3575 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3576 case INCR: 3577 PreIncrementExpression(); 3578 break; 3579 case DECR: 3580 PreDecrementExpression(); 3581 break; 3582 case BOOLEAN: 3583 case BYTE: 3584 case CHAR: 3585 case DOUBLE: 3586 case FALSE: 3587 case FLOAT: 3588 case INT: 3589 case LONG: 3590 case NEW: 3591 case NULL: 3592 case SHORT: 3593 case SUPER: 3594 case THIS: 3595 case TRUE: 3596 case VOID: 3597 case INTEGER_LITERAL: 3598 case FLOATING_POINT_LITERAL: 3599 case CHARACTER_LITERAL: 3600 case STRING_LITERAL: 3601 case IDENTIFIER: 3602 case LPAREN: 3603 PrimaryExpression(); 3604 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3605 case ASSIGN: 3606 case INCR: 3607 case DECR: 3608 case PLUSASSIGN: 3609 case MINUSASSIGN: 3610 case STARASSIGN: 3611 case SLASHASSIGN: 3612 case ANDASSIGN: 3613 case ORASSIGN: 3614 case XORASSIGN: 3615 case REMASSIGN: 3616 case LSHIFTASSIGN: 3617 case RSIGNEDSHIFTASSIGN: 3618 case RUNSIGNEDSHIFTASSIGN: 3619 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3620 case INCR: 3621 jj_consume_token(INCR); 3622 break; 3623 case DECR: 3624 jj_consume_token(DECR); 3625 break; 3626 case ASSIGN: 3627 case PLUSASSIGN: 3628 case MINUSASSIGN: 3629 case STARASSIGN: 3630 case SLASHASSIGN: 3631 case ANDASSIGN: 3632 case ORASSIGN: 3633 case XORASSIGN: 3634 case REMASSIGN: 3635 case LSHIFTASSIGN: 3636 case RSIGNEDSHIFTASSIGN: 3637 case RUNSIGNEDSHIFTASSIGN: 3638 AssignmentOperator(); 3639 Expression(); 3640 break; 3641 default: 3642 jj_la1[96] = jj_gen; 3643 jj_consume_token(-1); 3644 throw new ParseException(); 3645 } 3646 break; 3647 default: 3648 jj_la1[97] = jj_gen; 3649 ; 3650 } 3651 break; 3652 default: 3653 jj_la1[98] = jj_gen; 3654 jj_consume_token(-1); 3655 throw new ParseException(); 3656 } 3657 } catch (Throwable jjte000) { 3658 if (jjtc000) { 3659 jjtree.clearNodeScope(jjtn000); 3660 jjtc000 = false; 3661 } else { 3662 jjtree.popNode(); 3663 } 3664 if (jjte000 instanceof RuntimeException) { 3665 {if (true) throw (RuntimeException)jjte000;} 3666 } 3667 if (jjte000 instanceof ParseException) { 3668 {if (true) throw (ParseException)jjte000;} 3669 } 3670 {if (true) throw (RuntimeException)jjte000;} 3671 } finally { 3672 if (jjtc000) { 3673 jjtree.closeNodeScope(jjtn000, true); 3674 } 3675 } 3676 } 3677 3678 final public void SwitchStatement() throws ParseException { 3679 /*@bgen(jjtree) SwitchStatement */ 3680 ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT); 3681 boolean jjtc000 = true; 3682 jjtree.openNodeScope(jjtn000); 3683 try { 3684 jj_consume_token(SWITCH); 3685 jj_consume_token(LPAREN); 3686 Expression(); 3687 jj_consume_token(RPAREN); 3688 jj_consume_token(LBRACE); 3689 label_38: 3690 while (true) { 3691 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3692 case CASE: 3693 case _DEFAULT: 3694 ; 3695 break; 3696 default: 3697 jj_la1[99] = jj_gen; 3698 break label_38; 3699 } 3700 SwitchLabel(); 3701 label_39: 3702 while (true) { 3703 if (jj_2_33(1)) { 3704 ; 3705 } else { 3706 break label_39; 3707 } 3708 BlockStatement(); 3709 } 3710 } 3711 jj_consume_token(RBRACE); 3712 } catch (Throwable jjte000) { 3713 if (jjtc000) { 3714 jjtree.clearNodeScope(jjtn000); 3715 jjtc000 = false; 3716 } else { 3717 jjtree.popNode(); 3718 } 3719 if (jjte000 instanceof RuntimeException) { 3720 {if (true) throw (RuntimeException)jjte000;} 3721 } 3722 if (jjte000 instanceof ParseException) { 3723 {if (true) throw (ParseException)jjte000;} 3724 } 3725 {if (true) throw (RuntimeException)jjte000;} 3726 } finally { 3727 if (jjtc000) { 3728 jjtree.closeNodeScope(jjtn000, true); 3729 } 3730 } 3731 } 3732 3733 final public void SwitchLabel() throws ParseException { 3734 /*@bgen(jjtree) SwitchLabel */ 3735 ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL); 3736 boolean jjtc000 = true; 3737 jjtree.openNodeScope(jjtn000); 3738 try { 3739 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3740 case CASE: 3741 jj_consume_token(CASE); 3742 Expression(); 3743 jj_consume_token(COLON); 3744 break; 3745 case _DEFAULT: 3746 jj_consume_token(_DEFAULT); 3747 jj_consume_token(COLON); 3748 break; 3749 default: 3750 jj_la1[100] = jj_gen; 3751 jj_consume_token(-1); 3752 throw new ParseException(); 3753 } 3754 } catch (Throwable jjte000) { 3755 if (jjtc000) { 3756 jjtree.clearNodeScope(jjtn000); 3757 jjtc000 = false; 3758 } else { 3759 jjtree.popNode(); 3760 } 3761 if (jjte000 instanceof RuntimeException) { 3762 {if (true) throw (RuntimeException)jjte000;} 3763 } 3764 if (jjte000 instanceof ParseException) { 3765 {if (true) throw (ParseException)jjte000;} 3766 } 3767 {if (true) throw (RuntimeException)jjte000;} 3768 } finally { 3769 if (jjtc000) { 3770 jjtree.closeNodeScope(jjtn000, true); 3771 } 3772 } 3773 } 3774 3775 final public void IfStatement() throws ParseException { 3776 /*@bgen(jjtree) IfStatement */ 3777 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT); 3778 boolean jjtc000 = true; 3779 jjtree.openNodeScope(jjtn000);boolean hasElse = false; 3780 try { 3781 jj_consume_token(IF); 3782 jj_consume_token(LPAREN); 3783 Expression(); 3784 jj_consume_token(RPAREN); 3785 Statement(); 3786 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3787 case ELSE: 3788 jj_consume_token(ELSE); 3789 hasElse = true; 3790 Statement(); 3791 break; 3792 default: 3793 jj_la1[101] = jj_gen; 3794 ; 3795 } 3796 jjtree.closeNodeScope(jjtn000, true); 3797 jjtc000 = false; 3798 if (hasElse) { 3799 jjtn000.setHasElse(); 3800 } 3801 } catch (Throwable jjte000) { 3802 if (jjtc000) { 3803 jjtree.clearNodeScope(jjtn000); 3804 jjtc000 = false; 3805 } else { 3806 jjtree.popNode(); 3807 } 3808 if (jjte000 instanceof RuntimeException) { 3809 {if (true) throw (RuntimeException)jjte000;} 3810 } 3811 if (jjte000 instanceof ParseException) { 3812 {if (true) throw (ParseException)jjte000;} 3813 } 3814 {if (true) throw (RuntimeException)jjte000;} 3815 } finally { 3816 if (jjtc000) { 3817 jjtree.closeNodeScope(jjtn000, true); 3818 } 3819 } 3820 } 3821 3822 final public void WhileStatement() throws ParseException { 3823 /*@bgen(jjtree) WhileStatement */ 3824 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT); 3825 boolean jjtc000 = true; 3826 jjtree.openNodeScope(jjtn000); 3827 try { 3828 jj_consume_token(WHILE); 3829 jj_consume_token(LPAREN); 3830 Expression(); 3831 jj_consume_token(RPAREN); 3832 Statement(); 3833 } catch (Throwable jjte000) { 3834 if (jjtc000) { 3835 jjtree.clearNodeScope(jjtn000); 3836 jjtc000 = false; 3837 } else { 3838 jjtree.popNode(); 3839 } 3840 if (jjte000 instanceof RuntimeException) { 3841 {if (true) throw (RuntimeException)jjte000;} 3842 } 3843 if (jjte000 instanceof ParseException) { 3844 {if (true) throw (ParseException)jjte000;} 3845 } 3846 {if (true) throw (RuntimeException)jjte000;} 3847 } finally { 3848 if (jjtc000) { 3849 jjtree.closeNodeScope(jjtn000, true); 3850 } 3851 } 3852 } 3853 3854 final public void DoStatement() throws ParseException { 3855 /*@bgen(jjtree) DoStatement */ 3856 ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT); 3857 boolean jjtc000 = true; 3858 jjtree.openNodeScope(jjtn000); 3859 try { 3860 jj_consume_token(DO); 3861 Statement(); 3862 jj_consume_token(WHILE); 3863 jj_consume_token(LPAREN); 3864 Expression(); 3865 jj_consume_token(RPAREN); 3866 jj_consume_token(SEMICOLON); 3867 } catch (Throwable jjte000) { 3868 if (jjtc000) { 3869 jjtree.clearNodeScope(jjtn000); 3870 jjtc000 = false; 3871 } else { 3872 jjtree.popNode(); 3873 } 3874 if (jjte000 instanceof RuntimeException) { 3875 {if (true) throw (RuntimeException)jjte000;} 3876 } 3877 if (jjte000 instanceof ParseException) { 3878 {if (true) throw (ParseException)jjte000;} 3879 } 3880 {if (true) throw (RuntimeException)jjte000;} 3881 } finally { 3882 if (jjtc000) { 3883 jjtree.closeNodeScope(jjtn000, true); 3884 } 3885 } 3886 } 3887 3888 final public void ForStatement() throws ParseException { 3889 /*@bgen(jjtree) ForStatement */ 3890 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT); 3891 boolean jjtc000 = true; 3892 jjtree.openNodeScope(jjtn000); 3893 try { 3894 jj_consume_token(FOR); 3895 jj_consume_token(LPAREN); 3896 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3897 case BOOLEAN: 3898 case BYTE: 3899 case CHAR: 3900 case DOUBLE: 3901 case FALSE: 3902 case FINAL: 3903 case FLOAT: 3904 case INT: 3905 case LONG: 3906 case NEW: 3907 case NULL: 3908 case SHORT: 3909 case SUPER: 3910 case THIS: 3911 case TRUE: 3912 case VOID: 3913 case INTEGER_LITERAL: 3914 case FLOATING_POINT_LITERAL: 3915 case CHARACTER_LITERAL: 3916 case STRING_LITERAL: 3917 case IDENTIFIER: 3918 case LPAREN: 3919 case INCR: 3920 case DECR: 3921 ForInit(); 3922 break; 3923 default: 3924 jj_la1[102] = jj_gen; 3925 ; 3926 } 3927 jj_consume_token(SEMICOLON); 3928 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3929 case BOOLEAN: 3930 case BYTE: 3931 case CHAR: 3932 case DOUBLE: 3933 case FALSE: 3934 case FLOAT: 3935 case INT: 3936 case LONG: 3937 case NEW: 3938 case NULL: 3939 case SHORT: 3940 case SUPER: 3941 case THIS: 3942 case TRUE: 3943 case VOID: 3944 case INTEGER_LITERAL: 3945 case FLOATING_POINT_LITERAL: 3946 case CHARACTER_LITERAL: 3947 case STRING_LITERAL: 3948 case IDENTIFIER: 3949 case LPAREN: 3950 case BANG: 3951 case TILDE: 3952 case INCR: 3953 case DECR: 3954 case PLUS: 3955 case MINUS: 3956 Expression(); 3957 break; 3958 default: 3959 jj_la1[103] = jj_gen; 3960 ; 3961 } 3962 jj_consume_token(SEMICOLON); 3963 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 3964 case BOOLEAN: 3965 case BYTE: 3966 case CHAR: 3967 case DOUBLE: 3968 case FALSE: 3969 case FLOAT: 3970 case INT: 3971 case LONG: 3972 case NEW: 3973 case NULL: 3974 case SHORT: 3975 case SUPER: 3976 case THIS: 3977 case TRUE: 3978 case VOID: 3979 case INTEGER_LITERAL: 3980 case FLOATING_POINT_LITERAL: 3981 case CHARACTER_LITERAL: 3982 case STRING_LITERAL: 3983 case IDENTIFIER: 3984 case LPAREN: 3985 case INCR: 3986 case DECR: 3987 ForUpdate(); 3988 break; 3989 default: 3990 jj_la1[104] = jj_gen; 3991 ; 3992 } 3993 jj_consume_token(RPAREN); 3994 Statement(); 3995 } catch (Throwable jjte000) { 3996 if (jjtc000) { 3997 jjtree.clearNodeScope(jjtn000); 3998 jjtc000 = false; 3999 } else { 4000 jjtree.popNode(); 4001 } 4002 if (jjte000 instanceof RuntimeException) { 4003 {if (true) throw (RuntimeException)jjte000;} 4004 } 4005 if (jjte000 instanceof ParseException) { 4006 {if (true) throw (ParseException)jjte000;} 4007 } 4008 {if (true) throw (RuntimeException)jjte000;} 4009 } finally { 4010 if (jjtc000) { 4011 jjtree.closeNodeScope(jjtn000, true); 4012 } 4013 } 4014 } 4015 4016 final public void ForInit() throws ParseException { 4017 /*@bgen(jjtree) ForInit */ 4018 ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT); 4019 boolean jjtc000 = true; 4020 jjtree.openNodeScope(jjtn000); 4021 try { 4022 if (jj_2_34(2147483647)) { 4023 LocalVariableDeclaration(); 4024 } else { 4025 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4026 case BOOLEAN: 4027 case BYTE: 4028 case CHAR: 4029 case DOUBLE: 4030 case FALSE: 4031 case FLOAT: 4032 case INT: 4033 case LONG: 4034 case NEW: 4035 case NULL: 4036 case SHORT: 4037 case SUPER: 4038 case THIS: 4039 case TRUE: 4040 case VOID: 4041 case INTEGER_LITERAL: 4042 case FLOATING_POINT_LITERAL: 4043 case CHARACTER_LITERAL: 4044 case STRING_LITERAL: 4045 case IDENTIFIER: 4046 case LPAREN: 4047 case INCR: 4048 case DECR: 4049 StatementExpressionList(); 4050 break; 4051 default: 4052 jj_la1[105] = jj_gen; 4053 jj_consume_token(-1); 4054 throw new ParseException(); 4055 } 4056 } 4057 } catch (Throwable jjte000) { 4058 if (jjtc000) { 4059 jjtree.clearNodeScope(jjtn000); 4060 jjtc000 = false; 4061 } else { 4062 jjtree.popNode(); 4063 } 4064 if (jjte000 instanceof RuntimeException) { 4065 {if (true) throw (RuntimeException)jjte000;} 4066 } 4067 if (jjte000 instanceof ParseException) { 4068 {if (true) throw (ParseException)jjte000;} 4069 } 4070 {if (true) throw (RuntimeException)jjte000;} 4071 } finally { 4072 if (jjtc000) { 4073 jjtree.closeNodeScope(jjtn000, true); 4074 } 4075 } 4076 } 4077 4078 final public void StatementExpressionList() throws ParseException { 4079 /*@bgen(jjtree) StatementExpressionList */ 4080 ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST); 4081 boolean jjtc000 = true; 4082 jjtree.openNodeScope(jjtn000); 4083 try { 4084 StatementExpression(); 4085 label_40: 4086 while (true) { 4087 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4088 case COMMA: 4089 ; 4090 break; 4091 default: 4092 jj_la1[106] = jj_gen; 4093 break label_40; 4094 } 4095 jj_consume_token(COMMA); 4096 StatementExpression(); 4097 } 4098 } catch (Throwable jjte000) { 4099 if (jjtc000) { 4100 jjtree.clearNodeScope(jjtn000); 4101 jjtc000 = false; 4102 } else { 4103 jjtree.popNode(); 4104 } 4105 if (jjte000 instanceof RuntimeException) { 4106 {if (true) throw (RuntimeException)jjte000;} 4107 } 4108 if (jjte000 instanceof ParseException) { 4109 {if (true) throw (ParseException)jjte000;} 4110 } 4111 {if (true) throw (RuntimeException)jjte000;} 4112 } finally { 4113 if (jjtc000) { 4114 jjtree.closeNodeScope(jjtn000, true); 4115 } 4116 } 4117 } 4118 4119 final public void ForUpdate() throws ParseException { 4120 /*@bgen(jjtree) ForUpdate */ 4121 ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE); 4122 boolean jjtc000 = true; 4123 jjtree.openNodeScope(jjtn000); 4124 try { 4125 StatementExpressionList(); 4126 } catch (Throwable jjte000) { 4127 if (jjtc000) { 4128 jjtree.clearNodeScope(jjtn000); 4129 jjtc000 = false; 4130 } else { 4131 jjtree.popNode(); 4132 } 4133 if (jjte000 instanceof RuntimeException) { 4134 {if (true) throw (RuntimeException)jjte000;} 4135 } 4136 if (jjte000 instanceof ParseException) { 4137 {if (true) throw (ParseException)jjte000;} 4138 } 4139 {if (true) throw (RuntimeException)jjte000;} 4140 } finally { 4141 if (jjtc000) { 4142 jjtree.closeNodeScope(jjtn000, true); 4143 } 4144 } 4145 } 4146 4147 final public void BreakStatement() throws ParseException { 4148 /*@bgen(jjtree) BreakStatement */ 4149 ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT); 4150 boolean jjtc000 = true; 4151 jjtree.openNodeScope(jjtn000); 4152 try { 4153 jj_consume_token(BREAK); 4154 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4155 case IDENTIFIER: 4156 jj_consume_token(IDENTIFIER); 4157 break; 4158 default: 4159 jj_la1[107] = jj_gen; 4160 ; 4161 } 4162 jj_consume_token(SEMICOLON); 4163 } finally { 4164 if (jjtc000) { 4165 jjtree.closeNodeScope(jjtn000, true); 4166 } 4167 } 4168 } 4169 4170 final public void ContinueStatement() throws ParseException { 4171 /*@bgen(jjtree) ContinueStatement */ 4172 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT); 4173 boolean jjtc000 = true; 4174 jjtree.openNodeScope(jjtn000); 4175 try { 4176 jj_consume_token(CONTINUE); 4177 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4178 case IDENTIFIER: 4179 jj_consume_token(IDENTIFIER); 4180 break; 4181 default: 4182 jj_la1[108] = jj_gen; 4183 ; 4184 } 4185 jj_consume_token(SEMICOLON); 4186 } finally { 4187 if (jjtc000) { 4188 jjtree.closeNodeScope(jjtn000, true); 4189 } 4190 } 4191 } 4192 4193 final public void ReturnStatement() throws ParseException { 4194 /*@bgen(jjtree) ReturnStatement */ 4195 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT); 4196 boolean jjtc000 = true; 4197 jjtree.openNodeScope(jjtn000); 4198 try { 4199 jj_consume_token(RETURN); 4200 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4201 case BOOLEAN: 4202 case BYTE: 4203 case CHAR: 4204 case DOUBLE: 4205 case FALSE: 4206 case FLOAT: 4207 case INT: 4208 case LONG: 4209 case NEW: 4210 case NULL: 4211 case SHORT: 4212 case SUPER: 4213 case THIS: 4214 case TRUE: 4215 case VOID: 4216 case INTEGER_LITERAL: 4217 case FLOATING_POINT_LITERAL: 4218 case CHARACTER_LITERAL: 4219 case STRING_LITERAL: 4220 case IDENTIFIER: 4221 case LPAREN: 4222 case BANG: 4223 case TILDE: 4224 case INCR: 4225 case DECR: 4226 case PLUS: 4227 case MINUS: 4228 Expression(); 4229 break; 4230 default: 4231 jj_la1[109] = jj_gen; 4232 ; 4233 } 4234 jj_consume_token(SEMICOLON); 4235 } catch (Throwable jjte000) { 4236 if (jjtc000) { 4237 jjtree.clearNodeScope(jjtn000); 4238 jjtc000 = false; 4239 } else { 4240 jjtree.popNode(); 4241 } 4242 if (jjte000 instanceof RuntimeException) { 4243 {if (true) throw (RuntimeException)jjte000;} 4244 } 4245 if (jjte000 instanceof ParseException) { 4246 {if (true) throw (ParseException)jjte000;} 4247 } 4248 {if (true) throw (RuntimeException)jjte000;} 4249 } finally { 4250 if (jjtc000) { 4251 jjtree.closeNodeScope(jjtn000, true); 4252 } 4253 } 4254 } 4255 4256 final public void ThrowStatement() throws ParseException { 4257 /*@bgen(jjtree) ThrowStatement */ 4258 ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT); 4259 boolean jjtc000 = true; 4260 jjtree.openNodeScope(jjtn000); 4261 try { 4262 jj_consume_token(THROW); 4263 Expression(); 4264 jj_consume_token(SEMICOLON); 4265 } catch (Throwable jjte000) { 4266 if (jjtc000) { 4267 jjtree.clearNodeScope(jjtn000); 4268 jjtc000 = false; 4269 } else { 4270 jjtree.popNode(); 4271 } 4272 if (jjte000 instanceof RuntimeException) { 4273 {if (true) throw (RuntimeException)jjte000;} 4274 } 4275 if (jjte000 instanceof ParseException) { 4276 {if (true) throw (ParseException)jjte000;} 4277 } 4278 {if (true) throw (RuntimeException)jjte000;} 4279 } finally { 4280 if (jjtc000) { 4281 jjtree.closeNodeScope(jjtn000, true); 4282 } 4283 } 4284 } 4285 4286 final public void SynchronizedStatement() throws ParseException { 4287 /*@bgen(jjtree) SynchronizedStatement */ 4288 ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT); 4289 boolean jjtc000 = true; 4290 jjtree.openNodeScope(jjtn000); 4291 try { 4292 jj_consume_token(SYNCHRONIZED); 4293 jj_consume_token(LPAREN); 4294 Expression(); 4295 jj_consume_token(RPAREN); 4296 Block(); 4297 } catch (Throwable jjte000) { 4298 if (jjtc000) { 4299 jjtree.clearNodeScope(jjtn000); 4300 jjtc000 = false; 4301 } else { 4302 jjtree.popNode(); 4303 } 4304 if (jjte000 instanceof RuntimeException) { 4305 {if (true) throw (RuntimeException)jjte000;} 4306 } 4307 if (jjte000 instanceof ParseException) { 4308 {if (true) throw (ParseException)jjte000;} 4309 } 4310 {if (true) throw (RuntimeException)jjte000;} 4311 } finally { 4312 if (jjtc000) { 4313 jjtree.closeNodeScope(jjtn000, true); 4314 } 4315 } 4316 } 4317 4318 final public void TryStatement() throws ParseException { 4319 /*@bgen(jjtree) TryStatement */ 4320 ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT); 4321 boolean jjtc000 = true; 4322 jjtree.openNodeScope(jjtn000); 4323 try { 4324 jj_consume_token(TRY); 4325 Block(); 4326 label_41: 4327 while (true) { 4328 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4329 case CATCH: 4330 ; 4331 break; 4332 default: 4333 jj_la1[110] = jj_gen; 4334 break label_41; 4335 } 4336 jj_consume_token(CATCH); 4337 jjtn000.setHasCatch(); 4338 jj_consume_token(LPAREN); 4339 FormalParameter(); 4340 jj_consume_token(RPAREN); 4341 Block(); 4342 } 4343 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4344 case FINALLY: 4345 jj_consume_token(FINALLY); 4346 jjtn000.setHasFinally(); 4347 Block(); 4348 break; 4349 default: 4350 jj_la1[111] = jj_gen; 4351 ; 4352 } 4353 } catch (Throwable jjte000) { 4354 if (jjtc000) { 4355 jjtree.clearNodeScope(jjtn000); 4356 jjtc000 = false; 4357 } else { 4358 jjtree.popNode(); 4359 } 4360 if (jjte000 instanceof RuntimeException) { 4361 {if (true) throw (RuntimeException)jjte000;} 4362 } 4363 if (jjte000 instanceof ParseException) { 4364 {if (true) throw (ParseException)jjte000;} 4365 } 4366 {if (true) throw (RuntimeException)jjte000;} 4367 } finally { 4368 if (jjtc000) { 4369 jjtree.closeNodeScope(jjtn000, true); 4370 } 4371 } 4372 } 4373 4374 final public void AssertStatement() throws ParseException { 4375 /*@bgen(jjtree) AssertStatement */ 4376 ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT); 4377 boolean jjtc000 = true; 4378 jjtree.openNodeScope(jjtn000);if (usingAssertAsIdentifier) { 4379 throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!"); 4380 } 4381 Token tok; 4382 try { 4383 tok = jj_consume_token(IDENTIFIER); 4384 4385 Expression(); 4386 switch ((jj_ntk==-1)?jj_ntk():jj_ntk) { 4387 case COLON: 4388 jj_consume_token(COLON); 4389 Expression(); 4390 break; 4391 default: 4392 jj_la1[112] = jj_gen; 4393 ; 4394 } 4395 jj_consume_token(SEMICOLON); 4396 } catch (Throwable jjte000) { 4397 if (jjtc000) { 4398 jjtree.clearNodeScope(jjtn000); 4399 jjtc000 = false; 4400 } else { 4401 jjtree.popNode(); 4402 } 4403 if (jjte000 instanceof RuntimeException) { 4404 {if (true) throw (RuntimeException)jjte000;} 4405 } 4406 if (jjte000 instanceof ParseException) { 4407 {if (true) throw (ParseException)jjte000;} 4408 } 4409 {if (true) throw (RuntimeException)jjte000;} 4410 } finally { 4411 if (jjtc000) { 4412 jjtree.closeNodeScope(jjtn000, true); 4413 } 4414 } 4415 } 4416 4417 final private boolean jj_2_1(int xla) { 4418 jj_la = xla; jj_lastpos = jj_scanpos = token; 4419 try { return !jj_3_1(); } 4420 catch(LookaheadSuccess ls) { return true; } 4421 finally { jj_save(0, xla); } 4422 } 4423 4424 final private boolean jj_2_2(int xla) { 4425 jj_la = xla; jj_lastpos = jj_scanpos = token; 4426 try { return !jj_3_2(); } 4427 catch(LookaheadSuccess ls) { return true; } 4428 finally { jj_save(1, xla); } 4429 } 4430 4431 final private boolean jj_2_3(int xla) { 4432 jj_la = xla; jj_lastpos = jj_scanpos = token; 4433 try { return !jj_3_3(); } 4434 catch(LookaheadSuccess ls) { return true; } 4435 finally { jj_save(2, xla); } 4436 } 4437 4438 final private boolean jj_2_4(int xla) { 4439 jj_la = xla; jj_lastpos = jj_scanpos = token; 4440 try { return !jj_3_4(); } 4441 catch(LookaheadSuccess ls) { return true; } 4442 finally { jj_save(3, xla); } 4443 } 4444 4445 final private boolean jj_2_5(int xla) { 4446 jj_la = xla; jj_lastpos = jj_scanpos = token; 4447 try { return !jj_3_5(); } 4448 catch(LookaheadSuccess ls) { return true; } 4449 finally { jj_save(4, xla); } 4450 } 4451 4452 final private boolean jj_2_6(int xla) { 4453 jj_la = xla; jj_lastpos = jj_scanpos = token; 4454 try { return !jj_3_6(); } 4455 catch(LookaheadSuccess ls) { return true; } 4456 finally { jj_save(5, xla); } 4457 } 4458 4459 final private boolean jj_2_7(int xla) { 4460 jj_la = xla; jj_lastpos = jj_scanpos = token; 4461 try { return !jj_3_7(); } 4462 catch(LookaheadSuccess ls) { return true; } 4463 finally { jj_save(6, xla); } 4464 } 4465 4466 final private boolean jj_2_8(int xla) { 4467 jj_la = xla; jj_lastpos = jj_scanpos = token; 4468 try { return !jj_3_8(); } 4469 catch(LookaheadSuccess ls) { return true; } 4470 finally { jj_save(7, xla); } 4471 } 4472 4473 final private boolean jj_2_9(int xla) { 4474 jj_la = xla; jj_lastpos = jj_scanpos = token; 4475 try { return !jj_3_9(); } 4476 catch(LookaheadSuccess ls) { return true; } 4477 finally { jj_save(8, xla); } 4478 } 4479 4480 final private boolean jj_2_10(int xla) { 4481 jj_la = xla; jj_lastpos = jj_scanpos = token; 4482 try { return !jj_3_10(); } 4483 catch(LookaheadSuccess ls) { return true; } 4484 finally { jj_save(9, xla); } 4485 } 4486 4487 final private boolean jj_2_11(int xla) { 4488 jj_la = xla; jj_lastpos = jj_scanpos = token; 4489 try { return !jj_3_11(); } 4490 catch(LookaheadSuccess ls) { return true; } 4491 finally { jj_save(10, xla); } 4492 } 4493 4494 final private boolean jj_2_12(int xla) { 4495 jj_la = xla; jj_lastpos = jj_scanpos = token; 4496 try { return !jj_3_12(); } 4497 catch(LookaheadSuccess ls) { return true; } 4498 finally { jj_save(11, xla); } 4499 } 4500 4501 final private boolean jj_2_13(int xla) { 4502 jj_la = xla; jj_lastpos = jj_scanpos = token; 4503 try { return !jj_3_13(); } 4504 catch(LookaheadSuccess ls) { return true; } 4505 finally { jj_save(12, xla); } 4506 } 4507 4508 final private boolean jj_2_14(int xla) { 4509 jj_la = xla; jj_lastpos = jj_scanpos = token; 4510 try { return !jj_3_14(); } 4511 catch(LookaheadSuccess ls) { return true; } 4512 finally { jj_save(13, xla); } 4513 } 4514 4515 final private boolean jj_2_15(int xla) { 4516 jj_la = xla; jj_lastpos = jj_scanpos = token; 4517 try { return !jj_3_15(); } 4518 catch(LookaheadSuccess ls) { return true; } 4519 finally { jj_save(14, xla); } 4520 } 4521 4522 final private boolean jj_2_16(int xla) { 4523 jj_la = xla; jj_lastpos = jj_scanpos = token; 4524 try { return !jj_3_16(); } 4525 catch(LookaheadSuccess ls) { return true; } 4526 finally { jj_save(15, xla); } 4527 } 4528 4529 final private boolean jj_2_17(int xla) { 4530 jj_la = xla; jj_lastpos = jj_scanpos = token; 4531 try { return !jj_3_17(); } 4532 catch(LookaheadSuccess ls) { return true; } 4533 finally { jj_save(16, xla); } 4534 } 4535 4536 final private boolean jj_2_18(int xla) { 4537 jj_la = xla; jj_lastpos = jj_scanpos = token; 4538 try { return !jj_3_18(); } 4539 catch(LookaheadSuccess ls) { return true; } 4540 finally { jj_save(17, xla); } 4541 } 4542 4543 final private boolean jj_2_19(int xla) { 4544 jj_la = xla; jj_lastpos = jj_scanpos = token; 4545 try { return !jj_3_19(); } 4546 catch(LookaheadSuccess ls) { return true; } 4547 finally { jj_save(18, xla); } 4548 } 4549 4550 final private boolean jj_2_20(int xla) { 4551 jj_la = xla; jj_lastpos = jj_scanpos = token; 4552 try { return !jj_3_20(); } 4553 catch(LookaheadSuccess ls) { return true; } 4554 finally { jj_save(19, xla); } 4555 } 4556 4557 final private boolean jj_2_21(int xla) { 4558 jj_la = xla; jj_lastpos = jj_scanpos = token; 4559 try { return !jj_3_21(); } 4560 catch(LookaheadSuccess ls) { return true; } 4561 finally { jj_save(20, xla); } 4562 } 4563 4564 final private boolean jj_2_22(int xla) { 4565 jj_la = xla; jj_lastpos = jj_scanpos = token; 4566 try { return !jj_3_22(); } 4567 catch(LookaheadSuccess ls) { return true; } 4568 finally { jj_save(21, xla); } 4569 } 4570 4571 final private boolean jj_2_23(int xla) { 4572 jj_la = xla; jj_lastpos = jj_scanpos = token; 4573 try { return !jj_3_23(); } 4574 catch(LookaheadSuccess ls) { return true; } 4575 finally { jj_save(22, xla); } 4576 } 4577 4578 final private boolean jj_2_24(int xla) { 4579 jj_la = xla; jj_lastpos = jj_scanpos = token; 4580 try { return !jj_3_24(); } 4581 catch(LookaheadSuccess ls) { return true; } 4582 finally { jj_save(23, xla); } 4583 } 4584 4585 final private boolean jj_2_25(int xla) { 4586 jj_la = xla; jj_lastpos = jj_scanpos = token; 4587 try { return !jj_3_25(); } 4588 catch(LookaheadSuccess ls) { return true; } 4589 finally { jj_save(24, xla); } 4590 } 4591 4592 final private boolean jj_2_26(int xla) { 4593 jj_la = xla; jj_lastpos = jj_scanpos = token; 4594 try { return !jj_3_26(); } 4595 catch(LookaheadSuccess ls) { return true; } 4596 finally { jj_save(25, xla); } 4597 } 4598 4599 final private boolean jj_2_27(int xla) { 4600 jj_la = xla; jj_lastpos = jj_scanpos = token; 4601 try { return !jj_3_27(); } 4602 catch(LookaheadSuccess ls) { return true; } 4603 finally { jj_save(26, xla); } 4604 } 4605 4606 final private boolean jj_2_28(int xla) { 4607 jj_la = xla; jj_lastpos = jj_scanpos = token; 4608 try { return !jj_3_28(); } 4609 catch(LookaheadSuccess ls) { return true; } 4610 finally { jj_save(27, xla); } 4611 } 4612 4613 final private boolean jj_2_29(int xla) { 4614 jj_la = xla; jj_lastpos = jj_scanpos = token; 4615 try { return !jj_3_29(); } 4616 catch(LookaheadSuccess ls) { return true; } 4617 finally { jj_save(28, xla); } 4618 } 4619 4620 final private boolean jj_2_30(int xla) { 4621 jj_la = xla; jj_lastpos = jj_scanpos = token; 4622 try { return !jj_3_30(); } 4623 catch(LookaheadSuccess ls) { return true; } 4624 finally { jj_save(29, xla); } 4625 } 4626 4627 final private boolean jj_2_31(int xla) { 4628 jj_la = xla; jj_lastpos = jj_scanpos = token; 4629 try { return !jj_3_31(); } 4630 catch(LookaheadSuccess ls) { return true; } 4631 finally { jj_save(30, xla); } 4632 } 4633 4634 final private boolean jj_2_32(int xla) { 4635 jj_la = xla; jj_lastpos = jj_scanpos = token; 4636 try { return !jj_3_32(); } 4637 catch(LookaheadSuccess ls) { return true; } 4638 finally { jj_save(31, xla); } 4639 } 4640 4641 final private boolean jj_2_33(int xla) { 4642 jj_la = xla; jj_lastpos = jj_scanpos = token; 4643 try { return !jj_3_33(); } 4644 catch(LookaheadSuccess ls) { return true; } 4645 finally { jj_save(32, xla); } 4646 } 4647 4648 final private boolean jj_2_34(int xla) { 4649 jj_la = xla; jj_lastpos = jj_scanpos = token; 4650 try { return !jj_3_34(); } 4651 catch(LookaheadSuccess ls) { return true; } 4652 finally { jj_save(33, xla); } 4653 } 4654 4655 final private boolean jj_3R_126() { 4656 if (jj_3R_144()) return true; 4657 Token xsp; 4658 while (true) { 4659 xsp = jj_scanpos; 4660 if (jj_3R_164()) { jj_scanpos = xsp; break; } 4661 } 4662 return false; 4663 } 4664 4665 final private boolean jj_3R_94() { 4666 if (jj_3R_126()) return true; 4667 Token xsp; 4668 xsp = jj_scanpos; 4669 if (jj_3R_160()) jj_scanpos = xsp; 4670 return false; 4671 } 4672 4673 final private boolean jj_3R_176() { 4674 if (jj_scan_token(ORASSIGN)) return true; 4675 return false; 4676 } 4677 4678 final private boolean jj_3R_175() { 4679 if (jj_scan_token(XORASSIGN)) return true; 4680 return false; 4681 } 4682 4683 final private boolean jj_3R_174() { 4684 if (jj_scan_token(ANDASSIGN)) return true; 4685 return false; 4686 } 4687 4688 final private boolean jj_3R_173() { 4689 if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true; 4690 return false; 4691 } 4692 4693 final private boolean jj_3R_172() { 4694 if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true; 4695 return false; 4696 } 4697 4698 final private boolean jj_3R_171() { 4699 if (jj_scan_token(LSHIFTASSIGN)) return true; 4700 return false; 4701 } 4702 4703 final private boolean jj_3R_170() { 4704 if (jj_scan_token(MINUSASSIGN)) return true; 4705 return false; 4706 } 4707 4708 final private boolean jj_3R_169() { 4709 if (jj_scan_token(PLUSASSIGN)) return true; 4710 return false; 4711 } 4712 4713 final private boolean jj_3R_168() { 4714 if (jj_scan_token(REMASSIGN)) return true; 4715 return false; 4716 } 4717 4718 final private boolean jj_3R_167() { 4719 if (jj_scan_token(SLASHASSIGN)) return true; 4720 return false; 4721 } 4722 4723 final private boolean jj_3R_166() { 4724 if (jj_scan_token(STARASSIGN)) return true; 4725 return false; 4726 } 4727 4728 final private boolean jj_3R_161() { 4729 Token xsp; 4730 xsp = jj_scanpos; 4731 if (jj_3R_165()) { 4732 jj_scanpos = xsp; 4733 if (jj_3R_166()) { 4734 jj_scanpos = xsp; 4735 if (jj_3R_167()) { 4736 jj_scanpos = xsp; 4737 if (jj_3R_168()) { 4738 jj_scanpos = xsp; 4739 if (jj_3R_169()) { 4740 jj_scanpos = xsp; 4741 if (jj_3R_170()) { 4742 jj_scanpos = xsp; 4743 if (jj_3R_171()) { 4744 jj_scanpos = xsp; 4745 if (jj_3R_172()) { 4746 jj_scanpos = xsp; 4747 if (jj_3R_173()) { 4748 jj_scanpos = xsp; 4749 if (jj_3R_174()) { 4750 jj_scanpos = xsp; 4751 if (jj_3R_175()) { 4752 jj_scanpos = xsp; 4753 if (jj_3R_176()) return true; 4754 } 4755 } 4756 } 4757 } 4758 } 4759 } 4760 } 4761 } 4762 } 4763 } 4764 } 4765 return false; 4766 } 4767 4768 final private boolean jj_3R_165() { 4769 if (jj_scan_token(ASSIGN)) return true; 4770 return false; 4771 } 4772 4773 final private boolean jj_3R_154() { 4774 if (jj_3R_161()) return true; 4775 if (jj_3R_61()) return true; 4776 return false; 4777 } 4778 4779 final private boolean jj_3R_61() { 4780 if (jj_3R_94()) return true; 4781 Token xsp; 4782 xsp = jj_scanpos; 4783 if (jj_3R_154()) jj_scanpos = xsp; 4784 return false; 4785 } 4786 4787 final private boolean jj_3R_283() { 4788 if (jj_scan_token(COMMA)) return true; 4789 if (jj_3R_47()) return true; 4790 return false; 4791 } 4792 4793 final private boolean jj_3R_256() { 4794 if (jj_3R_47()) return true; 4795 Token xsp; 4796 while (true) { 4797 xsp = jj_scanpos; 4798 if (jj_3R_283()) { jj_scanpos = xsp; break; } 4799 } 4800 return false; 4801 } 4802 4803 final private boolean jj_3_15() { 4804 if (jj_scan_token(DOT)) return true; 4805 if (jj_scan_token(IDENTIFIER)) return true; 4806 return false; 4807 } 4808 4809 final private boolean jj_3R_47() { 4810 if (jj_scan_token(IDENTIFIER)) return true; 4811 Token xsp; 4812 while (true) { 4813 xsp = jj_scanpos; 4814 if (jj_3_15()) { jj_scanpos = xsp; break; } 4815 } 4816 return false; 4817 } 4818 4819 final private boolean jj_3R_97() { 4820 if (jj_scan_token(LBRACKET)) return true; 4821 if (jj_scan_token(RBRACKET)) return true; 4822 return false; 4823 } 4824 4825 final private boolean jj_3R_92() { 4826 if (jj_3R_63()) return true; 4827 return false; 4828 } 4829 4830 final private boolean jj_3R_59() { 4831 Token xsp; 4832 xsp = jj_scanpos; 4833 if (jj_scan_token(59)) { 4834 jj_scanpos = xsp; 4835 if (jj_3R_92()) return true; 4836 } 4837 return false; 4838 } 4839 4840 final private boolean jj_3R_96() { 4841 if (jj_3R_47()) return true; 4842 return false; 4843 } 4844 4845 final private boolean jj_3R_88() { 4846 if (jj_scan_token(DOUBLE)) return true; 4847 return false; 4848 } 4849 4850 final private boolean jj_3R_87() { 4851 if (jj_scan_token(FLOAT)) return true; 4852 return false; 4853 } 4854 4855 final private boolean jj_3R_86() { 4856 if (jj_scan_token(LONG)) return true; 4857 return false; 4858 } 4859 4860 final private boolean jj_3R_85() { 4861 if (jj_scan_token(INT)) return true; 4862 return false; 4863 } 4864 4865 final private boolean jj_3R_84() { 4866 if (jj_scan_token(SHORT)) return true; 4867 return false; 4868 } 4869 4870 final private boolean jj_3R_83() { 4871 if (jj_scan_token(BYTE)) return true; 4872 return false; 4873 } 4874 4875 final private boolean jj_3R_82() { 4876 if (jj_scan_token(CHAR)) return true; 4877 return false; 4878 } 4879 4880 final private boolean jj_3R_81() { 4881 if (jj_scan_token(BOOLEAN)) return true; 4882 return false; 4883 } 4884 4885 final private boolean jj_3R_57() { 4886 Token xsp; 4887 xsp = jj_scanpos; 4888 if (jj_3R_81()) { 4889 jj_scanpos = xsp; 4890 if (jj_3R_82()) { 4891 jj_scanpos = xsp; 4892 if (jj_3R_83()) { 4893 jj_scanpos = xsp; 4894 if (jj_3R_84()) { 4895 jj_scanpos = xsp; 4896 if (jj_3R_85()) { 4897 jj_scanpos = xsp; 4898 if (jj_3R_86()) { 4899 jj_scanpos = xsp; 4900 if (jj_3R_87()) { 4901 jj_scanpos = xsp; 4902 if (jj_3R_88()) return true; 4903 } 4904 } 4905 } 4906 } 4907 } 4908 } 4909 } 4910 return false; 4911 } 4912 4913 final private boolean jj_3R_221() { 4914 if (jj_scan_token(THROWS)) return true; 4915 if (jj_3R_256()) return true; 4916 return false; 4917 } 4918 4919 final private boolean jj_3R_95() { 4920 if (jj_3R_57()) return true; 4921 return false; 4922 } 4923 4924 final private boolean jj_3R_63() { 4925 Token xsp; 4926 xsp = jj_scanpos; 4927 if (jj_3R_95()) { 4928 jj_scanpos = xsp; 4929 if (jj_3R_96()) return true; 4930 } 4931 while (true) { 4932 xsp = jj_scanpos; 4933 if (jj_3R_97()) { jj_scanpos = xsp; break; } 4934 } 4935 return false; 4936 } 4937 4938 final private boolean jj_3_14() { 4939 if (jj_scan_token(THIS)) return true; 4940 if (jj_3R_55()) return true; 4941 if (jj_scan_token(SEMICOLON)) return true; 4942 return false; 4943 } 4944 4945 final private boolean jj_3R_65() { 4946 if (jj_scan_token(STATIC)) return true; 4947 return false; 4948 } 4949 4950 final private boolean jj_3R_43() { 4951 Token xsp; 4952 xsp = jj_scanpos; 4953 if (jj_3R_65()) jj_scanpos = xsp; 4954 if (jj_3R_66()) return true; 4955 return false; 4956 } 4957 4958 final private boolean jj_3_11() { 4959 if (jj_3R_52()) return true; 4960 return false; 4961 } 4962 4963 final private boolean jj_3_13() { 4964 if (jj_3R_54()) return true; 4965 if (jj_scan_token(DOT)) return true; 4966 return false; 4967 } 4968 4969 final private boolean jj_3R_71() { 4970 Token xsp; 4971 xsp = jj_scanpos; 4972 if (jj_3_13()) jj_scanpos = xsp; 4973 if (jj_scan_token(SUPER)) return true; 4974 if (jj_3R_55()) return true; 4975 if (jj_scan_token(SEMICOLON)) return true; 4976 return false; 4977 } 4978 4979 final private boolean jj_3R_52() { 4980 Token xsp; 4981 xsp = jj_scanpos; 4982 if (jj_3R_70()) { 4983 jj_scanpos = xsp; 4984 if (jj_3R_71()) return true; 4985 } 4986 return false; 4987 } 4988 4989 final private boolean jj_3R_70() { 4990 if (jj_scan_token(THIS)) return true; 4991 if (jj_3R_55()) return true; 4992 if (jj_scan_token(SEMICOLON)) return true; 4993 return false; 4994 } 4995 4996 final private boolean jj_3R_282() { 4997 if (jj_scan_token(COMMA)) return true; 4998 if (jj_3R_281()) return true; 4999 return false; 5000 } 5001 5002 final private boolean jj_3_12() { 5003 if (jj_3R_53()) return true; 5004 return false; 5005 } 5006 5007 final private boolean jj_3R_222() { 5008 if (jj_3R_52()) return true; 5009 return false; 5010 } 5011 5012 final private boolean jj_3R_254() { 5013 if (jj_scan_token(PRIVATE)) return true; 5014 return false; 5015 } 5016 5017 final private boolean jj_3R_253() { 5018 if (jj_scan_token(PROTECTED)) return true; 5019 return false; 5020 } 5021 5022 final private boolean jj_3R_266() { 5023 if (jj_scan_token(LBRACKET)) return true; 5024 if (jj_scan_token(RBRACKET)) return true; 5025 return false; 5026 } 5027 5028 final private boolean jj_3R_219() { 5029 Token xsp; 5030 xsp = jj_scanpos; 5031 if (jj_3R_252()) { 5032 jj_scanpos = xsp; 5033 if (jj_3R_253()) { 5034 jj_scanpos = xsp; 5035 if (jj_3R_254()) return true; 5036 } 5037 } 5038 return false; 5039 } 5040 5041 final private boolean jj_3R_225() { 5042 if (jj_scan_token(THROWS)) return true; 5043 if (jj_3R_256()) return true; 5044 return false; 5045 } 5046 5047 final private boolean jj_3R_252() { 5048 if (jj_scan_token(PUBLIC)) return true; 5049 return false; 5050 } 5051 5052 final private boolean jj_3R_209() { 5053 Token xsp; 5054 xsp = jj_scanpos; 5055 if (jj_3R_219()) jj_scanpos = xsp; 5056 if (jj_scan_token(IDENTIFIER)) return true; 5057 if (jj_3R_220()) return true; 5058 xsp = jj_scanpos; 5059 if (jj_3R_221()) jj_scanpos = xsp; 5060 if (jj_scan_token(LBRACE)) return true; 5061 xsp = jj_scanpos; 5062 if (jj_3R_222()) jj_scanpos = xsp; 5063 while (true) { 5064 xsp = jj_scanpos; 5065 if (jj_3_12()) { jj_scanpos = xsp; break; } 5066 } 5067 if (jj_scan_token(RBRACE)) return true; 5068 return false; 5069 } 5070 5071 final private boolean jj_3R_291() { 5072 if (jj_scan_token(FINAL)) return true; 5073 return false; 5074 } 5075 5076 final private boolean jj_3R_255() { 5077 if (jj_3R_281()) return true; 5078 Token xsp; 5079 while (true) { 5080 xsp = jj_scanpos; 5081 if (jj_3R_282()) { jj_scanpos = xsp; break; } 5082 } 5083 return false; 5084 } 5085 5086 final private boolean jj_3R_281() { 5087 Token xsp; 5088 xsp = jj_scanpos; 5089 if (jj_3R_291()) jj_scanpos = xsp; 5090 if (jj_3R_63()) return true; 5091 if (jj_3R_274()) return true; 5092 return false; 5093 } 5094 5095 final private boolean jj_3R_220() { 5096 if (jj_scan_token(LPAREN)) return true; 5097 Token xsp; 5098 xsp = jj_scanpos; 5099 if (jj_3R_255()) jj_scanpos = xsp; 5100 if (jj_scan_token(RPAREN)) return true; 5101 return false; 5102 } 5103 5104 final private boolean jj_3_10() { 5105 if (jj_scan_token(COMMA)) return true; 5106 if (jj_3R_51()) return true; 5107 return false; 5108 } 5109 5110 final private boolean jj_3R_224() { 5111 if (jj_scan_token(IDENTIFIER)) return true; 5112 if (jj_3R_220()) return true; 5113 Token xsp; 5114 while (true) { 5115 xsp = jj_scanpos; 5116 if (jj_3R_266()) { jj_scanpos = xsp; break; } 5117 } 5118 return false; 5119 } 5120 5121 final private boolean jj_3R_226() { 5122 if (jj_3R_66()) return true; 5123 return false; 5124 } 5125 5126 final private boolean jj_3R_265() { 5127 if (jj_scan_token(STRICTFP)) return true; 5128 return false; 5129 } 5130 5131 final private boolean jj_3R_264() { 5132 if (jj_scan_token(SYNCHRONIZED)) return true; 5133 return false; 5134 } 5135 5136 final private boolean jj_3R_263() { 5137 if (jj_scan_token(NATIVE)) return true; 5138 return false; 5139 } 5140 5141 final private boolean jj_3R_262() { 5142 if (jj_scan_token(FINAL)) return true; 5143 return false; 5144 } 5145 5146 final private boolean jj_3R_261() { 5147 if (jj_scan_token(ABSTRACT)) return true; 5148 return false; 5149 } 5150 5151 final private boolean jj_3R_260() { 5152 if (jj_scan_token(STATIC)) return true; 5153 return false; 5154 } 5155 5156 final private boolean jj_3R_259() { 5157 if (jj_scan_token(PRIVATE)) return true; 5158 return false; 5159 } 5160 5161 final private boolean jj_3R_258() { 5162 if (jj_scan_token(PROTECTED)) return true; 5163 return false; 5164 } 5165 5166 final private boolean jj_3R_223() { 5167 Token xsp; 5168 xsp = jj_scanpos; 5169 if (jj_3R_257()) { 5170 jj_scanpos = xsp; 5171 if (jj_3R_258()) { 5172 jj_scanpos = xsp; 5173 if (jj_3R_259()) { 5174 jj_scanpos = xsp; 5175 if (jj_3R_260()) { 5176 jj_scanpos = xsp; 5177 if (jj_3R_261()) { 5178 jj_scanpos = xsp; 5179 if (jj_3R_262()) { 5180 jj_scanpos = xsp; 5181 if (jj_3R_263()) { 5182 jj_scanpos = xsp; 5183 if (jj_3R_264()) { 5184 jj_scanpos = xsp; 5185 if (jj_3R_265()) return true; 5186 } 5187 } 5188 } 5189 } 5190 } 5191 } 5192 } 5193 } 5194 return false; 5195 } 5196 5197 final private boolean jj_3R_257() { 5198 if (jj_scan_token(PUBLIC)) return true; 5199 return false; 5200 } 5201 5202 final private boolean jj_3R_193() { 5203 if (jj_3R_51()) return true; 5204 Token xsp; 5205 while (true) { 5206 xsp = jj_scanpos; 5207 if (jj_3_10()) { jj_scanpos = xsp; break; } 5208 } 5209 return false; 5210 } 5211 5212 final private boolean jj_3R_210() { 5213 Token xsp; 5214 while (true) { 5215 xsp = jj_scanpos; 5216 if (jj_3R_223()) { jj_scanpos = xsp; break; } 5217 } 5218 if (jj_3R_59()) return true; 5219 if (jj_3R_224()) return true; 5220 xsp = jj_scanpos; 5221 if (jj_3R_225()) jj_scanpos = xsp; 5222 xsp = jj_scanpos; 5223 if (jj_3R_226()) { 5224 jj_scanpos = xsp; 5225 if (jj_scan_token(80)) return true; 5226 } 5227 return false; 5228 } 5229 5230 final private boolean jj_3R_113() { 5231 if (jj_scan_token(LBRACE)) return true; 5232 Token xsp; 5233 xsp = jj_scanpos; 5234 if (jj_3R_193()) jj_scanpos = xsp; 5235 xsp = jj_scanpos; 5236 if (jj_scan_token(81)) jj_scanpos = xsp; 5237 if (jj_scan_token(RBRACE)) return true; 5238 return false; 5239 } 5240 5241 final private boolean jj_3R_275() { 5242 if (jj_scan_token(ASSIGN)) return true; 5243 if (jj_3R_51()) return true; 5244 return false; 5245 } 5246 5247 final private boolean jj_3R_69() { 5248 if (jj_3R_61()) return true; 5249 return false; 5250 } 5251 5252 final private boolean jj_3R_229() { 5253 if (jj_scan_token(COMMA)) return true; 5254 if (jj_3R_228()) return true; 5255 return false; 5256 } 5257 5258 final private boolean jj_3R_51() { 5259 Token xsp; 5260 xsp = jj_scanpos; 5261 if (jj_3R_68()) { 5262 jj_scanpos = xsp; 5263 if (jj_3R_69()) return true; 5264 } 5265 return false; 5266 } 5267 5268 final private boolean jj_3R_68() { 5269 if (jj_3R_113()) return true; 5270 return false; 5271 } 5272 5273 final private boolean jj_3R_284() { 5274 if (jj_scan_token(LBRACKET)) return true; 5275 if (jj_scan_token(RBRACKET)) return true; 5276 return false; 5277 } 5278 5279 final private boolean jj_3R_274() { 5280 if (jj_scan_token(IDENTIFIER)) return true; 5281 Token xsp; 5282 while (true) { 5283 xsp = jj_scanpos; 5284 if (jj_3R_284()) { jj_scanpos = xsp; break; } 5285 } 5286 return false; 5287 } 5288 5289 final private boolean jj_3R_228() { 5290 if (jj_3R_274()) return true; 5291 Token xsp; 5292 xsp = jj_scanpos; 5293 if (jj_3R_275()) jj_scanpos = xsp; 5294 return false; 5295 } 5296 5297 final private boolean jj_3R_273() { 5298 if (jj_scan_token(VOLATILE)) return true; 5299 return false; 5300 } 5301 5302 final private boolean jj_3R_272() { 5303 if (jj_scan_token(TRANSIENT)) return true; 5304 return false; 5305 } 5306 5307 final private boolean jj_3R_271() { 5308 if (jj_scan_token(FINAL)) return true; 5309 return false; 5310 } 5311 5312 final private boolean jj_3R_270() { 5313 if (jj_scan_token(STATIC)) return true; 5314 return false; 5315 } 5316 5317 final private boolean jj_3R_269() { 5318 if (jj_scan_token(PRIVATE)) return true; 5319 return false; 5320 } 5321 5322 final private boolean jj_3R_268() { 5323 if (jj_scan_token(PROTECTED)) return true; 5324 return false; 5325 } 5326 5327 final private boolean jj_3R_227() { 5328 Token xsp; 5329 xsp = jj_scanpos; 5330 if (jj_3R_267()) { 5331 jj_scanpos = xsp; 5332 if (jj_3R_268()) { 5333 jj_scanpos = xsp; 5334 if (jj_3R_269()) { 5335 jj_scanpos = xsp; 5336 if (jj_3R_270()) { 5337 jj_scanpos = xsp; 5338 if (jj_3R_271()) { 5339 jj_scanpos = xsp; 5340 if (jj_3R_272()) { 5341 jj_scanpos = xsp; 5342 if (jj_3R_273()) return true; 5343 } 5344 } 5345 } 5346 } 5347 } 5348 } 5349 return false; 5350 } 5351 5352 final private boolean jj_3R_267() { 5353 if (jj_scan_token(PUBLIC)) return true; 5354 return false; 5355 } 5356 5357 final private boolean jj_3R_211() { 5358 Token xsp; 5359 while (true) { 5360 xsp = jj_scanpos; 5361 if (jj_3R_227()) { jj_scanpos = xsp; break; } 5362 } 5363 if (jj_3R_63()) return true; 5364 if (jj_3R_228()) return true; 5365 while (true) { 5366 xsp = jj_scanpos; 5367 if (jj_3R_229()) { jj_scanpos = xsp; break; } 5368 } 5369 if (jj_scan_token(SEMICOLON)) return true; 5370 return false; 5371 } 5372 5373 final private boolean jj_3_9() { 5374 if (jj_3R_48()) return true; 5375 return false; 5376 } 5377 5378 final private boolean jj_3R_50() { 5379 Token xsp; 5380 xsp = jj_scanpos; 5381 if (jj_scan_token(49)) { 5382 jj_scanpos = xsp; 5383 if (jj_scan_token(12)) { 5384 jj_scanpos = xsp; 5385 if (jj_scan_token(28)) { 5386 jj_scanpos = xsp; 5387 if (jj_scan_token(46)) { 5388 jj_scanpos = xsp; 5389 if (jj_scan_token(45)) { 5390 jj_scanpos = xsp; 5391 if (jj_scan_token(44)) { 5392 jj_scanpos = xsp; 5393 if (jj_scan_token(62)) return true; 5394 } 5395 } 5396 } 5397 } 5398 } 5399 } 5400 return false; 5401 } 5402 5403 final private boolean jj_3_8() { 5404 Token xsp; 5405 while (true) { 5406 xsp = jj_scanpos; 5407 if (jj_3R_50()) { jj_scanpos = xsp; break; } 5408 } 5409 if (jj_scan_token(INTERFACE)) return true; 5410 return false; 5411 } 5412 5413 final private boolean jj_3R_49() { 5414 Token xsp; 5415 xsp = jj_scanpos; 5416 if (jj_scan_token(49)) { 5417 jj_scanpos = xsp; 5418 if (jj_scan_token(12)) { 5419 jj_scanpos = xsp; 5420 if (jj_scan_token(28)) { 5421 jj_scanpos = xsp; 5422 if (jj_scan_token(46)) { 5423 jj_scanpos = xsp; 5424 if (jj_scan_token(45)) { 5425 jj_scanpos = xsp; 5426 if (jj_scan_token(44)) { 5427 jj_scanpos = xsp; 5428 if (jj_scan_token(62)) return true; 5429 } 5430 } 5431 } 5432 } 5433 } 5434 } 5435 return false; 5436 } 5437 5438 final private boolean jj_3_7() { 5439 Token xsp; 5440 while (true) { 5441 xsp = jj_scanpos; 5442 if (jj_3R_49()) { jj_scanpos = xsp; break; } 5443 } 5444 if (jj_scan_token(CLASS)) return true; 5445 return false; 5446 } 5447 5448 final private boolean jj_3R_290() { 5449 if (jj_3R_211()) return true; 5450 return false; 5451 } 5452 5453 final private boolean jj_3R_289() { 5454 if (jj_3R_210()) return true; 5455 return false; 5456 } 5457 5458 final private boolean jj_3R_288() { 5459 if (jj_3R_208()) return true; 5460 return false; 5461 } 5462 5463 final private boolean jj_3R_287() { 5464 if (jj_3R_207()) return true; 5465 return false; 5466 } 5467 5468 final private boolean jj_3R_251() { 5469 if (jj_3R_280()) return true; 5470 return false; 5471 } 5472 5473 final private boolean jj_3R_280() { 5474 Token xsp; 5475 xsp = jj_scanpos; 5476 if (jj_3R_287()) { 5477 jj_scanpos = xsp; 5478 if (jj_3R_288()) { 5479 jj_scanpos = xsp; 5480 if (jj_3R_289()) { 5481 jj_scanpos = xsp; 5482 if (jj_3R_290()) { 5483 jj_scanpos = xsp; 5484 if (jj_scan_token(80)) return true; 5485 } 5486 } 5487 } 5488 } 5489 return false; 5490 } 5491 5492 final private boolean jj_3R_250() { 5493 if (jj_scan_token(EXTENDS)) return true; 5494 if (jj_3R_256()) return true; 5495 return false; 5496 } 5497 5498 final private boolean jj_3R_116() { 5499 if (jj_scan_token(INTERFACE)) return true; 5500 if (jj_scan_token(IDENTIFIER)) return true; 5501 Token xsp; 5502 xsp = jj_scanpos; 5503 if (jj_3R_250()) jj_scanpos = xsp; 5504 if (jj_scan_token(LBRACE)) return true; 5505 while (true) { 5506 xsp = jj_scanpos; 5507 if (jj_3R_251()) { jj_scanpos = xsp; break; } 5508 } 5509 if (jj_scan_token(RBRACE)) return true; 5510 return false; 5511 } 5512 5513 final private boolean jj_3R_249() { 5514 if (jj_scan_token(STRICTFP)) return true; 5515 return false; 5516 } 5517 5518 final private boolean jj_3R_248() { 5519 if (jj_scan_token(PRIVATE)) return true; 5520 return false; 5521 } 5522 5523 final private boolean jj_3R_247() { 5524 if (jj_scan_token(PROTECTED)) return true; 5525 return false; 5526 } 5527 5528 final private boolean jj_3R_246() { 5529 if (jj_scan_token(PUBLIC)) return true; 5530 return false; 5531 } 5532 5533 final private boolean jj_3R_245() { 5534 if (jj_scan_token(FINAL)) return true; 5535 return false; 5536 } 5537 5538 final private boolean jj_3R_244() { 5539 if (jj_scan_token(ABSTRACT)) return true; 5540 return false; 5541 } 5542 5543 final private boolean jj_3R_218() { 5544 Token xsp; 5545 xsp = jj_scanpos; 5546 if (jj_3R_243()) { 5547 jj_scanpos = xsp; 5548 if (jj_3R_244()) { 5549 jj_scanpos = xsp; 5550 if (jj_3R_245()) { 5551 jj_scanpos = xsp; 5552 if (jj_3R_246()) { 5553 jj_scanpos = xsp; 5554 if (jj_3R_247()) { 5555 jj_scanpos = xsp; 5556 if (jj_3R_248()) { 5557 jj_scanpos = xsp; 5558 if (jj_3R_249()) return true; 5559 } 5560 } 5561 } 5562 } 5563 } 5564 } 5565 return false; 5566 } 5567 5568 final private boolean jj_3R_243() { 5569 if (jj_scan_token(STATIC)) return true; 5570 return false; 5571 } 5572 5573 final private boolean jj_3R_208() { 5574 Token xsp; 5575 while (true) { 5576 xsp = jj_scanpos; 5577 if (jj_3R_218()) { jj_scanpos = xsp; break; } 5578 } 5579 if (jj_3R_116()) return true; 5580 return false; 5581 } 5582 5583 final private boolean jj_3R_322() { 5584 if (jj_scan_token(STRICTFP)) return true; 5585 return false; 5586 } 5587 5588 final private boolean jj_3R_321() { 5589 if (jj_scan_token(PUBLIC)) return true; 5590 return false; 5591 } 5592 5593 final private boolean jj_3R_320() { 5594 if (jj_scan_token(ABSTRACT)) return true; 5595 return false; 5596 } 5597 5598 final private boolean jj_3R_310() { 5599 Token xsp; 5600 xsp = jj_scanpos; 5601 if (jj_3R_320()) { 5602 jj_scanpos = xsp; 5603 if (jj_3R_321()) { 5604 jj_scanpos = xsp; 5605 if (jj_3R_322()) return true; 5606 } 5607 } 5608 return false; 5609 } 5610 5611 final private boolean jj_3R_299() { 5612 Token xsp; 5613 while (true) { 5614 xsp = jj_scanpos; 5615 if (jj_3R_310()) { jj_scanpos = xsp; break; } 5616 } 5617 if (jj_3R_116()) return true; 5618 return false; 5619 } 5620 5621 final private boolean jj_3R_67() { 5622 Token xsp; 5623 xsp = jj_scanpos; 5624 if (jj_scan_token(46)) { 5625 jj_scanpos = xsp; 5626 if (jj_scan_token(45)) { 5627 jj_scanpos = xsp; 5628 if (jj_scan_token(44)) { 5629 jj_scanpos = xsp; 5630 if (jj_scan_token(49)) { 5631 jj_scanpos = xsp; 5632 if (jj_scan_token(12)) { 5633 jj_scanpos = xsp; 5634 if (jj_scan_token(28)) { 5635 jj_scanpos = xsp; 5636 if (jj_scan_token(40)) { 5637 jj_scanpos = xsp; 5638 if (jj_scan_token(52)) { 5639 jj_scanpos = xsp; 5640 if (jj_scan_token(62)) return true; 5641 } 5642 } 5643 } 5644 } 5645 } 5646 } 5647 } 5648 } 5649 return false; 5650 } 5651 5652 final private boolean jj_3R_48() { 5653 Token xsp; 5654 while (true) { 5655 xsp = jj_scanpos; 5656 if (jj_3R_67()) { jj_scanpos = xsp; break; } 5657 } 5658 if (jj_3R_59()) return true; 5659 if (jj_scan_token(IDENTIFIER)) return true; 5660 if (jj_scan_token(LPAREN)) return true; 5661 return false; 5662 } 5663 5664 final private boolean jj_3_6() { 5665 if (jj_3R_48()) return true; 5666 return false; 5667 } 5668 5669 final private boolean jj_3R_46() { 5670 Token xsp; 5671 xsp = jj_scanpos; 5672 if (jj_scan_token(46)) { 5673 jj_scanpos = xsp; 5674 if (jj_scan_token(45)) { 5675 jj_scanpos = xsp; 5676 if (jj_scan_token(44)) return true; 5677 } 5678 } 5679 return false; 5680 } 5681 5682 final private boolean jj_3_5() { 5683 Token xsp; 5684 xsp = jj_scanpos; 5685 if (jj_3R_46()) jj_scanpos = xsp; 5686 if (jj_3R_47()) return true; 5687 if (jj_scan_token(LPAREN)) return true; 5688 return false; 5689 } 5690 5691 final private boolean jj_3R_45() { 5692 Token xsp; 5693 xsp = jj_scanpos; 5694 if (jj_scan_token(49)) { 5695 jj_scanpos = xsp; 5696 if (jj_scan_token(12)) { 5697 jj_scanpos = xsp; 5698 if (jj_scan_token(28)) { 5699 jj_scanpos = xsp; 5700 if (jj_scan_token(46)) { 5701 jj_scanpos = xsp; 5702 if (jj_scan_token(45)) { 5703 jj_scanpos = xsp; 5704 if (jj_scan_token(44)) { 5705 jj_scanpos = xsp; 5706 if (jj_scan_token(62)) return true; 5707 } 5708 } 5709 } 5710 } 5711 } 5712 } 5713 return false; 5714 } 5715 5716 final private boolean jj_3_4() { 5717 Token xsp; 5718 while (true) { 5719 xsp = jj_scanpos; 5720 if (jj_3R_45()) { jj_scanpos = xsp; break; } 5721 } 5722 if (jj_scan_token(INTERFACE)) return true; 5723 return false; 5724 } 5725 5726 final private boolean jj_3R_44() { 5727 Token xsp; 5728 xsp = jj_scanpos; 5729 if (jj_scan_token(49)) { 5730 jj_scanpos = xsp; 5731 if (jj_scan_token(12)) { 5732 jj_scanpos = xsp; 5733 if (jj_scan_token(28)) { 5734 jj_scanpos = xsp; 5735 if (jj_scan_token(46)) { 5736 jj_scanpos = xsp; 5737 if (jj_scan_token(45)) { 5738 jj_scanpos = xsp; 5739 if (jj_scan_token(44)) { 5740 jj_scanpos = xsp; 5741 if (jj_scan_token(62)) return true; 5742 } 5743 } 5744 } 5745 } 5746 } 5747 } 5748 return false; 5749 } 5750 5751 final private boolean jj_3R_204() { 5752 if (jj_3R_211()) return true; 5753 return false; 5754 } 5755 5756 final private boolean jj_3_3() { 5757 Token xsp; 5758 while (true) { 5759 xsp = jj_scanpos; 5760 if (jj_3R_44()) { jj_scanpos = xsp; break; } 5761 } 5762 if (jj_scan_token(CLASS)) return true; 5763 return false; 5764 } 5765 5766 final private boolean jj_3R_203() { 5767 if (jj_3R_210()) return true; 5768 return false; 5769 } 5770 5771 final private boolean jj_3R_202() { 5772 if (jj_3R_209()) return true; 5773 return false; 5774 } 5775 5776 final private boolean jj_3R_201() { 5777 if (jj_3R_208()) return true; 5778 return false; 5779 } 5780 5781 final private boolean jj_3R_200() { 5782 if (jj_3R_207()) return true; 5783 return false; 5784 } 5785 5786 final private boolean jj_3_2() { 5787 if (jj_3R_43()) return true; 5788 return false; 5789 } 5790 5791 final private boolean jj_3R_197() { 5792 Token xsp; 5793 xsp = jj_scanpos; 5794 if (jj_3_2()) { 5795 jj_scanpos = xsp; 5796 if (jj_3R_200()) { 5797 jj_scanpos = xsp; 5798 if (jj_3R_201()) { 5799 jj_scanpos = xsp; 5800 if (jj_3R_202()) { 5801 jj_scanpos = xsp; 5802 if (jj_3R_203()) { 5803 jj_scanpos = xsp; 5804 if (jj_3R_204()) { 5805 jj_scanpos = xsp; 5806 if (jj_scan_token(80)) return true; 5807 } 5808 } 5809 } 5810 } 5811 } 5812 } 5813 return false; 5814 } 5815 5816 final private boolean jj_3R_240() { 5817 if (jj_scan_token(STRICTFP)) return true; 5818 return false; 5819 } 5820 5821 final private boolean jj_3R_239() { 5822 if (jj_scan_token(PRIVATE)) return true; 5823 return false; 5824 } 5825 5826 final private boolean jj_3R_238() { 5827 if (jj_scan_token(PROTECTED)) return true; 5828 return false; 5829 } 5830 5831 final private boolean jj_3R_237() { 5832 if (jj_scan_token(PUBLIC)) return true; 5833 return false; 5834 } 5835 5836 final private boolean jj_3R_236() { 5837 if (jj_scan_token(FINAL)) return true; 5838 return false; 5839 } 5840 5841 final private boolean jj_3R_235() { 5842 if (jj_scan_token(ABSTRACT)) return true; 5843 return false; 5844 } 5845 5846 final private boolean jj_3R_217() { 5847 Token xsp; 5848 xsp = jj_scanpos; 5849 if (jj_3R_234()) { 5850 jj_scanpos = xsp; 5851 if (jj_3R_235()) { 5852 jj_scanpos = xsp; 5853 if (jj_3R_236()) { 5854 jj_scanpos = xsp; 5855 if (jj_3R_237()) { 5856 jj_scanpos = xsp; 5857 if (jj_3R_238()) { 5858 jj_scanpos = xsp; 5859 if (jj_3R_239()) { 5860 jj_scanpos = xsp; 5861 if (jj_3R_240()) return true; 5862 } 5863 } 5864 } 5865 } 5866 } 5867 } 5868 return false; 5869 } 5870 5871 final private boolean jj_3R_234() { 5872 if (jj_scan_token(STATIC)) return true; 5873 return false; 5874 } 5875 5876 final private boolean jj_3R_300() { 5877 if (jj_scan_token(COLON)) return true; 5878 if (jj_3R_61()) return true; 5879 return false; 5880 } 5881 5882 final private boolean jj_3R_194() { 5883 if (jj_3R_197()) return true; 5884 return false; 5885 } 5886 5887 final private boolean jj_3R_207() { 5888 Token xsp; 5889 while (true) { 5890 xsp = jj_scanpos; 5891 if (jj_3R_217()) { jj_scanpos = xsp; break; } 5892 } 5893 if (jj_3R_115()) return true; 5894 return false; 5895 } 5896 5897 final private boolean jj_3R_190() { 5898 if (jj_scan_token(LBRACE)) return true; 5899 Token xsp; 5900 while (true) { 5901 xsp = jj_scanpos; 5902 if (jj_3R_194()) { jj_scanpos = xsp; break; } 5903 } 5904 if (jj_scan_token(RBRACE)) return true; 5905 return false; 5906 } 5907 5908 final private boolean jj_3R_242() { 5909 if (jj_scan_token(IMPLEMENTS)) return true; 5910 if (jj_3R_256()) return true; 5911 return false; 5912 } 5913 5914 final private boolean jj_3R_241() { 5915 if (jj_scan_token(EXTENDS)) return true; 5916 if (jj_3R_47()) return true; 5917 return false; 5918 } 5919 5920 final private boolean jj_3R_127() { 5921 if (jj_scan_token(IDENTIFIER)) return true; 5922 if (jj_3R_61()) return true; 5923 Token xsp; 5924 xsp = jj_scanpos; 5925 if (jj_3R_300()) jj_scanpos = xsp; 5926 if (jj_scan_token(SEMICOLON)) return true; 5927 return false; 5928 } 5929 5930 final private boolean jj_3R_115() { 5931 if (jj_scan_token(CLASS)) return true; 5932 if (jj_scan_token(IDENTIFIER)) return true; 5933 Token xsp; 5934 xsp = jj_scanpos; 5935 if (jj_3R_241()) jj_scanpos = xsp; 5936 xsp = jj_scanpos; 5937 if (jj_3R_242()) jj_scanpos = xsp; 5938 if (jj_3R_190()) return true; 5939 return false; 5940 } 5941 5942 final private boolean jj_3R_319() { 5943 if (jj_scan_token(STRICTFP)) return true; 5944 return false; 5945 } 5946 5947 final private boolean jj_3R_318() { 5948 if (jj_scan_token(PUBLIC)) return true; 5949 return false; 5950 } 5951 5952 final private boolean jj_3R_317() { 5953 if (jj_scan_token(FINAL)) return true; 5954 return false; 5955 } 5956 5957 final private boolean jj_3R_308() { 5958 if (jj_scan_token(FINALLY)) return true; 5959 if (jj_3R_66()) return true; 5960 return false; 5961 } 5962 5963 final private boolean jj_3R_316() { 5964 if (jj_scan_token(ABSTRACT)) return true; 5965 return false; 5966 } 5967 5968 final private boolean jj_3R_309() { 5969 Token xsp; 5970 xsp = jj_scanpos; 5971 if (jj_3R_316()) { 5972 jj_scanpos = xsp; 5973 if (jj_3R_317()) { 5974 jj_scanpos = xsp; 5975 if (jj_3R_318()) { 5976 jj_scanpos = xsp; 5977 if (jj_3R_319()) return true; 5978 } 5979 } 5980 } 5981 return false; 5982 } 5983 5984 final private boolean jj_3R_307() { 5985 if (jj_scan_token(CATCH)) return true; 5986 if (jj_scan_token(LPAREN)) return true; 5987 if (jj_3R_281()) return true; 5988 if (jj_scan_token(RPAREN)) return true; 5989 if (jj_3R_66()) return true; 5990 return false; 5991 } 5992 5993 final private boolean jj_3R_298() { 5994 Token xsp; 5995 while (true) { 5996 xsp = jj_scanpos; 5997 if (jj_3R_309()) { jj_scanpos = xsp; break; } 5998 } 5999 if (jj_3R_115()) return true; 6000 return false; 6001 } 6002 6003 final private boolean jj_3R_140() { 6004 if (jj_scan_token(TRY)) return true; 6005 if (jj_3R_66()) return true; 6006 Token xsp; 6007 while (true) { 6008 xsp = jj_scanpos; 6009 if (jj_3R_307()) { jj_scanpos = xsp; break; } 6010 } 6011 xsp = jj_scanpos; 6012 if (jj_3R_308()) jj_scanpos = xsp; 6013 return false; 6014 } 6015 6016 final private boolean jj_3R_42() { 6017 Token xsp; 6018 xsp = jj_scanpos; 6019 if (jj_scan_token(12)) { 6020 jj_scanpos = xsp; 6021 if (jj_scan_token(28)) { 6022 jj_scanpos = xsp; 6023 if (jj_scan_token(46)) { 6024 jj_scanpos = xsp; 6025 if (jj_scan_token(62)) return true; 6026 } 6027 } 6028 } 6029 return false; 6030 } 6031 6032 final private boolean jj_3_1() { 6033 Token xsp; 6034 while (true) { 6035 xsp = jj_scanpos; 6036 if (jj_3R_42()) { jj_scanpos = xsp; break; } 6037 } 6038 if (jj_scan_token(CLASS)) return true; 6039 return false; 6040 } 6041 6042 final private boolean jj_3R_305() { 6043 if (jj_3R_315()) return true; 6044 return false; 6045 } 6046 6047 final private boolean jj_3R_139() { 6048 if (jj_scan_token(SYNCHRONIZED)) return true; 6049 if (jj_scan_token(LPAREN)) return true; 6050 if (jj_3R_61()) return true; 6051 if (jj_scan_token(RPAREN)) return true; 6052 if (jj_3R_66()) return true; 6053 return false; 6054 } 6055 6056 final private boolean jj_3R_306() { 6057 if (jj_3R_61()) return true; 6058 return false; 6059 } 6060 6061 final private boolean jj_3R_297() { 6062 if (jj_3R_299()) return true; 6063 return false; 6064 } 6065 6066 final private boolean jj_3R_296() { 6067 if (jj_3R_298()) return true; 6068 return false; 6069 } 6070 6071 final private boolean jj_3R_292() { 6072 Token xsp; 6073 xsp = jj_scanpos; 6074 if (jj_3R_296()) { 6075 jj_scanpos = xsp; 6076 if (jj_3R_297()) { 6077 jj_scanpos = xsp; 6078 if (jj_scan_token(80)) return true; 6079 } 6080 } 6081 return false; 6082 } 6083 6084 final private boolean jj_3R_138() { 6085 if (jj_scan_token(THROW)) return true; 6086 if (jj_3R_61()) return true; 6087 if (jj_scan_token(SEMICOLON)) return true; 6088 return false; 6089 } 6090 6091 final private boolean jj_3R_329() { 6092 if (jj_scan_token(COMMA)) return true; 6093 if (jj_3R_129()) return true; 6094 return false; 6095 } 6096 6097 final private boolean jj_3R_137() { 6098 if (jj_scan_token(RETURN)) return true; 6099 Token xsp; 6100 xsp = jj_scanpos; 6101 if (jj_3R_306()) jj_scanpos = xsp; 6102 if (jj_scan_token(SEMICOLON)) return true; 6103 return false; 6104 } 6105 6106 final private boolean jj_3R_136() { 6107 if (jj_scan_token(CONTINUE)) return true; 6108 Token xsp; 6109 xsp = jj_scanpos; 6110 if (jj_scan_token(71)) jj_scanpos = xsp; 6111 if (jj_scan_token(SEMICOLON)) return true; 6112 return false; 6113 } 6114 6115 final private boolean jj_3R_304() { 6116 if (jj_3R_61()) return true; 6117 return false; 6118 } 6119 6120 final private boolean jj_3R_135() { 6121 if (jj_scan_token(BREAK)) return true; 6122 Token xsp; 6123 xsp = jj_scanpos; 6124 if (jj_scan_token(71)) jj_scanpos = xsp; 6125 if (jj_scan_token(SEMICOLON)) return true; 6126 return false; 6127 } 6128 6129 final private boolean jj_3R_315() { 6130 if (jj_3R_328()) return true; 6131 return false; 6132 } 6133 6134 final private boolean jj_3R_302() { 6135 if (jj_scan_token(ELSE)) return true; 6136 if (jj_3R_64()) return true; 6137 return false; 6138 } 6139 6140 final private boolean jj_3_34() { 6141 Token xsp; 6142 xsp = jj_scanpos; 6143 if (jj_scan_token(28)) jj_scanpos = xsp; 6144 if (jj_3R_63()) return true; 6145 if (jj_scan_token(IDENTIFIER)) return true; 6146 return false; 6147 } 6148 6149 final private boolean jj_3R_328() { 6150 if (jj_3R_129()) return true; 6151 Token xsp; 6152 while (true) { 6153 xsp = jj_scanpos; 6154 if (jj_3R_329()) { jj_scanpos = xsp; break; } 6155 } 6156 return false; 6157 } 6158 6159 final private boolean jj_3R_303() { 6160 if (jj_3R_314()) return true; 6161 return false; 6162 } 6163 6164 final private boolean jj_3R_327() { 6165 if (jj_3R_328()) return true; 6166 return false; 6167 } 6168 6169 final private boolean jj_3R_326() { 6170 if (jj_3R_114()) return true; 6171 return false; 6172 } 6173 6174 final private boolean jj_3R_314() { 6175 Token xsp; 6176 xsp = jj_scanpos; 6177 if (jj_3R_326()) { 6178 jj_scanpos = xsp; 6179 if (jj_3R_327()) return true; 6180 } 6181 return false; 6182 } 6183 6184 final private boolean jj_3R_134() { 6185 if (jj_scan_token(FOR)) return true; 6186 if (jj_scan_token(LPAREN)) return true; 6187 Token xsp; 6188 xsp = jj_scanpos; 6189 if (jj_3R_303()) jj_scanpos = xsp; 6190 if (jj_scan_token(SEMICOLON)) return true; 6191 xsp = jj_scanpos; 6192 if (jj_3R_304()) jj_scanpos = xsp; 6193 if (jj_scan_token(SEMICOLON)) return true; 6194 xsp = jj_scanpos; 6195 if (jj_3R_305()) jj_scanpos = xsp; 6196 if (jj_scan_token(RPAREN)) return true; 6197 if (jj_3R_64()) return true; 6198 return false; 6199 } 6200 6201 final private boolean jj_3R_133() { 6202 if (jj_scan_token(DO)) return true; 6203 if (jj_3R_64()) return true; 6204 if (jj_scan_token(WHILE)) return true; 6205 if (jj_scan_token(LPAREN)) return true; 6206 if (jj_3R_61()) return true; 6207 if (jj_scan_token(RPAREN)) return true; 6208 if (jj_scan_token(SEMICOLON)) return true; 6209 return false; 6210 } 6211 6212 final private boolean jj_3R_132() { 6213 if (jj_scan_token(WHILE)) return true; 6214 if (jj_scan_token(LPAREN)) return true; 6215 if (jj_3R_61()) return true; 6216 if (jj_scan_token(RPAREN)) return true; 6217 if (jj_3R_64()) return true; 6218 return false; 6219 } 6220 6221 final private boolean jj_3R_295() { 6222 if (jj_scan_token(COMMA)) return true; 6223 if (jj_3R_228()) return true; 6224 return false; 6225 } 6226 6227 final private boolean jj_3R_131() { 6228 if (jj_scan_token(IF)) return true; 6229 if (jj_scan_token(LPAREN)) return true; 6230 if (jj_3R_61()) return true; 6231 if (jj_scan_token(RPAREN)) return true; 6232 if (jj_3R_64()) return true; 6233 Token xsp; 6234 xsp = jj_scanpos; 6235 if (jj_3R_302()) jj_scanpos = xsp; 6236 return false; 6237 } 6238 6239 final private boolean jj_3_33() { 6240 if (jj_3R_53()) return true; 6241 return false; 6242 } 6243 6244 final private boolean jj_3R_325() { 6245 if (jj_scan_token(_DEFAULT)) return true; 6246 if (jj_scan_token(COLON)) return true; 6247 return false; 6248 } 6249 6250 final private boolean jj_3R_324() { 6251 if (jj_scan_token(CASE)) return true; 6252 if (jj_3R_61()) return true; 6253 if (jj_scan_token(COLON)) return true; 6254 return false; 6255 } 6256 6257 final private boolean jj_3R_313() { 6258 Token xsp; 6259 xsp = jj_scanpos; 6260 if (jj_3R_324()) { 6261 jj_scanpos = xsp; 6262 if (jj_3R_325()) return true; 6263 } 6264 return false; 6265 } 6266 6267 final private boolean jj_3R_301() { 6268 if (jj_3R_313()) return true; 6269 Token xsp; 6270 while (true) { 6271 xsp = jj_scanpos; 6272 if (jj_3_33()) { jj_scanpos = xsp; break; } 6273 } 6274 return false; 6275 } 6276 6277 final private boolean jj_3R_130() { 6278 if (jj_scan_token(SWITCH)) return true; 6279 if (jj_scan_token(LPAREN)) return true; 6280 if (jj_3R_61()) return true; 6281 if (jj_scan_token(RPAREN)) return true; 6282 if (jj_scan_token(LBRACE)) return true; 6283 Token xsp; 6284 while (true) { 6285 xsp = jj_scanpos; 6286 if (jj_3R_301()) { jj_scanpos = xsp; break; } 6287 } 6288 if (jj_scan_token(RBRACE)) return true; 6289 return false; 6290 } 6291 6292 final private boolean jj_3R_323() { 6293 if (jj_3R_161()) return true; 6294 if (jj_3R_61()) return true; 6295 return false; 6296 } 6297 6298 final private boolean jj_3R_312() { 6299 Token xsp; 6300 xsp = jj_scanpos; 6301 if (jj_scan_token(96)) { 6302 jj_scanpos = xsp; 6303 if (jj_scan_token(97)) { 6304 jj_scanpos = xsp; 6305 if (jj_3R_323()) return true; 6306 } 6307 } 6308 return false; 6309 } 6310 6311 final private boolean jj_3R_147() { 6312 if (jj_3R_54()) return true; 6313 Token xsp; 6314 xsp = jj_scanpos; 6315 if (jj_3R_312()) jj_scanpos = xsp; 6316 return false; 6317 } 6318 6319 final private boolean jj_3R_146() { 6320 if (jj_3R_157()) return true; 6321 return false; 6322 } 6323 6324 final private boolean jj_3R_145() { 6325 if (jj_3R_156()) return true; 6326 return false; 6327 } 6328 6329 final private boolean jj_3R_129() { 6330 Token xsp; 6331 xsp = jj_scanpos; 6332 if (jj_3R_145()) { 6333 jj_scanpos = xsp; 6334 if (jj_3R_146()) { 6335 jj_scanpos = xsp; 6336 if (jj_3R_147()) return true; 6337 } 6338 } 6339 return false; 6340 } 6341 6342 final private boolean jj_3R_128() { 6343 if (jj_scan_token(SEMICOLON)) return true; 6344 return false; 6345 } 6346 6347 final private boolean jj_3R_141() { 6348 if (jj_scan_token(FINAL)) return true; 6349 return false; 6350 } 6351 6352 final private boolean jj_3R_114() { 6353 Token xsp; 6354 xsp = jj_scanpos; 6355 if (jj_3R_141()) jj_scanpos = xsp; 6356 if (jj_3R_63()) return true; 6357 if (jj_3R_228()) return true; 6358 while (true) { 6359 xsp = jj_scanpos; 6360 if (jj_3R_295()) { jj_scanpos = xsp; break; } 6361 } 6362 return false; 6363 } 6364 6365 final private boolean jj_3_31() { 6366 Token xsp; 6367 xsp = jj_scanpos; 6368 if (jj_scan_token(28)) jj_scanpos = xsp; 6369 if (jj_3R_63()) return true; 6370 if (jj_scan_token(IDENTIFIER)) return true; 6371 return false; 6372 } 6373 6374 final private boolean jj_3R_76() { 6375 if (jj_3R_116()) return true; 6376 return false; 6377 } 6378 6379 final private boolean jj_3R_75() { 6380 if (jj_3R_115()) return true; 6381 return false; 6382 } 6383 6384 final private boolean jj_3_32() { 6385 if (jj_3R_64()) return true; 6386 return false; 6387 } 6388 6389 final private boolean jj_3R_74() { 6390 if (jj_scan_token(FINAL)) return true; 6391 if (jj_3R_292()) return true; 6392 return false; 6393 } 6394 6395 final private boolean jj_3R_73() { 6396 if (jj_3R_114()) return true; 6397 if (jj_scan_token(SEMICOLON)) return true; 6398 return false; 6399 } 6400 6401 final private boolean jj_3_30() { 6402 if (jj_3R_53()) return true; 6403 return false; 6404 } 6405 6406 final private boolean jj_3R_53() { 6407 Token xsp; 6408 xsp = jj_scanpos; 6409 lookingAhead = true; 6410 jj_semLA = isNextTokenAnAssert(); 6411 lookingAhead = false; 6412 if (!jj_semLA || jj_3R_72()) { 6413 jj_scanpos = xsp; 6414 if (jj_3R_73()) { 6415 jj_scanpos = xsp; 6416 if (jj_3R_74()) { 6417 jj_scanpos = xsp; 6418 if (jj_3_32()) { 6419 jj_scanpos = xsp; 6420 if (jj_3R_75()) { 6421 jj_scanpos = xsp; 6422 if (jj_3R_76()) return true; 6423 } 6424 } 6425 } 6426 } 6427 } 6428 return false; 6429 } 6430 6431 final private boolean jj_3R_72() { 6432 if (jj_3R_64()) return true; 6433 return false; 6434 } 6435 6436 final private boolean jj_3_27() { 6437 if (jj_scan_token(LBRACKET)) return true; 6438 if (jj_scan_token(RBRACKET)) return true; 6439 return false; 6440 } 6441 6442 final private boolean jj_3R_66() { 6443 if (jj_scan_token(LBRACE)) return true; 6444 Token xsp; 6445 while (true) { 6446 xsp = jj_scanpos; 6447 if (jj_3_30()) { jj_scanpos = xsp; break; } 6448 } 6449 if (jj_scan_token(RBRACE)) return true; 6450 return false; 6451 } 6452 6453 final private boolean jj_3R_62() { 6454 if (jj_scan_token(IDENTIFIER)) return true; 6455 if (jj_scan_token(COLON)) return true; 6456 if (jj_3R_64()) return true; 6457 return false; 6458 } 6459 6460 final private boolean jj_3R_112() { 6461 if (jj_3R_140()) return true; 6462 return false; 6463 } 6464 6465 final private boolean jj_3R_111() { 6466 if (jj_3R_139()) return true; 6467 return false; 6468 } 6469 6470 final private boolean jj_3R_110() { 6471 if (jj_3R_138()) return true; 6472 return false; 6473 } 6474 6475 final private boolean jj_3R_109() { 6476 if (jj_3R_137()) return true; 6477 return false; 6478 } 6479 6480 final private boolean jj_3R_108() { 6481 if (jj_3R_136()) return true; 6482 return false; 6483 } 6484 6485 final private boolean jj_3R_107() { 6486 if (jj_3R_135()) return true; 6487 return false; 6488 } 6489 6490 final private boolean jj_3R_106() { 6491 if (jj_3R_134()) return true; 6492 return false; 6493 } 6494 6495 final private boolean jj_3R_105() { 6496 if (jj_3R_133()) return true; 6497 return false; 6498 } 6499 6500 final private boolean jj_3R_104() { 6501 if (jj_3R_132()) return true; 6502 return false; 6503 } 6504 6505 final private boolean jj_3R_103() { 6506 if (jj_3R_131()) return true; 6507 return false; 6508 } 6509 6510 final private boolean jj_3R_102() { 6511 if (jj_3R_130()) return true; 6512 return false; 6513 } 6514 6515 final private boolean jj_3R_101() { 6516 if (jj_3R_129()) return true; 6517 if (jj_scan_token(SEMICOLON)) return true; 6518 return false; 6519 } 6520 6521 final private boolean jj_3R_100() { 6522 if (jj_3R_128()) return true; 6523 return false; 6524 } 6525 6526 final private boolean jj_3R_99() { 6527 if (jj_3R_66()) return true; 6528 return false; 6529 } 6530 6531 final private boolean jj_3_29() { 6532 if (jj_3R_62()) return true; 6533 return false; 6534 } 6535 6536 final private boolean jj_3R_98() { 6537 if (jj_3R_127()) return true; 6538 return false; 6539 } 6540 6541 final private boolean jj_3R_64() { 6542 Token xsp; 6543 xsp = jj_scanpos; 6544 lookingAhead = true; 6545 jj_semLA = isNextTokenAnAssert(); 6546 lookingAhead = false; 6547 if (!jj_semLA || jj_3R_98()) { 6548 jj_scanpos = xsp; 6549 if (jj_3_29()) { 6550 jj_scanpos = xsp; 6551 if (jj_3R_99()) { 6552 jj_scanpos = xsp; 6553 if (jj_3R_100()) { 6554 jj_scanpos = xsp; 6555 if (jj_3R_101()) { 6556 jj_scanpos = xsp; 6557 if (jj_3R_102()) { 6558 jj_scanpos = xsp; 6559 if (jj_3R_103()) { 6560 jj_scanpos = xsp; 6561 if (jj_3R_104()) { 6562 jj_scanpos = xsp; 6563 if (jj_3R_105()) { 6564 jj_scanpos = xsp; 6565 if (jj_3R_106()) { 6566 jj_scanpos = xsp; 6567 if (jj_3R_107()) { 6568 jj_scanpos = xsp; 6569 if (jj_3R_108()) { 6570 jj_scanpos = xsp; 6571 if (jj_3R_109()) { 6572 jj_scanpos = xsp; 6573 if (jj_3R_110()) { 6574 jj_scanpos = xsp; 6575 if (jj_3R_111()) { 6576 jj_scanpos = xsp; 6577 if (jj_3R_112()) return true; 6578 } 6579 } 6580 } 6581 } 6582 } 6583 } 6584 } 6585 } 6586 } 6587 } 6588 } 6589 } 6590 } 6591 } 6592 } 6593 return false; 6594 } 6595 6596 final private boolean jj_3R_186() { 6597 if (jj_3R_190()) return true; 6598 return false; 6599 } 6600 6601 final private boolean jj_3R_189() { 6602 if (jj_scan_token(LBRACKET)) return true; 6603 if (jj_scan_token(RBRACKET)) return true; 6604 return false; 6605 } 6606 6607 final private boolean jj_3_26() { 6608 if (jj_scan_token(LBRACKET)) return true; 6609 if (jj_3R_61()) return true; 6610 if (jj_scan_token(RBRACKET)) return true; 6611 return false; 6612 } 6613 6614 final private boolean jj_3R_185() { 6615 Token xsp; 6616 if (jj_3R_189()) return true; 6617 while (true) { 6618 xsp = jj_scanpos; 6619 if (jj_3R_189()) { jj_scanpos = xsp; break; } 6620 } 6621 if (jj_3R_113()) return true; 6622 return false; 6623 } 6624 6625 final private boolean jj_3_28() { 6626 Token xsp; 6627 if (jj_3_26()) return true; 6628 while (true) { 6629 xsp = jj_scanpos; 6630 if (jj_3_26()) { jj_scanpos = xsp; break; } 6631 } 6632 while (true) { 6633 xsp = jj_scanpos; 6634 if (jj_3_27()) { jj_scanpos = xsp; break; } 6635 } 6636 return false; 6637 } 6638 6639 final private boolean jj_3R_180() { 6640 Token xsp; 6641 xsp = jj_scanpos; 6642 if (jj_3_28()) { 6643 jj_scanpos = xsp; 6644 if (jj_3R_185()) return true; 6645 } 6646 return false; 6647 } 6648 6649 final private boolean jj_3R_182() { 6650 if (jj_3R_55()) return true; 6651 Token xsp; 6652 xsp = jj_scanpos; 6653 if (jj_3R_186()) jj_scanpos = xsp; 6654 return false; 6655 } 6656 6657 final private boolean jj_3R_143() { 6658 if (jj_scan_token(COMMA)) return true; 6659 if (jj_3R_61()) return true; 6660 return false; 6661 } 6662 6663 final private boolean jj_3R_181() { 6664 if (jj_3R_180()) return true; 6665 return false; 6666 } 6667 6668 final private boolean jj_3R_93() { 6669 if (jj_scan_token(NEW)) return true; 6670 if (jj_3R_47()) return true; 6671 Token xsp; 6672 xsp = jj_scanpos; 6673 if (jj_3R_181()) { 6674 jj_scanpos = xsp; 6675 if (jj_3R_182()) return true; 6676 } 6677 return false; 6678 } 6679 6680 final private boolean jj_3_25() { 6681 if (jj_scan_token(NEW)) return true; 6682 if (jj_3R_57()) return true; 6683 if (jj_3R_180()) return true; 6684 return false; 6685 } 6686 6687 final private boolean jj_3R_60() { 6688 Token xsp; 6689 xsp = jj_scanpos; 6690 if (jj_3_25()) { 6691 jj_scanpos = xsp; 6692 if (jj_3R_93()) return true; 6693 } 6694 return false; 6695 } 6696 6697 final private boolean jj_3R_124() { 6698 if (jj_3R_61()) return true; 6699 Token xsp; 6700 while (true) { 6701 xsp = jj_scanpos; 6702 if (jj_3R_143()) { jj_scanpos = xsp; break; } 6703 } 6704 return false; 6705 } 6706 6707 final private boolean jj_3R_78() { 6708 if (jj_3R_124()) return true; 6709 return false; 6710 } 6711 6712 final private boolean jj_3R_125() { 6713 if (jj_3R_142()) return true; 6714 return false; 6715 } 6716 6717 final private boolean jj_3R_55() { 6718 if (jj_scan_token(LPAREN)) return true; 6719 Token xsp; 6720 xsp = jj_scanpos; 6721 if (jj_3R_78()) jj_scanpos = xsp; 6722 if (jj_scan_token(RPAREN)) return true; 6723 return false; 6724 } 6725 6726 final private boolean jj_3R_159() { 6727 if (jj_scan_token(NULL)) return true; 6728 return false; 6729 } 6730 6731 final private boolean jj_3R_158() { 6732 Token xsp; 6733 xsp = jj_scanpos; 6734 if (jj_3R_163()) { 6735 jj_scanpos = xsp; 6736 if (jj_scan_token(27)) return true; 6737 } 6738 return false; 6739 } 6740 6741 final private boolean jj_3R_163() { 6742 if (jj_scan_token(TRUE)) return true; 6743 return false; 6744 } 6745 6746 final private boolean jj_3R_153() { 6747 if (jj_3R_159()) return true; 6748 return false; 6749 } 6750 6751 final private boolean jj_3R_152() { 6752 if (jj_3R_158()) return true; 6753 return false; 6754 } 6755 6756 final private boolean jj_3R_151() { 6757 if (jj_scan_token(STRING_LITERAL)) return true; 6758 return false; 6759 } 6760 6761 final private boolean jj_3R_150() { 6762 if (jj_scan_token(CHARACTER_LITERAL)) return true; 6763 return false; 6764 } 6765 6766 final private boolean jj_3R_149() { 6767 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true; 6768 return false; 6769 } 6770 6771 final private boolean jj_3R_148() { 6772 if (jj_scan_token(INTEGER_LITERAL)) return true; 6773 return false; 6774 } 6775 6776 final private boolean jj_3R_142() { 6777 Token xsp; 6778 xsp = jj_scanpos; 6779 if (jj_3R_148()) { 6780 jj_scanpos = xsp; 6781 if (jj_3R_149()) { 6782 jj_scanpos = xsp; 6783 if (jj_3R_150()) { 6784 jj_scanpos = xsp; 6785 if (jj_3R_151()) { 6786 jj_scanpos = xsp; 6787 if (jj_3R_152()) { 6788 jj_scanpos = xsp; 6789 if (jj_3R_153()) return true; 6790 } 6791 } 6792 } 6793 } 6794 } 6795 return false; 6796 } 6797 6798 final private boolean jj_3R_91() { 6799 if (jj_3R_55()) return true; 6800 return false; 6801 } 6802 6803 final private boolean jj_3R_90() { 6804 if (jj_scan_token(DOT)) return true; 6805 if (jj_scan_token(IDENTIFIER)) return true; 6806 return false; 6807 } 6808 6809 final private boolean jj_3R_89() { 6810 if (jj_scan_token(LBRACKET)) return true; 6811 if (jj_3R_61()) return true; 6812 if (jj_scan_token(RBRACKET)) return true; 6813 return false; 6814 } 6815 6816 final private boolean jj_3_24() { 6817 if (jj_scan_token(DOT)) return true; 6818 if (jj_3R_60()) return true; 6819 return false; 6820 } 6821 6822 final private boolean jj_3_21() { 6823 if (jj_3R_59()) return true; 6824 if (jj_scan_token(DOT)) return true; 6825 if (jj_scan_token(CLASS)) return true; 6826 return false; 6827 } 6828 6829 final private boolean jj_3_23() { 6830 if (jj_scan_token(DOT)) return true; 6831 if (jj_scan_token(SUPER)) return true; 6832 return false; 6833 } 6834 6835 final private boolean jj_3R_58() { 6836 Token xsp; 6837 xsp = jj_scanpos; 6838 if (jj_3_22()) { 6839 jj_scanpos = xsp; 6840 if (jj_3_23()) { 6841 jj_scanpos = xsp; 6842 if (jj_3_24()) { 6843 jj_scanpos = xsp; 6844 if (jj_3R_89()) { 6845 jj_scanpos = xsp; 6846 if (jj_3R_90()) { 6847 jj_scanpos = xsp; 6848 if (jj_3R_91()) return true; 6849 } 6850 } 6851 } 6852 } 6853 } 6854 return false; 6855 } 6856 6857 final private boolean jj_3_22() { 6858 if (jj_scan_token(DOT)) return true; 6859 if (jj_scan_token(THIS)) return true; 6860 return false; 6861 } 6862 6863 final private boolean jj_3_20() { 6864 if (jj_3R_58()) return true; 6865 return false; 6866 } 6867 6868 final private boolean jj_3R_123() { 6869 if (jj_3R_47()) return true; 6870 return false; 6871 } 6872 6873 final private boolean jj_3R_122() { 6874 if (jj_3R_59()) return true; 6875 if (jj_scan_token(DOT)) return true; 6876 if (jj_scan_token(CLASS)) return true; 6877 return false; 6878 } 6879 6880 final private boolean jj_3R_121() { 6881 if (jj_3R_60()) return true; 6882 return false; 6883 } 6884 6885 final private boolean jj_3R_120() { 6886 if (jj_scan_token(LPAREN)) return true; 6887 if (jj_3R_61()) return true; 6888 if (jj_scan_token(RPAREN)) return true; 6889 return false; 6890 } 6891 6892 final private boolean jj_3R_311() { 6893 Token xsp; 6894 xsp = jj_scanpos; 6895 if (jj_scan_token(96)) { 6896 jj_scanpos = xsp; 6897 if (jj_scan_token(97)) return true; 6898 } 6899 return false; 6900 } 6901 6902 final private boolean jj_3R_119() { 6903 if (jj_scan_token(SUPER)) return true; 6904 if (jj_scan_token(DOT)) return true; 6905 if (jj_scan_token(IDENTIFIER)) return true; 6906 return false; 6907 } 6908 6909 final private boolean jj_3R_118() { 6910 if (jj_scan_token(THIS)) return true; 6911 return false; 6912 } 6913 6914 final private boolean jj_3R_117() { 6915 if (jj_3R_142()) return true; 6916 return false; 6917 } 6918 6919 final private boolean jj_3R_77() { 6920 Token xsp; 6921 xsp = jj_scanpos; 6922 if (jj_3R_117()) { 6923 jj_scanpos = xsp; 6924 if (jj_3R_118()) { 6925 jj_scanpos = xsp; 6926 if (jj_3R_119()) { 6927 jj_scanpos = xsp; 6928 if (jj_3R_120()) { 6929 jj_scanpos = xsp; 6930 if (jj_3R_121()) { 6931 jj_scanpos = xsp; 6932 if (jj_3R_122()) { 6933 jj_scanpos = xsp; 6934 if (jj_3R_123()) return true; 6935 } 6936 } 6937 } 6938 } 6939 } 6940 } 6941 return false; 6942 } 6943 6944 final private boolean jj_3_19() { 6945 if (jj_scan_token(LPAREN)) return true; 6946 if (jj_3R_57()) return true; 6947 return false; 6948 } 6949 6950 final private boolean jj_3R_54() { 6951 if (jj_3R_77()) return true; 6952 Token xsp; 6953 while (true) { 6954 xsp = jj_scanpos; 6955 if (jj_3_20()) { jj_scanpos = xsp; break; } 6956 } 6957 return false; 6958 } 6959 6960 final private boolean jj_3R_294() { 6961 if (jj_scan_token(LPAREN)) return true; 6962 if (jj_3R_63()) return true; 6963 if (jj_scan_token(RPAREN)) return true; 6964 if (jj_3R_233()) return true; 6965 return false; 6966 } 6967 6968 final private boolean jj_3R_285() { 6969 Token xsp; 6970 xsp = jj_scanpos; 6971 if (jj_3R_293()) { 6972 jj_scanpos = xsp; 6973 if (jj_3R_294()) return true; 6974 } 6975 return false; 6976 } 6977 6978 final private boolean jj_3R_293() { 6979 if (jj_scan_token(LPAREN)) return true; 6980 if (jj_3R_63()) return true; 6981 if (jj_scan_token(RPAREN)) return true; 6982 if (jj_3R_206()) return true; 6983 return false; 6984 } 6985 6986 final private boolean jj_3_18() { 6987 if (jj_scan_token(LPAREN)) return true; 6988 if (jj_3R_47()) return true; 6989 if (jj_scan_token(LBRACKET)) return true; 6990 return false; 6991 } 6992 6993 final private boolean jj_3R_286() { 6994 if (jj_3R_54()) return true; 6995 Token xsp; 6996 xsp = jj_scanpos; 6997 if (jj_3R_311()) jj_scanpos = xsp; 6998 return false; 6999 } 7000 7001 final private boolean jj_3R_80() { 7002 if (jj_scan_token(LPAREN)) return true; 7003 if (jj_3R_47()) return true; 7004 if (jj_scan_token(RPAREN)) return true; 7005 Token xsp; 7006 xsp = jj_scanpos; 7007 if (jj_scan_token(87)) { 7008 jj_scanpos = xsp; 7009 if (jj_scan_token(86)) { 7010 jj_scanpos = xsp; 7011 if (jj_scan_token(74)) { 7012 jj_scanpos = xsp; 7013 if (jj_scan_token(71)) { 7014 jj_scanpos = xsp; 7015 if (jj_scan_token(53)) { 7016 jj_scanpos = xsp; 7017 if (jj_scan_token(50)) { 7018 jj_scanpos = xsp; 7019 if (jj_scan_token(41)) { 7020 jj_scanpos = xsp; 7021 if (jj_3R_125()) return true; 7022 } 7023 } 7024 } 7025 } 7026 } 7027 } 7028 } 7029 return false; 7030 } 7031 7032 final private boolean jj_3_16() { 7033 if (jj_3R_56()) return true; 7034 return false; 7035 } 7036 7037 final private boolean jj_3R_232() { 7038 if (jj_scan_token(MINUS)) return true; 7039 return false; 7040 } 7041 7042 final private boolean jj_3R_79() { 7043 if (jj_scan_token(LPAREN)) return true; 7044 if (jj_3R_47()) return true; 7045 if (jj_scan_token(LBRACKET)) return true; 7046 if (jj_scan_token(RBRACKET)) return true; 7047 return false; 7048 } 7049 7050 final private boolean jj_3R_56() { 7051 Token xsp; 7052 xsp = jj_scanpos; 7053 if (jj_3_17()) { 7054 jj_scanpos = xsp; 7055 if (jj_3R_79()) { 7056 jj_scanpos = xsp; 7057 if (jj_3R_80()) return true; 7058 } 7059 } 7060 return false; 7061 } 7062 7063 final private boolean jj_3_17() { 7064 if (jj_scan_token(LPAREN)) return true; 7065 if (jj_3R_57()) return true; 7066 return false; 7067 } 7068 7069 final private boolean jj_3R_279() { 7070 if (jj_3R_286()) return true; 7071 return false; 7072 } 7073 7074 final private boolean jj_3R_278() { 7075 if (jj_3R_285()) return true; 7076 return false; 7077 } 7078 7079 final private boolean jj_3R_233() { 7080 Token xsp; 7081 xsp = jj_scanpos; 7082 if (jj_3R_277()) { 7083 jj_scanpos = xsp; 7084 if (jj_3R_278()) { 7085 jj_scanpos = xsp; 7086 if (jj_3R_279()) return true; 7087 } 7088 } 7089 return false; 7090 } 7091 7092 final private boolean jj_3R_277() { 7093 Token xsp; 7094 xsp = jj_scanpos; 7095 if (jj_scan_token(87)) { 7096 jj_scanpos = xsp; 7097 if (jj_scan_token(86)) return true; 7098 } 7099 if (jj_3R_206()) return true; 7100 return false; 7101 } 7102 7103 final private boolean jj_3R_230() { 7104 Token xsp; 7105 xsp = jj_scanpos; 7106 if (jj_scan_token(98)) { 7107 jj_scanpos = xsp; 7108 if (jj_scan_token(99)) return true; 7109 } 7110 if (jj_3R_199()) return true; 7111 return false; 7112 } 7113 7114 final private boolean jj_3R_157() { 7115 if (jj_scan_token(DECR)) return true; 7116 if (jj_3R_54()) return true; 7117 return false; 7118 } 7119 7120 final private boolean jj_3R_276() { 7121 Token xsp; 7122 xsp = jj_scanpos; 7123 if (jj_scan_token(100)) { 7124 jj_scanpos = xsp; 7125 if (jj_scan_token(101)) { 7126 jj_scanpos = xsp; 7127 if (jj_scan_token(105)) return true; 7128 } 7129 } 7130 if (jj_3R_206()) return true; 7131 return false; 7132 } 7133 7134 final private boolean jj_3R_156() { 7135 if (jj_scan_token(INCR)) return true; 7136 if (jj_3R_54()) return true; 7137 return false; 7138 } 7139 7140 final private boolean jj_3R_212() { 7141 Token xsp; 7142 xsp = jj_scanpos; 7143 if (jj_scan_token(106)) { 7144 jj_scanpos = xsp; 7145 if (jj_scan_token(107)) { 7146 jj_scanpos = xsp; 7147 if (jj_scan_token(108)) return true; 7148 } 7149 } 7150 if (jj_3R_196()) return true; 7151 return false; 7152 } 7153 7154 final private boolean jj_3R_216() { 7155 if (jj_3R_233()) return true; 7156 return false; 7157 } 7158 7159 final private boolean jj_3R_215() { 7160 if (jj_3R_157()) return true; 7161 return false; 7162 } 7163 7164 final private boolean jj_3R_231() { 7165 if (jj_scan_token(PLUS)) return true; 7166 return false; 7167 } 7168 7169 final private boolean jj_3R_214() { 7170 if (jj_3R_156()) return true; 7171 return false; 7172 } 7173 7174 final private boolean jj_3R_206() { 7175 Token xsp; 7176 xsp = jj_scanpos; 7177 if (jj_3R_213()) { 7178 jj_scanpos = xsp; 7179 if (jj_3R_214()) { 7180 jj_scanpos = xsp; 7181 if (jj_3R_215()) { 7182 jj_scanpos = xsp; 7183 if (jj_3R_216()) return true; 7184 } 7185 } 7186 } 7187 return false; 7188 } 7189 7190 final private boolean jj_3R_213() { 7191 Token xsp; 7192 xsp = jj_scanpos; 7193 if (jj_3R_231()) { 7194 jj_scanpos = xsp; 7195 if (jj_3R_232()) return true; 7196 } 7197 if (jj_3R_206()) return true; 7198 return false; 7199 } 7200 7201 final private boolean jj_3R_205() { 7202 Token xsp; 7203 xsp = jj_scanpos; 7204 if (jj_scan_token(85)) { 7205 jj_scanpos = xsp; 7206 if (jj_scan_token(84)) { 7207 jj_scanpos = xsp; 7208 if (jj_scan_token(91)) { 7209 jj_scanpos = xsp; 7210 if (jj_scan_token(92)) return true; 7211 } 7212 } 7213 } 7214 if (jj_3R_192()) return true; 7215 return false; 7216 } 7217 7218 final private boolean jj_3R_198() { 7219 if (jj_scan_token(INSTANCEOF)) return true; 7220 if (jj_3R_63()) return true; 7221 return false; 7222 } 7223 7224 final private boolean jj_3R_199() { 7225 if (jj_3R_206()) return true; 7226 Token xsp; 7227 while (true) { 7228 xsp = jj_scanpos; 7229 if (jj_3R_276()) { jj_scanpos = xsp; break; } 7230 } 7231 return false; 7232 } 7233 7234 final private boolean jj_3R_195() { 7235 Token xsp; 7236 xsp = jj_scanpos; 7237 if (jj_scan_token(90)) { 7238 jj_scanpos = xsp; 7239 if (jj_scan_token(93)) return true; 7240 } 7241 if (jj_3R_184()) return true; 7242 return false; 7243 } 7244 7245 final private boolean jj_3R_196() { 7246 if (jj_3R_199()) return true; 7247 Token xsp; 7248 while (true) { 7249 xsp = jj_scanpos; 7250 if (jj_3R_230()) { jj_scanpos = xsp; break; } 7251 } 7252 return false; 7253 } 7254 7255 final private boolean jj_3R_192() { 7256 if (jj_3R_196()) return true; 7257 Token xsp; 7258 while (true) { 7259 xsp = jj_scanpos; 7260 if (jj_3R_212()) { jj_scanpos = xsp; break; } 7261 } 7262 return false; 7263 } 7264 7265 final private boolean jj_3R_191() { 7266 if (jj_scan_token(BIT_AND)) return true; 7267 if (jj_3R_179()) return true; 7268 return false; 7269 } 7270 7271 final private boolean jj_3R_188() { 7272 if (jj_3R_192()) return true; 7273 Token xsp; 7274 while (true) { 7275 xsp = jj_scanpos; 7276 if (jj_3R_205()) { jj_scanpos = xsp; break; } 7277 } 7278 return false; 7279 } 7280 7281 final private boolean jj_3R_183() { 7282 if (jj_scan_token(BIT_OR)) return true; 7283 if (jj_3R_162()) return true; 7284 return false; 7285 } 7286 7287 final private boolean jj_3R_184() { 7288 if (jj_3R_188()) return true; 7289 Token xsp; 7290 xsp = jj_scanpos; 7291 if (jj_3R_198()) jj_scanpos = xsp; 7292 return false; 7293 } 7294 7295 final private boolean jj_3R_187() { 7296 if (jj_scan_token(XOR)) return true; 7297 if (jj_3R_177()) return true; 7298 return false; 7299 } 7300 7301 final private boolean jj_3R_178() { 7302 if (jj_scan_token(SC_AND)) return true; 7303 if (jj_3R_155()) return true; 7304 return false; 7305 } 7306 7307 final private boolean jj_3R_179() { 7308 if (jj_3R_184()) return true; 7309 Token xsp; 7310 while (true) { 7311 xsp = jj_scanpos; 7312 if (jj_3R_195()) { jj_scanpos = xsp; break; } 7313 } 7314 return false; 7315 } 7316 7317 final private boolean jj_3R_164() { 7318 if (jj_scan_token(SC_OR)) return true; 7319 if (jj_3R_144()) return true; 7320 return false; 7321 } 7322 7323 final private boolean jj_3R_177() { 7324 if (jj_3R_179()) return true; 7325 Token xsp; 7326 while (true) { 7327 xsp = jj_scanpos; 7328 if (jj_3R_191()) { jj_scanpos = xsp; break; } 7329 } 7330 return false; 7331 } 7332 7333 final private boolean jj_3R_160() { 7334 if (jj_scan_token(HOOK)) return true; 7335 if (jj_3R_61()) return true; 7336 if (jj_scan_token(COLON)) return true; 7337 if (jj_3R_94()) return true; 7338 return false; 7339 } 7340 7341 final private boolean jj_3R_162() { 7342 if (jj_3R_177()) return true; 7343 Token xsp; 7344 while (true) { 7345 xsp = jj_scanpos; 7346 if (jj_3R_187()) { jj_scanpos = xsp; break; } 7347 } 7348 return false; 7349 } 7350 7351 final private boolean jj_3R_155() { 7352 if (jj_3R_162()) return true; 7353 Token xsp; 7354 while (true) { 7355 xsp = jj_scanpos; 7356 if (jj_3R_183()) { jj_scanpos = xsp; break; } 7357 } 7358 return false; 7359 } 7360 7361 final private boolean jj_3R_144() { 7362 if (jj_3R_155()) return true; 7363 Token xsp; 7364 while (true) { 7365 xsp = jj_scanpos; 7366 if (jj_3R_178()) { jj_scanpos = xsp; break; } 7367 } 7368 return false; 7369 } 7370 7371 public JavaParserTokenManager token_source; 7372 JavaCharStream jj_input_stream; 7373 public Token token, jj_nt; 7374 private int jj_ntk; 7375 private Token jj_scanpos, jj_lastpos; 7376 private int jj_la; 7377 public boolean lookingAhead = false; 7378 private boolean jj_semLA; 7379 private int jj_gen; 7380 final private int[] jj_la1 = new int[113]; 7381 static private int[] jj_la1_0; 7382 static private int[] jj_la1_1; 7383 static private int[] jj_la1_2; 7384 static private int[] jj_la1_3; 7385 static { 7386 jj_la1_0(); 7387 jj_la1_1(); 7388 jj_la1_2(); 7389 jj_la1_3(); 7390 } 7391 private static void jj_la1_0() { 7392 jj_la1_0 = new int[] {0x0,0x0,0x10081000,0x0,0x0,0x0,0x1000,0x10001000,0x10001000,0x4000000,0x0,0x510cb000,0x10001000,0x10001000,0x5104a000,0x10001000,0x10001000,0x1000,0x1000,0x10001000,0x10001000,0x4000000,0x510cb000,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x10001000,0x10001000,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x0,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x10000000,0x80000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x20000,0x20000000,0x0,}; 7393 } 7394 private static void jj_la1_1() { 7395 jj_la1_1 = new int[] {0x800,0x8,0x40004040,0x0,0x0,0x0,0x40004040,0x40004000,0x40004000,0x0,0x4,0x591371e0,0x40027000,0x40027000,0x110370a0,0x40127100,0x40127100,0x40004000,0x40004000,0x40027000,0x40027000,0x0,0x591371e0,0x110370a0,0x11027000,0x11027000,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x40127100,0x40127100,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x7000,0x7000,0x800000,0x8a2506a0,0x20000,0x100a0,0x0,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x82240600,0x0,0x0,0x0,0x0,0x82240600,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x200,0x0,0x0,0xae7d86a2,0x0,0x40,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,}; 7396 } 7397 private static void jj_la1_2() { 7398 jj_la1_2 = new int[] {0x0,0x0,0x10000,0x0,0x0,0x40000,0x10000,0x0,0x0,0x0,0x0,0x11080,0x0,0x0,0x10080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10080,0x10080,0x0,0x0,0x20000,0x80000,0x4000,0xc014e8,0xc014e8,0x20000,0x0,0x0,0x0,0x11000,0x4000,0x20000,0x80,0x0,0x0,0x0,0x0,0x4e8,0x0,0x80,0x4000,0x0,0x80,0x20000,0x80000,0x80000,0x1000000,0x40000000,0x80000000,0x0,0x0,0x0,0x24000000,0x24000000,0x0,0x18300000,0x18300000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc004e8,0xc00000,0xc00000,0x4e8,0xc004e8,0x400,0x0,0x0,0x400,0x468,0x80,0x44400,0x68,0x0,0xc004e8,0x20000,0x1000,0x4400,0x0,0x4000,0x4000,0x114e8,0x0,0x0,0x0,0x20000,0x80000,0x80000,0x4e8,0x0,0x0,0x0,0x4e8,0xc004e8,0x4e8,0x4e8,0x20000,0x80,0x80,0xc004e8,0x0,0x0,0x2000000,}; 7399 } 7400 private static void jj_la1_3() { 7401 jj_la1_3 = new int[] {0x0,0x0,0x0,0x1000000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe000,0xffe000,0x0,0x0,0x0,0x80,0x100,0x40,0x0,0x0,0x0,0x0,0x0,0x1c00,0x1c00,0xc,0xc,0x230,0x230,0xc,0xf,0x0,0x0,0x0,0x0,0x0,0x3,0x3,0x0,0x0,0x0,0x0,0x0,0x0,0xf,0x0,0x0,0x0,0x0,0x0,0x0,0x3,0x0,0x0,0x0,0x0,0xffe003,0xffe003,0x3,0x0,0x0,0x0,0x3,0xf,0x3,0x3,0x0,0x0,0x0,0xf,0x0,0x0,0x0,}; 7402 } 7403 final private JJCalls[] jj_2_rtns = new JJCalls[34]; 7404 private boolean jj_rescan = false; 7405 private int jj_gc = 0; 7406 7407 public JavaParser(java.io.InputStream stream) { 7408 jj_input_stream = new JavaCharStream(stream, 1, 1); 7409 token_source = new JavaParserTokenManager(jj_input_stream); 7410 token = new Token(); 7411 jj_ntk = -1; 7412 jj_gen = 0; 7413 for (int i = 0; i < 113; i++) jj_la1[i] = -1; 7414 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 7415 } 7416 7417 public void ReInit(java.io.InputStream stream) { 7418 jj_input_stream.ReInit(stream, 1, 1); 7419 token_source.ReInit(jj_input_stream); 7420 token = new Token(); 7421 jj_ntk = -1; 7422 jjtree.reset(); 7423 jj_gen = 0; 7424 for (int i = 0; i < 113; i++) jj_la1[i] = -1; 7425 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 7426 } 7427 7428 public JavaParser(java.io.Reader stream) { 7429 jj_input_stream = new JavaCharStream(stream, 1, 1); 7430 token_source = new JavaParserTokenManager(jj_input_stream); 7431 token = new Token(); 7432 jj_ntk = -1; 7433 jj_gen = 0; 7434 for (int i = 0; i < 113; i++) jj_la1[i] = -1; 7435 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 7436 } 7437 7438 public void ReInit(java.io.Reader stream) { 7439 jj_input_stream.ReInit(stream, 1, 1); 7440 token_source.ReInit(jj_input_stream); 7441 token = new Token(); 7442 jj_ntk = -1; 7443 jjtree.reset(); 7444 jj_gen = 0; 7445 for (int i = 0; i < 113; i++) jj_la1[i] = -1; 7446 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 7447 } 7448 7449 public JavaParser(JavaParserTokenManager tm) { 7450 token_source = tm; 7451 token = new Token(); 7452 jj_ntk = -1; 7453 jj_gen = 0; 7454 for (int i = 0; i < 113; i++) jj_la1[i] = -1; 7455 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 7456 } 7457 7458 public void ReInit(JavaParserTokenManager tm) { 7459 token_source = tm; 7460 token = new Token(); 7461 jj_ntk = -1; 7462 jjtree.reset(); 7463 jj_gen = 0; 7464 for (int i = 0; i < 113; i++) jj_la1[i] = -1; 7465 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls(); 7466 } 7467 7468 final private Token jj_consume_token(int kind) throws ParseException { 7469 Token oldToken; 7470 if ((oldToken = token).next != null) token = token.next; 7471 else token = token.next = token_source.getNextToken(); 7472 jj_ntk = -1; 7473 if (token.kind == kind) { 7474 jj_gen++; 7475 if (++jj_gc > 100) { 7476 jj_gc = 0; 7477 for (int i = 0; i < jj_2_rtns.length; i++) { 7478 JJCalls c = jj_2_rtns[i]; 7479 while (c != null) { 7480 if (c.gen < jj_gen) c.first = null; 7481 c = c.next; 7482 } 7483 } 7484 } 7485 return token; 7486 } 7487 token = oldToken; 7488 jj_kind = kind; 7489 throw generateParseException(); 7490 } 7491 7492 static private final class LookaheadSuccess extends java.lang.Error { } 7493 final private LookaheadSuccess jj_ls = new LookaheadSuccess(); 7494 final private boolean jj_scan_token(int kind) { 7495 if (jj_scanpos == jj_lastpos) { 7496 jj_la--; 7497 if (jj_scanpos.next == null) { 7498 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken(); 7499 } else { 7500 jj_lastpos = jj_scanpos = jj_scanpos.next; 7501 } 7502 } else { 7503 jj_scanpos = jj_scanpos.next; 7504 } 7505 if (jj_rescan) { 7506 int i = 0; Token tok = token; 7507 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; } 7508 if (tok != null) jj_add_error_token(kind, i); 7509 } 7510 if (jj_scanpos.kind != kind) return true; 7511 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls; 7512 return false; 7513 } 7514 7515 final public Token getNextToken() { 7516 if (token.next != null) token = token.next; 7517 else token = token.next = token_source.getNextToken(); 7518 jj_ntk = -1; 7519 jj_gen++; 7520 return token; 7521 } 7522 7523 final public Token getToken(int index) { 7524 Token t = lookingAhead ? jj_scanpos : token; 7525 for (int i = 0; i < index; i++) { 7526 if (t.next != null) t = t.next; 7527 else t = t.next = token_source.getNextToken(); 7528 } 7529 return t; 7530 } 7531 7532 final private int jj_ntk() { 7533 if ((jj_nt=token.next) == null) 7534 return (jj_ntk = (token.next=token_source.getNextToken()).kind); 7535 else 7536 return (jj_ntk = jj_nt.kind); 7537 } 7538 7539 private java.util.Vector jj_expentries = new java.util.Vector(); 7540 private int[] jj_expentry; 7541 private int jj_kind = -1; 7542 private int[] jj_lasttokens = new int[100]; 7543 private int jj_endpos; 7544 7545 private void jj_add_error_token(int kind, int pos) { 7546 if (pos >= 100) return; 7547 if (pos == jj_endpos + 1) { 7548 jj_lasttokens[jj_endpos++] = kind; 7549 } else if (jj_endpos != 0) { 7550 jj_expentry = new int[jj_endpos]; 7551 for (int i = 0; i < jj_endpos; i++) { 7552 jj_expentry[i] = jj_lasttokens[i]; 7553 } 7554 boolean exists = false; 7555 for (java.util.Enumeration e = jj_expentries.elements(); e.hasMoreElements();) { 7556 int[] oldentry = (int[])(e.nextElement()); 7557 if (oldentry.length == jj_expentry.length) { 7558 exists = true; 7559 for (int i = 0; i < jj_expentry.length; i++) { 7560 if (oldentry[i] != jj_expentry[i]) { 7561 exists = false; 7562 break; 7563 } 7564 } 7565 if (exists) break; 7566 } 7567 } 7568 if (!exists) jj_expentries.addElement(jj_expentry); 7569 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind; 7570 } 7571 } 7572 7573 public ParseException generateParseException() { 7574 jj_expentries.removeAllElements(); 7575 boolean[] la1tokens = new boolean[122]; 7576 for (int i = 0; i < 122; i++) { 7577 la1tokens[i] = false; 7578 } 7579 if (jj_kind >= 0) { 7580 la1tokens[jj_kind] = true; 7581 jj_kind = -1; 7582 } 7583 for (int i = 0; i < 113; i++) { 7584 if (jj_la1[i] == jj_gen) { 7585 for (int j = 0; j < 32; j++) { 7586 if ((jj_la1_0[i] & (1<<j)) != 0) { 7587 la1tokens[j] = true; 7588 } 7589 if ((jj_la1_1[i] & (1<<j)) != 0) { 7590 la1tokens[32+j] = true; 7591 } 7592 if ((jj_la1_2[i] & (1<<j)) != 0) { 7593 la1tokens[64+j] = true; 7594 } 7595 if ((jj_la1_3[i] & (1<<j)) != 0) { 7596 la1tokens[96+j] = true; 7597 } 7598 } 7599 } 7600 } 7601 for (int i = 0; i < 122; i++) { 7602 if (la1tokens[i]) { 7603 jj_expentry = new int[1]; 7604 jj_expentry[0] = i; 7605 jj_expentries.addElement(jj_expentry); 7606 } 7607 } 7608 jj_endpos = 0; 7609 jj_rescan_token(); 7610 jj_add_error_token(0, 0); 7611 int[][] exptokseq = new int[jj_expentries.size()][]; 7612 for (int i = 0; i < jj_expentries.size(); i++) { 7613 exptokseq[i] = (int[])jj_expentries.elementAt(i); 7614 } 7615 return new ParseException(token, exptokseq, tokenImage); 7616 } 7617 7618 final public void enable_tracing() { 7619 } 7620 7621 final public void disable_tracing() { 7622 } 7623 7624 final private void jj_rescan_token() { 7625 jj_rescan = true; 7626 for (int i = 0; i < 34; i++) { 7627 JJCalls p = jj_2_rtns[i]; 7628 do { 7629 if (p.gen > jj_gen) { 7630 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first; 7631 switch (i) { 7632 case 0: jj_3_1(); break; 7633 case 1: jj_3_2(); break; 7634 case 2: jj_3_3(); break; 7635 case 3: jj_3_4(); break; 7636 case 4: jj_3_5(); break; 7637 case 5: jj_3_6(); break; 7638 case 6: jj_3_7(); break; 7639 case 7: jj_3_8(); break; 7640 case 8: jj_3_9(); break; 7641 case 9: jj_3_10(); break; 7642 case 10: jj_3_11(); break; 7643 case 11: jj_3_12(); break; 7644 case 12: jj_3_13(); break; 7645 case 13: jj_3_14(); break; 7646 case 14: jj_3_15(); break; 7647 case 15: jj_3_16(); break; 7648 case 16: jj_3_17(); break; 7649 case 17: jj_3_18(); break; 7650 case 18: jj_3_19(); break; 7651 case 19: jj_3_20(); break; 7652 case 20: jj_3_21(); break; 7653 case 21: jj_3_22(); break; 7654 case 22: jj_3_23(); break; 7655 case 23: jj_3_24(); break; 7656 case 24: jj_3_25(); break; 7657 case 25: jj_3_26(); break; 7658 case 26: jj_3_27(); break; 7659 case 27: jj_3_28(); break; 7660 case 28: jj_3_29(); break; 7661 case 29: jj_3_30(); break; 7662 case 30: jj_3_31(); break; 7663 case 31: jj_3_32(); break; 7664 case 32: jj_3_33(); break; 7665 case 33: jj_3_34(); break; 7666 } 7667 } 7668 p = p.next; 7669 } while (p != null); 7670 } 7671 jj_rescan = false; 7672 } 7673 7674 final private void jj_save(int index, int xla) { 7675 JJCalls p = jj_2_rtns[index]; 7676 while (p.gen > jj_gen) { 7677 if (p.next == null) { p = p.next = new JJCalls(); break; } 7678 p = p.next; 7679 } 7680 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla; 7681 } 7682 7683 static final class JJCalls { 7684 int gen; 7685 Token first; 7686 int arg; 7687 JJCalls next; 7688 } 7689 7690 }

This page was automatically generated by Maven