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