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