00001: /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
00002: package jaxx.parser;
00003:
00004: import java.io.*;
00005:
00006: /**
00007: * Grammar to parse Java version 1.5
00008: * @author Sreenivasa Viswanadha - Simplified and enhanced for 1.5
00009: */
00010: public class JavaParser/*@bgen(jjtree)*/implements
00011: JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/
00012: protected JJTJavaParserState jjtree = new JJTJavaParserState();
00013:
00014: /**
00015: * Class to hold modifiers.
00016: */
00017: static public final class ModifierSet {
00018: /* Definitions of the bits in the modifiers field. */
00019: public static final int PUBLIC = 0x0001;
00020: public static final int PROTECTED = 0x0002;
00021: public static final int PRIVATE = 0x0004;
00022: public static final int ABSTRACT = 0x0008;
00023: public static final int STATIC = 0x0010;
00024: public static final int FINAL = 0x0020;
00025: public static final int SYNCHRONIZED = 0x0040;
00026: public static final int NATIVE = 0x0080;
00027: public static final int TRANSIENT = 0x0100;
00028: public static final int VOLATILE = 0x0200;
00029: public static final int STRICTFP = 0x1000;
00030:
00031: /** A set of accessors that indicate whether the specified modifier
00032: is in the set. */
00033:
00034: public boolean isPublic(int modifiers) {
00035: return (modifiers & PUBLIC) != 0;
00036: }
00037:
00038: public boolean isProtected(int modifiers) {
00039: return (modifiers & PROTECTED) != 0;
00040: }
00041:
00042: public boolean isPrivate(int modifiers) {
00043: return (modifiers & PRIVATE) != 0;
00044: }
00045:
00046: public boolean isStatic(int modifiers) {
00047: return (modifiers & STATIC) != 0;
00048: }
00049:
00050: public boolean isAbstract(int modifiers) {
00051: return (modifiers & ABSTRACT) != 0;
00052: }
00053:
00054: public boolean isFinal(int modifiers) {
00055: return (modifiers & FINAL) != 0;
00056: }
00057:
00058: public boolean isNative(int modifiers) {
00059: return (modifiers & NATIVE) != 0;
00060: }
00061:
00062: public boolean isStrictfp(int modifiers) {
00063: return (modifiers & STRICTFP) != 0;
00064: }
00065:
00066: public boolean isSynchronized(int modifiers) {
00067: return (modifiers & SYNCHRONIZED) != 0;
00068: }
00069:
00070: public boolean isTransient(int modifiers) {
00071: return (modifiers & TRANSIENT) != 0;
00072: }
00073:
00074: public boolean isVolatile(int modifiers) {
00075: return (modifiers & VOLATILE) != 0;
00076: }
00077:
00078: /**
00079: * Removes the given modifier.
00080: */
00081: static int removeModifier(int modifiers, int mod) {
00082: return modifiers & ~mod;
00083: }
00084: }
00085:
00086: public JavaParser(String fileName) {
00087: this (System.in);
00088: try {
00089: ReInit(new FileInputStream(new File(fileName)));
00090: } catch (Exception e) {
00091: e.printStackTrace();
00092: }
00093: }
00094:
00095: void jjtreeOpenNodeScope(Node n) {
00096: ((SimpleNode) n).firstToken = getToken(1);
00097: }
00098:
00099: void jjtreeCloseNodeScope(Node n) {
00100: ((SimpleNode) n).lastToken = getToken(0);
00101: }
00102:
00103: public SimpleNode popNode() {
00104: if (jjtree.nodeArity() > 0) // number of child nodes
00105: return (SimpleNode) jjtree.popNode();
00106: else
00107: return null;
00108: }
00109:
00110: public static void main(String args[]) {
00111: JavaParser parser;
00112: if (args.length == 0) {
00113: System.out
00114: .println("Java Parser Version 1.1: Reading from standard input . . .");
00115: parser = new JavaParser(System.in);
00116: } else if (args.length == 1) {
00117: System.out
00118: .println("Java Parser Version 1.1: Reading from file "
00119: + args[0] + " . . .");
00120: try {
00121: parser = new JavaParser(new java.io.FileInputStream(
00122: args[0]));
00123: } catch (java.io.FileNotFoundException e) {
00124: System.out.println("Java Parser Version 1.1: File "
00125: + args[0] + " not found.");
00126: return;
00127: }
00128: } else {
00129: System.out
00130: .println("Java Parser Version 1.1: Usage is one of:");
00131: System.out.println(" java JavaParser < inputfile");
00132: System.out.println("OR");
00133: System.out.println(" java JavaParser inputfile");
00134: return;
00135: }
00136: try {
00137: parser.CompilationUnit();
00138: System.out
00139: .println("Java Parser Version 1.1: Java program parsed successfully.");
00140: } catch (ParseException e) {
00141: System.out.println(e.getMessage());
00142: System.out
00143: .println("Java Parser Version 1.1: Encountered errors during parse.");
00144: }
00145: }
00146:
00147: final public boolean Line() throws ParseException {
00148: /*@bgen(jjtree) Line */
00149: SimpleNode jjtn000 = new SimpleNode(JJTLINE);
00150: boolean jjtc000 = true;
00151: jjtree.openNodeScope(jjtn000);
00152: jjtreeOpenNodeScope(jjtn000);
00153: int modifiers;
00154: try {
00155: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00156: case 0:
00157: jj_consume_token(0);
00158: jjtree.closeNodeScope(jjtn000, true);
00159: jjtc000 = false;
00160: jjtreeCloseNodeScope(jjtn000);
00161: {
00162: if (true)
00163: return true;
00164: }
00165: break;
00166: default:
00167: if (jj_2_1(2147483647)) {
00168: BlockStatement();
00169: jjtree.closeNodeScope(jjtn000, true);
00170: jjtc000 = false;
00171: jjtreeCloseNodeScope(jjtn000);
00172: {
00173: if (true)
00174: return false;
00175: }
00176: } else if (jj_2_2(2147483647)) {
00177: ClassOrInterfaceBodyDeclaration(false);
00178: jjtree.closeNodeScope(jjtn000, true);
00179: jjtc000 = false;
00180: jjtreeCloseNodeScope(jjtn000);
00181: {
00182: if (true)
00183: return false;
00184: }
00185: } else if (jj_2_3(2147483647)) {
00186: ClassOrInterfaceBodyDeclaration(false);
00187: jjtree.closeNodeScope(jjtn000, true);
00188: jjtc000 = false;
00189: jjtreeCloseNodeScope(jjtn000);
00190: {
00191: if (true)
00192: return false;
00193: }
00194: } else if (jj_2_4(2147483647)) {
00195: Expression();
00196: jjtree.closeNodeScope(jjtn000, true);
00197: jjtc000 = false;
00198: jjtreeCloseNodeScope(jjtn000);
00199: {
00200: if (true)
00201: return false;
00202: }
00203: } else {
00204: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00205: case IMPORT:
00206: ImportDeclaration();
00207: jjtree.closeNodeScope(jjtn000, true);
00208: jjtc000 = false;
00209: jjtreeCloseNodeScope(jjtn000);
00210: {
00211: if (true)
00212: return false;
00213: }
00214: break;
00215: default:
00216: jj_consume_token(-1);
00217: throw new ParseException();
00218: }
00219: }
00220: }
00221: } catch (Throwable jjte000) {
00222: if (jjtc000) {
00223: jjtree.clearNodeScope(jjtn000);
00224: jjtc000 = false;
00225: } else {
00226: jjtree.popNode();
00227: }
00228: if (jjte000 instanceof RuntimeException) {
00229: {
00230: if (true)
00231: throw (RuntimeException) jjte000;
00232: }
00233: }
00234: if (jjte000 instanceof ParseException) {
00235: {
00236: if (true)
00237: throw (ParseException) jjte000;
00238: }
00239: }
00240: {
00241: if (true)
00242: throw (Error) jjte000;
00243: }
00244: } finally {
00245: if (jjtc000) {
00246: jjtree.closeNodeScope(jjtn000, true);
00247: jjtreeCloseNodeScope(jjtn000);
00248: }
00249: }
00250: throw new Error("Missing return statement in function");
00251: }
00252:
00253: /*****************************************
00254: * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
00255: *****************************************/
00256:
00257: /*
00258: * Program structuring syntax follows.
00259: */
00260: final public void CompilationUnit() throws ParseException {
00261: /*@bgen(jjtree) CompilationUnit */
00262: SimpleNode jjtn000 = new SimpleNode(JJTCOMPILATIONUNIT);
00263: boolean jjtc000 = true;
00264: jjtree.openNodeScope(jjtn000);
00265: jjtreeOpenNodeScope(jjtn000);
00266: try {
00267: if (jj_2_5(2147483647)) {
00268: PackageDeclaration();
00269: } else {
00270: ;
00271: }
00272: label_1: while (true) {
00273: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00274: case IMPORT:
00275: ;
00276: break;
00277: default:
00278: break label_1;
00279: }
00280: ImportDeclaration();
00281: }
00282: label_2: while (true) {
00283: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00284: case ABSTRACT:
00285: case CLASS:
00286: case ENUM:
00287: case FINAL:
00288: case INTERFACE:
00289: case NATIVE:
00290: case PRIVATE:
00291: case PROTECTED:
00292: case PUBLIC:
00293: case STATIC:
00294: case STRICTFP:
00295: case SYNCHRONIZED:
00296: case TRANSIENT:
00297: case VOLATILE:
00298: case SEMICOLON:
00299: case AT:
00300: ;
00301: break;
00302: default:
00303: break label_2;
00304: }
00305: TypeDeclaration();
00306: }
00307: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00308: case 123:
00309: jj_consume_token(123);
00310: break;
00311: default:
00312: ;
00313: }
00314: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00315: case STUFF_TO_IGNORE:
00316: jj_consume_token(STUFF_TO_IGNORE);
00317: break;
00318: default:
00319: ;
00320: }
00321: jj_consume_token(0);
00322: } catch (Throwable jjte000) {
00323: if (jjtc000) {
00324: jjtree.clearNodeScope(jjtn000);
00325: jjtc000 = false;
00326: } else {
00327: jjtree.popNode();
00328: }
00329: if (jjte000 instanceof RuntimeException) {
00330: {
00331: if (true)
00332: throw (RuntimeException) jjte000;
00333: }
00334: }
00335: if (jjte000 instanceof ParseException) {
00336: {
00337: if (true)
00338: throw (ParseException) jjte000;
00339: }
00340: }
00341: {
00342: if (true)
00343: throw (Error) jjte000;
00344: }
00345: } finally {
00346: if (jjtc000) {
00347: jjtree.closeNodeScope(jjtn000, true);
00348: jjtreeCloseNodeScope(jjtn000);
00349: }
00350: }
00351: }
00352:
00353: final public void PackageDeclaration() throws ParseException {
00354: /*@bgen(jjtree) PackageDeclaration */
00355: SimpleNode jjtn000 = new SimpleNode(JJTPACKAGEDECLARATION);
00356: boolean jjtc000 = true;
00357: jjtree.openNodeScope(jjtn000);
00358: jjtreeOpenNodeScope(jjtn000);
00359: try {
00360: Modifiers();
00361: jj_consume_token(PACKAGE);
00362: Name();
00363: jj_consume_token(SEMICOLON);
00364: } catch (Throwable jjte000) {
00365: if (jjtc000) {
00366: jjtree.clearNodeScope(jjtn000);
00367: jjtc000 = false;
00368: } else {
00369: jjtree.popNode();
00370: }
00371: if (jjte000 instanceof RuntimeException) {
00372: {
00373: if (true)
00374: throw (RuntimeException) jjte000;
00375: }
00376: }
00377: if (jjte000 instanceof ParseException) {
00378: {
00379: if (true)
00380: throw (ParseException) jjte000;
00381: }
00382: }
00383: {
00384: if (true)
00385: throw (Error) jjte000;
00386: }
00387: } finally {
00388: if (jjtc000) {
00389: jjtree.closeNodeScope(jjtn000, true);
00390: jjtreeCloseNodeScope(jjtn000);
00391: }
00392: }
00393: }
00394:
00395: final public void ImportDeclaration() throws ParseException {
00396: /*@bgen(jjtree) ImportDeclaration */
00397: SimpleNode jjtn000 = new SimpleNode(JJTIMPORTDECLARATION);
00398: boolean jjtc000 = true;
00399: jjtree.openNodeScope(jjtn000);
00400: jjtreeOpenNodeScope(jjtn000);
00401: try {
00402: jj_consume_token(IMPORT);
00403: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00404: case STATIC:
00405: jj_consume_token(STATIC);
00406: break;
00407: default:
00408: ;
00409: }
00410: Name();
00411: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00412: case DOT:
00413: jj_consume_token(DOT);
00414: jj_consume_token(STAR);
00415: break;
00416: default:
00417: ;
00418: }
00419: jj_consume_token(SEMICOLON);
00420: } catch (Throwable jjte000) {
00421: if (jjtc000) {
00422: jjtree.clearNodeScope(jjtn000);
00423: jjtc000 = false;
00424: } else {
00425: jjtree.popNode();
00426: }
00427: if (jjte000 instanceof RuntimeException) {
00428: {
00429: if (true)
00430: throw (RuntimeException) jjte000;
00431: }
00432: }
00433: if (jjte000 instanceof ParseException) {
00434: {
00435: if (true)
00436: throw (ParseException) jjte000;
00437: }
00438: }
00439: {
00440: if (true)
00441: throw (Error) jjte000;
00442: }
00443: } finally {
00444: if (jjtc000) {
00445: jjtree.closeNodeScope(jjtn000, true);
00446: jjtreeCloseNodeScope(jjtn000);
00447: }
00448: }
00449: }
00450:
00451: /*
00452: * Modifiers. We match all modifiers in a single rule to reduce the chances of
00453: * syntax errors for simple modifier mistakes. It will also enable us to give
00454: * better error messages.
00455: */
00456: final public int Modifiers() throws ParseException {
00457: /*@bgen(jjtree) Modifiers */
00458: SimpleNode jjtn000 = new SimpleNode(JJTMODIFIERS);
00459: boolean jjtc000 = true;
00460: jjtree.openNodeScope(jjtn000);
00461: jjtreeOpenNodeScope(jjtn000);
00462: int modifiers = 0;
00463: try {
00464: label_3: while (true) {
00465: if (jj_2_6(2)) {
00466: ;
00467: } else {
00468: break label_3;
00469: }
00470: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00471: case PUBLIC:
00472: jj_consume_token(PUBLIC);
00473: modifiers |= ModifierSet.PUBLIC;
00474: break;
00475: case STATIC:
00476: jj_consume_token(STATIC);
00477: modifiers |= ModifierSet.STATIC;
00478: break;
00479: case PROTECTED:
00480: jj_consume_token(PROTECTED);
00481: modifiers |= ModifierSet.PROTECTED;
00482: break;
00483: case PRIVATE:
00484: jj_consume_token(PRIVATE);
00485: modifiers |= ModifierSet.PRIVATE;
00486: break;
00487: case FINAL:
00488: jj_consume_token(FINAL);
00489: modifiers |= ModifierSet.FINAL;
00490: break;
00491: case ABSTRACT:
00492: jj_consume_token(ABSTRACT);
00493: modifiers |= ModifierSet.ABSTRACT;
00494: break;
00495: case SYNCHRONIZED:
00496: jj_consume_token(SYNCHRONIZED);
00497: modifiers |= ModifierSet.SYNCHRONIZED;
00498: break;
00499: case NATIVE:
00500: jj_consume_token(NATIVE);
00501: modifiers |= ModifierSet.NATIVE;
00502: break;
00503: case TRANSIENT:
00504: jj_consume_token(TRANSIENT);
00505: modifiers |= ModifierSet.TRANSIENT;
00506: break;
00507: case VOLATILE:
00508: jj_consume_token(VOLATILE);
00509: modifiers |= ModifierSet.VOLATILE;
00510: break;
00511: case STRICTFP:
00512: jj_consume_token(STRICTFP);
00513: modifiers |= ModifierSet.STRICTFP;
00514: break;
00515: case AT:
00516: Annotation();
00517: break;
00518: default:
00519: jj_consume_token(-1);
00520: throw new ParseException();
00521: }
00522: }
00523: jjtree.closeNodeScope(jjtn000, true);
00524: jjtc000 = false;
00525: jjtreeCloseNodeScope(jjtn000);
00526: {
00527: if (true)
00528: return modifiers;
00529: }
00530: } catch (Throwable jjte000) {
00531: if (jjtc000) {
00532: jjtree.clearNodeScope(jjtn000);
00533: jjtc000 = false;
00534: } else {
00535: jjtree.popNode();
00536: }
00537: if (jjte000 instanceof RuntimeException) {
00538: {
00539: if (true)
00540: throw (RuntimeException) jjte000;
00541: }
00542: }
00543: if (jjte000 instanceof ParseException) {
00544: {
00545: if (true)
00546: throw (ParseException) jjte000;
00547: }
00548: }
00549: {
00550: if (true)
00551: throw (Error) jjte000;
00552: }
00553: } finally {
00554: if (jjtc000) {
00555: jjtree.closeNodeScope(jjtn000, true);
00556: jjtreeCloseNodeScope(jjtn000);
00557: }
00558: }
00559: throw new Error("Missing return statement in function");
00560: }
00561:
00562: /*
00563: * Declaration syntax follows.
00564: */
00565: final public void TypeDeclaration() throws ParseException {
00566: /*@bgen(jjtree) TypeDeclaration */
00567: SimpleNode jjtn000 = new SimpleNode(JJTTYPEDECLARATION);
00568: boolean jjtc000 = true;
00569: jjtree.openNodeScope(jjtn000);
00570: jjtreeOpenNodeScope(jjtn000);
00571: int modifiers;
00572: try {
00573: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00574: case SEMICOLON:
00575: jj_consume_token(SEMICOLON);
00576: break;
00577: case ABSTRACT:
00578: case CLASS:
00579: case ENUM:
00580: case FINAL:
00581: case INTERFACE:
00582: case NATIVE:
00583: case PRIVATE:
00584: case PROTECTED:
00585: case PUBLIC:
00586: case STATIC:
00587: case STRICTFP:
00588: case SYNCHRONIZED:
00589: case TRANSIENT:
00590: case VOLATILE:
00591: case AT:
00592: modifiers = Modifiers();
00593: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00594: case CLASS:
00595: case INTERFACE:
00596: ClassOrInterfaceDeclaration(modifiers);
00597: break;
00598: case ENUM:
00599: EnumDeclaration(modifiers);
00600: break;
00601: case AT:
00602: AnnotationTypeDeclaration(modifiers);
00603: break;
00604: default:
00605: jj_consume_token(-1);
00606: throw new ParseException();
00607: }
00608: break;
00609: default:
00610: jj_consume_token(-1);
00611: throw new ParseException();
00612: }
00613: } catch (Throwable jjte000) {
00614: if (jjtc000) {
00615: jjtree.clearNodeScope(jjtn000);
00616: jjtc000 = false;
00617: } else {
00618: jjtree.popNode();
00619: }
00620: if (jjte000 instanceof RuntimeException) {
00621: {
00622: if (true)
00623: throw (RuntimeException) jjte000;
00624: }
00625: }
00626: if (jjte000 instanceof ParseException) {
00627: {
00628: if (true)
00629: throw (ParseException) jjte000;
00630: }
00631: }
00632: {
00633: if (true)
00634: throw (Error) jjte000;
00635: }
00636: } finally {
00637: if (jjtc000) {
00638: jjtree.closeNodeScope(jjtn000, true);
00639: jjtreeCloseNodeScope(jjtn000);
00640: }
00641: }
00642: }
00643:
00644: final public void ClassOrInterfaceDeclaration(int modifiers)
00645: throws ParseException {
00646: /*@bgen(jjtree) ClassOrInterfaceDeclaration */
00647: SimpleNode jjtn000 = new SimpleNode(
00648: JJTCLASSORINTERFACEDECLARATION);
00649: boolean jjtc000 = true;
00650: jjtree.openNodeScope(jjtn000);
00651: jjtreeOpenNodeScope(jjtn000);
00652: boolean isInterface = false;
00653: try {
00654: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00655: case CLASS:
00656: jj_consume_token(CLASS);
00657: break;
00658: case INTERFACE:
00659: jj_consume_token(INTERFACE);
00660: isInterface = true;
00661: break;
00662: default:
00663: jj_consume_token(-1);
00664: throw new ParseException();
00665: }
00666: jj_consume_token(IDENTIFIER);
00667: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00668: case LT:
00669: TypeParameters();
00670: break;
00671: default:
00672: ;
00673: }
00674: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00675: case EXTENDS:
00676: ExtendsList(isInterface);
00677: break;
00678: default:
00679: ;
00680: }
00681: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00682: case IMPLEMENTS:
00683: ImplementsList(isInterface);
00684: break;
00685: default:
00686: ;
00687: }
00688: ClassOrInterfaceBody(isInterface);
00689: } catch (Throwable jjte000) {
00690: if (jjtc000) {
00691: jjtree.clearNodeScope(jjtn000);
00692: jjtc000 = false;
00693: } else {
00694: jjtree.popNode();
00695: }
00696: if (jjte000 instanceof RuntimeException) {
00697: {
00698: if (true)
00699: throw (RuntimeException) jjte000;
00700: }
00701: }
00702: if (jjte000 instanceof ParseException) {
00703: {
00704: if (true)
00705: throw (ParseException) jjte000;
00706: }
00707: }
00708: {
00709: if (true)
00710: throw (Error) jjte000;
00711: }
00712: } finally {
00713: if (jjtc000) {
00714: jjtree.closeNodeScope(jjtn000, true);
00715: jjtreeCloseNodeScope(jjtn000);
00716: }
00717: }
00718: }
00719:
00720: final public void ExtendsList(boolean isInterface)
00721: throws ParseException {
00722: /*@bgen(jjtree) ExtendsList */
00723: SimpleNode jjtn000 = new SimpleNode(JJTEXTENDSLIST);
00724: boolean jjtc000 = true;
00725: jjtree.openNodeScope(jjtn000);
00726: jjtreeOpenNodeScope(jjtn000);
00727: boolean extendsMoreThanOne = false;
00728: try {
00729: jj_consume_token(EXTENDS);
00730: ClassOrInterfaceType();
00731: label_4: while (true) {
00732: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00733: case COMMA:
00734: ;
00735: break;
00736: default:
00737: break label_4;
00738: }
00739: jj_consume_token(COMMA);
00740: ClassOrInterfaceType();
00741: extendsMoreThanOne = true;
00742: }
00743: jjtree.closeNodeScope(jjtn000, true);
00744: jjtc000 = false;
00745: jjtreeCloseNodeScope(jjtn000);
00746: if (extendsMoreThanOne && !isInterface) {
00747: if (true)
00748: throw new ParseException(
00749: "A class cannot extend more than one other class");
00750: }
00751: } catch (Throwable jjte000) {
00752: if (jjtc000) {
00753: jjtree.clearNodeScope(jjtn000);
00754: jjtc000 = false;
00755: } else {
00756: jjtree.popNode();
00757: }
00758: if (jjte000 instanceof RuntimeException) {
00759: {
00760: if (true)
00761: throw (RuntimeException) jjte000;
00762: }
00763: }
00764: if (jjte000 instanceof ParseException) {
00765: {
00766: if (true)
00767: throw (ParseException) jjte000;
00768: }
00769: }
00770: {
00771: if (true)
00772: throw (Error) jjte000;
00773: }
00774: } finally {
00775: if (jjtc000) {
00776: jjtree.closeNodeScope(jjtn000, true);
00777: jjtreeCloseNodeScope(jjtn000);
00778: }
00779: }
00780: }
00781:
00782: final public void ImplementsList(boolean isInterface)
00783: throws ParseException {
00784: /*@bgen(jjtree) ImplementsList */
00785: SimpleNode jjtn000 = new SimpleNode(JJTIMPLEMENTSLIST);
00786: boolean jjtc000 = true;
00787: jjtree.openNodeScope(jjtn000);
00788: jjtreeOpenNodeScope(jjtn000);
00789: try {
00790: jj_consume_token(IMPLEMENTS);
00791: ClassOrInterfaceType();
00792: label_5: while (true) {
00793: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00794: case COMMA:
00795: ;
00796: break;
00797: default:
00798: break label_5;
00799: }
00800: jj_consume_token(COMMA);
00801: ClassOrInterfaceType();
00802: }
00803: jjtree.closeNodeScope(jjtn000, true);
00804: jjtc000 = false;
00805: jjtreeCloseNodeScope(jjtn000);
00806: if (isInterface) {
00807: if (true)
00808: throw new ParseException(
00809: "An interface cannot implement other interfaces");
00810: }
00811: } catch (Throwable jjte000) {
00812: if (jjtc000) {
00813: jjtree.clearNodeScope(jjtn000);
00814: jjtc000 = false;
00815: } else {
00816: jjtree.popNode();
00817: }
00818: if (jjte000 instanceof RuntimeException) {
00819: {
00820: if (true)
00821: throw (RuntimeException) jjte000;
00822: }
00823: }
00824: if (jjte000 instanceof ParseException) {
00825: {
00826: if (true)
00827: throw (ParseException) jjte000;
00828: }
00829: }
00830: {
00831: if (true)
00832: throw (Error) jjte000;
00833: }
00834: } finally {
00835: if (jjtc000) {
00836: jjtree.closeNodeScope(jjtn000, true);
00837: jjtreeCloseNodeScope(jjtn000);
00838: }
00839: }
00840: }
00841:
00842: final public void EnumDeclaration(int modifiers)
00843: throws ParseException {
00844: /*@bgen(jjtree) EnumDeclaration */
00845: SimpleNode jjtn000 = new SimpleNode(JJTENUMDECLARATION);
00846: boolean jjtc000 = true;
00847: jjtree.openNodeScope(jjtn000);
00848: jjtreeOpenNodeScope(jjtn000);
00849: try {
00850: jj_consume_token(ENUM);
00851: jj_consume_token(IDENTIFIER);
00852: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00853: case IMPLEMENTS:
00854: ImplementsList(false);
00855: break;
00856: default:
00857: ;
00858: }
00859: EnumBody();
00860: } catch (Throwable jjte000) {
00861: if (jjtc000) {
00862: jjtree.clearNodeScope(jjtn000);
00863: jjtc000 = false;
00864: } else {
00865: jjtree.popNode();
00866: }
00867: if (jjte000 instanceof RuntimeException) {
00868: {
00869: if (true)
00870: throw (RuntimeException) jjte000;
00871: }
00872: }
00873: if (jjte000 instanceof ParseException) {
00874: {
00875: if (true)
00876: throw (ParseException) jjte000;
00877: }
00878: }
00879: {
00880: if (true)
00881: throw (Error) jjte000;
00882: }
00883: } finally {
00884: if (jjtc000) {
00885: jjtree.closeNodeScope(jjtn000, true);
00886: jjtreeCloseNodeScope(jjtn000);
00887: }
00888: }
00889: }
00890:
00891: final public void EnumBody() throws ParseException {
00892: /*@bgen(jjtree) EnumBody */
00893: SimpleNode jjtn000 = new SimpleNode(JJTENUMBODY);
00894: boolean jjtc000 = true;
00895: jjtree.openNodeScope(jjtn000);
00896: jjtreeOpenNodeScope(jjtn000);
00897: try {
00898: jj_consume_token(LBRACE);
00899: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00900: case ABSTRACT:
00901: case FINAL:
00902: case NATIVE:
00903: case PRIVATE:
00904: case PROTECTED:
00905: case PUBLIC:
00906: case STATIC:
00907: case STRICTFP:
00908: case SYNCHRONIZED:
00909: case TRANSIENT:
00910: case VOLATILE:
00911: case IDENTIFIER:
00912: case AT:
00913: EnumConstant();
00914: label_6: while (true) {
00915: if (jj_2_7(2)) {
00916: ;
00917: } else {
00918: break label_6;
00919: }
00920: jj_consume_token(COMMA);
00921: EnumConstant();
00922: }
00923: break;
00924: default:
00925: ;
00926: }
00927: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00928: case COMMA:
00929: jj_consume_token(COMMA);
00930: break;
00931: default:
00932: ;
00933: }
00934: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00935: case SEMICOLON:
00936: jj_consume_token(SEMICOLON);
00937: label_7: while (true) {
00938: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
00939: case ABSTRACT:
00940: case BOOLEAN:
00941: case BYTE:
00942: case CHAR:
00943: case CLASS:
00944: case DOUBLE:
00945: case ENUM:
00946: case FINAL:
00947: case FLOAT:
00948: case INT:
00949: case INTERFACE:
00950: case LONG:
00951: case NATIVE:
00952: case PRIVATE:
00953: case PROTECTED:
00954: case PUBLIC:
00955: case SHORT:
00956: case STATIC:
00957: case STRICTFP:
00958: case SYNCHRONIZED:
00959: case TRANSIENT:
00960: case VOID:
00961: case VOLATILE:
00962: case IDENTIFIER:
00963: case LBRACE:
00964: case SEMICOLON:
00965: case AT:
00966: case LT:
00967: ;
00968: break;
00969: default:
00970: break label_7;
00971: }
00972: ClassOrInterfaceBodyDeclaration(false);
00973: }
00974: break;
00975: default:
00976: ;
00977: }
00978: jj_consume_token(RBRACE);
00979: } catch (Throwable jjte000) {
00980: if (jjtc000) {
00981: jjtree.clearNodeScope(jjtn000);
00982: jjtc000 = false;
00983: } else {
00984: jjtree.popNode();
00985: }
00986: if (jjte000 instanceof RuntimeException) {
00987: {
00988: if (true)
00989: throw (RuntimeException) jjte000;
00990: }
00991: }
00992: if (jjte000 instanceof ParseException) {
00993: {
00994: if (true)
00995: throw (ParseException) jjte000;
00996: }
00997: }
00998: {
00999: if (true)
01000: throw (Error) jjte000;
01001: }
01002: } finally {
01003: if (jjtc000) {
01004: jjtree.closeNodeScope(jjtn000, true);
01005: jjtreeCloseNodeScope(jjtn000);
01006: }
01007: }
01008: }
01009:
01010: final public void EnumConstant() throws ParseException {
01011: /*@bgen(jjtree) EnumConstant */
01012: SimpleNode jjtn000 = new SimpleNode(JJTENUMCONSTANT);
01013: boolean jjtc000 = true;
01014: jjtree.openNodeScope(jjtn000);
01015: jjtreeOpenNodeScope(jjtn000);
01016: try {
01017: Modifiers();
01018: jj_consume_token(IDENTIFIER);
01019: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01020: case LPAREN:
01021: Arguments();
01022: break;
01023: default:
01024: ;
01025: }
01026: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01027: case LBRACE:
01028: ClassOrInterfaceBody(false);
01029: break;
01030: default:
01031: ;
01032: }
01033: } catch (Throwable jjte000) {
01034: if (jjtc000) {
01035: jjtree.clearNodeScope(jjtn000);
01036: jjtc000 = false;
01037: } else {
01038: jjtree.popNode();
01039: }
01040: if (jjte000 instanceof RuntimeException) {
01041: {
01042: if (true)
01043: throw (RuntimeException) jjte000;
01044: }
01045: }
01046: if (jjte000 instanceof ParseException) {
01047: {
01048: if (true)
01049: throw (ParseException) jjte000;
01050: }
01051: }
01052: {
01053: if (true)
01054: throw (Error) jjte000;
01055: }
01056: } finally {
01057: if (jjtc000) {
01058: jjtree.closeNodeScope(jjtn000, true);
01059: jjtreeCloseNodeScope(jjtn000);
01060: }
01061: }
01062: }
01063:
01064: final public void TypeParameters() throws ParseException {
01065: /*@bgen(jjtree) TypeParameters */
01066: SimpleNode jjtn000 = new SimpleNode(JJTTYPEPARAMETERS);
01067: boolean jjtc000 = true;
01068: jjtree.openNodeScope(jjtn000);
01069: jjtreeOpenNodeScope(jjtn000);
01070: try {
01071: jj_consume_token(LT);
01072: TypeParameter();
01073: label_8: while (true) {
01074: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01075: case COMMA:
01076: ;
01077: break;
01078: default:
01079: break label_8;
01080: }
01081: jj_consume_token(COMMA);
01082: TypeParameter();
01083: }
01084: jj_consume_token(GT);
01085: } catch (Throwable jjte000) {
01086: if (jjtc000) {
01087: jjtree.clearNodeScope(jjtn000);
01088: jjtc000 = false;
01089: } else {
01090: jjtree.popNode();
01091: }
01092: if (jjte000 instanceof RuntimeException) {
01093: {
01094: if (true)
01095: throw (RuntimeException) jjte000;
01096: }
01097: }
01098: if (jjte000 instanceof ParseException) {
01099: {
01100: if (true)
01101: throw (ParseException) jjte000;
01102: }
01103: }
01104: {
01105: if (true)
01106: throw (Error) jjte000;
01107: }
01108: } finally {
01109: if (jjtc000) {
01110: jjtree.closeNodeScope(jjtn000, true);
01111: jjtreeCloseNodeScope(jjtn000);
01112: }
01113: }
01114: }
01115:
01116: final public void TypeParameter() throws ParseException {
01117: /*@bgen(jjtree) TypeParameter */
01118: SimpleNode jjtn000 = new SimpleNode(JJTTYPEPARAMETER);
01119: boolean jjtc000 = true;
01120: jjtree.openNodeScope(jjtn000);
01121: jjtreeOpenNodeScope(jjtn000);
01122: try {
01123: jj_consume_token(IDENTIFIER);
01124: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01125: case EXTENDS:
01126: TypeBound();
01127: break;
01128: default:
01129: ;
01130: }
01131: } catch (Throwable jjte000) {
01132: if (jjtc000) {
01133: jjtree.clearNodeScope(jjtn000);
01134: jjtc000 = false;
01135: } else {
01136: jjtree.popNode();
01137: }
01138: if (jjte000 instanceof RuntimeException) {
01139: {
01140: if (true)
01141: throw (RuntimeException) jjte000;
01142: }
01143: }
01144: if (jjte000 instanceof ParseException) {
01145: {
01146: if (true)
01147: throw (ParseException) jjte000;
01148: }
01149: }
01150: {
01151: if (true)
01152: throw (Error) jjte000;
01153: }
01154: } finally {
01155: if (jjtc000) {
01156: jjtree.closeNodeScope(jjtn000, true);
01157: jjtreeCloseNodeScope(jjtn000);
01158: }
01159: }
01160: }
01161:
01162: final public void TypeBound() throws ParseException {
01163: /*@bgen(jjtree) TypeBound */
01164: SimpleNode jjtn000 = new SimpleNode(JJTTYPEBOUND);
01165: boolean jjtc000 = true;
01166: jjtree.openNodeScope(jjtn000);
01167: jjtreeOpenNodeScope(jjtn000);
01168: try {
01169: jj_consume_token(EXTENDS);
01170: ClassOrInterfaceType();
01171: label_9: while (true) {
01172: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01173: case BIT_AND:
01174: ;
01175: break;
01176: default:
01177: break label_9;
01178: }
01179: jj_consume_token(BIT_AND);
01180: ClassOrInterfaceType();
01181: }
01182: } catch (Throwable jjte000) {
01183: if (jjtc000) {
01184: jjtree.clearNodeScope(jjtn000);
01185: jjtc000 = false;
01186: } else {
01187: jjtree.popNode();
01188: }
01189: if (jjte000 instanceof RuntimeException) {
01190: {
01191: if (true)
01192: throw (RuntimeException) jjte000;
01193: }
01194: }
01195: if (jjte000 instanceof ParseException) {
01196: {
01197: if (true)
01198: throw (ParseException) jjte000;
01199: }
01200: }
01201: {
01202: if (true)
01203: throw (Error) jjte000;
01204: }
01205: } finally {
01206: if (jjtc000) {
01207: jjtree.closeNodeScope(jjtn000, true);
01208: jjtreeCloseNodeScope(jjtn000);
01209: }
01210: }
01211: }
01212:
01213: final public void ClassOrInterfaceBody(boolean isInterface)
01214: throws ParseException {
01215: /*@bgen(jjtree) ClassOrInterfaceBody */
01216: SimpleNode jjtn000 = new SimpleNode(JJTCLASSORINTERFACEBODY);
01217: boolean jjtc000 = true;
01218: jjtree.openNodeScope(jjtn000);
01219: jjtreeOpenNodeScope(jjtn000);
01220: try {
01221: jj_consume_token(LBRACE);
01222: label_10: while (true) {
01223: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01224: case ABSTRACT:
01225: case BOOLEAN:
01226: case BYTE:
01227: case CHAR:
01228: case CLASS:
01229: case DOUBLE:
01230: case ENUM:
01231: case FINAL:
01232: case FLOAT:
01233: case INT:
01234: case INTERFACE:
01235: case LONG:
01236: case NATIVE:
01237: case PRIVATE:
01238: case PROTECTED:
01239: case PUBLIC:
01240: case SHORT:
01241: case STATIC:
01242: case STRICTFP:
01243: case SYNCHRONIZED:
01244: case TRANSIENT:
01245: case VOID:
01246: case VOLATILE:
01247: case IDENTIFIER:
01248: case LBRACE:
01249: case SEMICOLON:
01250: case AT:
01251: case LT:
01252: ;
01253: break;
01254: default:
01255: break label_10;
01256: }
01257: ClassOrInterfaceBodyDeclaration(isInterface);
01258: }
01259: jj_consume_token(RBRACE);
01260: } catch (Throwable jjte000) {
01261: if (jjtc000) {
01262: jjtree.clearNodeScope(jjtn000);
01263: jjtc000 = false;
01264: } else {
01265: jjtree.popNode();
01266: }
01267: if (jjte000 instanceof RuntimeException) {
01268: {
01269: if (true)
01270: throw (RuntimeException) jjte000;
01271: }
01272: }
01273: if (jjte000 instanceof ParseException) {
01274: {
01275: if (true)
01276: throw (ParseException) jjte000;
01277: }
01278: }
01279: {
01280: if (true)
01281: throw (Error) jjte000;
01282: }
01283: } finally {
01284: if (jjtc000) {
01285: jjtree.closeNodeScope(jjtn000, true);
01286: jjtreeCloseNodeScope(jjtn000);
01287: }
01288: }
01289: }
01290:
01291: final public void ClassOrInterfaceBodyDeclaration(
01292: boolean isInterface) throws ParseException {
01293: /*@bgen(jjtree) ClassOrInterfaceBodyDeclaration */
01294: SimpleNode jjtn000 = new SimpleNode(
01295: JJTCLASSORINTERFACEBODYDECLARATION);
01296: boolean jjtc000 = true;
01297: jjtree.openNodeScope(jjtn000);
01298: jjtreeOpenNodeScope(jjtn000);
01299: boolean isNestedInterface = false;
01300: int modifiers;
01301: try {
01302: if (jj_2_10(2)) {
01303: Initializer();
01304: jjtree.closeNodeScope(jjtn000, true);
01305: jjtc000 = false;
01306: jjtreeCloseNodeScope(jjtn000);
01307: if (isInterface) {
01308: if (true)
01309: throw new ParseException(
01310: "An interface cannot have initializers");
01311: }
01312: } else {
01313: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01314: case ABSTRACT:
01315: case BOOLEAN:
01316: case BYTE:
01317: case CHAR:
01318: case CLASS:
01319: case DOUBLE:
01320: case ENUM:
01321: case FINAL:
01322: case FLOAT:
01323: case INT:
01324: case INTERFACE:
01325: case LONG:
01326: case NATIVE:
01327: case PRIVATE:
01328: case PROTECTED:
01329: case PUBLIC:
01330: case SHORT:
01331: case STATIC:
01332: case STRICTFP:
01333: case SYNCHRONIZED:
01334: case TRANSIENT:
01335: case VOID:
01336: case VOLATILE:
01337: case IDENTIFIER:
01338: case AT:
01339: case LT:
01340: modifiers = Modifiers();
01341: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01342: case CLASS:
01343: case INTERFACE:
01344: ClassOrInterfaceDeclaration(modifiers);
01345: break;
01346: case ENUM:
01347: EnumDeclaration(modifiers);
01348: break;
01349: default:
01350: if (jj_2_8(2147483647)) {
01351: ConstructorDeclaration();
01352: } else if (jj_2_9(2147483647)) {
01353: FieldDeclaration(modifiers);
01354: } else {
01355: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01356: case BOOLEAN:
01357: case BYTE:
01358: case CHAR:
01359: case DOUBLE:
01360: case FLOAT:
01361: case INT:
01362: case LONG:
01363: case SHORT:
01364: case VOID:
01365: case IDENTIFIER:
01366: case LT:
01367: MethodDeclaration(modifiers);
01368: break;
01369: default:
01370: jj_consume_token(-1);
01371: throw new ParseException();
01372: }
01373: }
01374: }
01375: break;
01376: case SEMICOLON:
01377: jj_consume_token(SEMICOLON);
01378: break;
01379: default:
01380: jj_consume_token(-1);
01381: throw new ParseException();
01382: }
01383: }
01384: } catch (Throwable jjte000) {
01385: if (jjtc000) {
01386: jjtree.clearNodeScope(jjtn000);
01387: jjtc000 = false;
01388: } else {
01389: jjtree.popNode();
01390: }
01391: if (jjte000 instanceof RuntimeException) {
01392: {
01393: if (true)
01394: throw (RuntimeException) jjte000;
01395: }
01396: }
01397: if (jjte000 instanceof ParseException) {
01398: {
01399: if (true)
01400: throw (ParseException) jjte000;
01401: }
01402: }
01403: {
01404: if (true)
01405: throw (Error) jjte000;
01406: }
01407: } finally {
01408: if (jjtc000) {
01409: jjtree.closeNodeScope(jjtn000, true);
01410: jjtreeCloseNodeScope(jjtn000);
01411: }
01412: }
01413: }
01414:
01415: final public void FieldDeclaration(int modifiers)
01416: throws ParseException {
01417: /*@bgen(jjtree) FieldDeclaration */
01418: SimpleNode jjtn000 = new SimpleNode(JJTFIELDDECLARATION);
01419: boolean jjtc000 = true;
01420: jjtree.openNodeScope(jjtn000);
01421: jjtreeOpenNodeScope(jjtn000);
01422: try {
01423: Type();
01424: VariableDeclarator();
01425: label_11: while (true) {
01426: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01427: case COMMA:
01428: ;
01429: break;
01430: default:
01431: break label_11;
01432: }
01433: jj_consume_token(COMMA);
01434: VariableDeclarator();
01435: }
01436: jj_consume_token(SEMICOLON);
01437: } catch (Throwable jjte000) {
01438: if (jjtc000) {
01439: jjtree.clearNodeScope(jjtn000);
01440: jjtc000 = false;
01441: } else {
01442: jjtree.popNode();
01443: }
01444: if (jjte000 instanceof RuntimeException) {
01445: {
01446: if (true)
01447: throw (RuntimeException) jjte000;
01448: }
01449: }
01450: if (jjte000 instanceof ParseException) {
01451: {
01452: if (true)
01453: throw (ParseException) jjte000;
01454: }
01455: }
01456: {
01457: if (true)
01458: throw (Error) jjte000;
01459: }
01460: } finally {
01461: if (jjtc000) {
01462: jjtree.closeNodeScope(jjtn000, true);
01463: jjtreeCloseNodeScope(jjtn000);
01464: }
01465: }
01466: }
01467:
01468: final public void VariableDeclarator() throws ParseException {
01469: /*@bgen(jjtree) VariableDeclarator */
01470: SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEDECLARATOR);
01471: boolean jjtc000 = true;
01472: jjtree.openNodeScope(jjtn000);
01473: jjtreeOpenNodeScope(jjtn000);
01474: try {
01475: VariableDeclaratorId();
01476: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01477: case ASSIGN:
01478: jj_consume_token(ASSIGN);
01479: VariableInitializer();
01480: break;
01481: default:
01482: ;
01483: }
01484: } catch (Throwable jjte000) {
01485: if (jjtc000) {
01486: jjtree.clearNodeScope(jjtn000);
01487: jjtc000 = false;
01488: } else {
01489: jjtree.popNode();
01490: }
01491: if (jjte000 instanceof RuntimeException) {
01492: {
01493: if (true)
01494: throw (RuntimeException) jjte000;
01495: }
01496: }
01497: if (jjte000 instanceof ParseException) {
01498: {
01499: if (true)
01500: throw (ParseException) jjte000;
01501: }
01502: }
01503: {
01504: if (true)
01505: throw (Error) jjte000;
01506: }
01507: } finally {
01508: if (jjtc000) {
01509: jjtree.closeNodeScope(jjtn000, true);
01510: jjtreeCloseNodeScope(jjtn000);
01511: }
01512: }
01513: }
01514:
01515: final public void VariableDeclaratorId() throws ParseException {
01516: /*@bgen(jjtree) VariableDeclaratorId */
01517: SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEDECLARATORID);
01518: boolean jjtc000 = true;
01519: jjtree.openNodeScope(jjtn000);
01520: jjtreeOpenNodeScope(jjtn000);
01521: try {
01522: jj_consume_token(IDENTIFIER);
01523: label_12: while (true) {
01524: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01525: case LBRACKET:
01526: ;
01527: break;
01528: default:
01529: break label_12;
01530: }
01531: jj_consume_token(LBRACKET);
01532: jj_consume_token(RBRACKET);
01533: }
01534: } finally {
01535: if (jjtc000) {
01536: jjtree.closeNodeScope(jjtn000, true);
01537: jjtreeCloseNodeScope(jjtn000);
01538: }
01539: }
01540: }
01541:
01542: final public void VariableInitializer() throws ParseException {
01543: /*@bgen(jjtree) VariableInitializer */
01544: SimpleNode jjtn000 = new SimpleNode(JJTVARIABLEINITIALIZER);
01545: boolean jjtc000 = true;
01546: jjtree.openNodeScope(jjtn000);
01547: jjtreeOpenNodeScope(jjtn000);
01548: try {
01549: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01550: case LBRACE:
01551: ArrayInitializer();
01552: break;
01553: case BOOLEAN:
01554: case BYTE:
01555: case CHAR:
01556: case DOUBLE:
01557: case FALSE:
01558: case FLOAT:
01559: case INT:
01560: case LONG:
01561: case NEW:
01562: case NULL:
01563: case SHORT:
01564: case SUPER:
01565: case THIS:
01566: case TRUE:
01567: case VOID:
01568: case INTEGER_LITERAL:
01569: case FLOATING_POINT_LITERAL:
01570: case CHARACTER_LITERAL:
01571: case STRING_LITERAL:
01572: case IDENTIFIER:
01573: case LPAREN:
01574: case BANG:
01575: case TILDE:
01576: case INCR:
01577: case DECR:
01578: case PLUS:
01579: case MINUS:
01580: Expression();
01581: break;
01582: default:
01583: jj_consume_token(-1);
01584: throw new ParseException();
01585: }
01586: } catch (Throwable jjte000) {
01587: if (jjtc000) {
01588: jjtree.clearNodeScope(jjtn000);
01589: jjtc000 = false;
01590: } else {
01591: jjtree.popNode();
01592: }
01593: if (jjte000 instanceof RuntimeException) {
01594: {
01595: if (true)
01596: throw (RuntimeException) jjte000;
01597: }
01598: }
01599: if (jjte000 instanceof ParseException) {
01600: {
01601: if (true)
01602: throw (ParseException) jjte000;
01603: }
01604: }
01605: {
01606: if (true)
01607: throw (Error) jjte000;
01608: }
01609: } finally {
01610: if (jjtc000) {
01611: jjtree.closeNodeScope(jjtn000, true);
01612: jjtreeCloseNodeScope(jjtn000);
01613: }
01614: }
01615: }
01616:
01617: final public void ArrayInitializer() throws ParseException {
01618: /*@bgen(jjtree) ArrayInitializer */
01619: SimpleNode jjtn000 = new SimpleNode(JJTARRAYINITIALIZER);
01620: boolean jjtc000 = true;
01621: jjtree.openNodeScope(jjtn000);
01622: jjtreeOpenNodeScope(jjtn000);
01623: try {
01624: jj_consume_token(LBRACE);
01625: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01626: case BOOLEAN:
01627: case BYTE:
01628: case CHAR:
01629: case DOUBLE:
01630: case FALSE:
01631: case FLOAT:
01632: case INT:
01633: case LONG:
01634: case NEW:
01635: case NULL:
01636: case SHORT:
01637: case SUPER:
01638: case THIS:
01639: case TRUE:
01640: case VOID:
01641: case INTEGER_LITERAL:
01642: case FLOATING_POINT_LITERAL:
01643: case CHARACTER_LITERAL:
01644: case STRING_LITERAL:
01645: case IDENTIFIER:
01646: case LPAREN:
01647: case LBRACE:
01648: case BANG:
01649: case TILDE:
01650: case INCR:
01651: case DECR:
01652: case PLUS:
01653: case MINUS:
01654: VariableInitializer();
01655: label_13: while (true) {
01656: if (jj_2_11(2)) {
01657: ;
01658: } else {
01659: break label_13;
01660: }
01661: jj_consume_token(COMMA);
01662: VariableInitializer();
01663: }
01664: break;
01665: default:
01666: ;
01667: }
01668: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01669: case COMMA:
01670: jj_consume_token(COMMA);
01671: break;
01672: default:
01673: ;
01674: }
01675: jj_consume_token(RBRACE);
01676: } catch (Throwable jjte000) {
01677: if (jjtc000) {
01678: jjtree.clearNodeScope(jjtn000);
01679: jjtc000 = false;
01680: } else {
01681: jjtree.popNode();
01682: }
01683: if (jjte000 instanceof RuntimeException) {
01684: {
01685: if (true)
01686: throw (RuntimeException) jjte000;
01687: }
01688: }
01689: if (jjte000 instanceof ParseException) {
01690: {
01691: if (true)
01692: throw (ParseException) jjte000;
01693: }
01694: }
01695: {
01696: if (true)
01697: throw (Error) jjte000;
01698: }
01699: } finally {
01700: if (jjtc000) {
01701: jjtree.closeNodeScope(jjtn000, true);
01702: jjtreeCloseNodeScope(jjtn000);
01703: }
01704: }
01705: }
01706:
01707: final public void MethodDeclaration(int modifiers)
01708: throws ParseException {
01709: /*@bgen(jjtree) MethodDeclaration */
01710: SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATION);
01711: boolean jjtc000 = true;
01712: jjtree.openNodeScope(jjtn000);
01713: jjtreeOpenNodeScope(jjtn000);
01714: try {
01715: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01716: case LT:
01717: TypeParameters();
01718: break;
01719: default:
01720: ;
01721: }
01722: ResultType();
01723: MethodDeclarator();
01724: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01725: case THROWS:
01726: jj_consume_token(THROWS);
01727: NameList();
01728: break;
01729: default:
01730: ;
01731: }
01732: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01733: case LBRACE:
01734: Block();
01735: break;
01736: case SEMICOLON:
01737: jj_consume_token(SEMICOLON);
01738: break;
01739: default:
01740: jj_consume_token(-1);
01741: throw new ParseException();
01742: }
01743: } catch (Throwable jjte000) {
01744: if (jjtc000) {
01745: jjtree.clearNodeScope(jjtn000);
01746: jjtc000 = false;
01747: } else {
01748: jjtree.popNode();
01749: }
01750: if (jjte000 instanceof RuntimeException) {
01751: {
01752: if (true)
01753: throw (RuntimeException) jjte000;
01754: }
01755: }
01756: if (jjte000 instanceof ParseException) {
01757: {
01758: if (true)
01759: throw (ParseException) jjte000;
01760: }
01761: }
01762: {
01763: if (true)
01764: throw (Error) jjte000;
01765: }
01766: } finally {
01767: if (jjtc000) {
01768: jjtree.closeNodeScope(jjtn000, true);
01769: jjtreeCloseNodeScope(jjtn000);
01770: }
01771: }
01772: }
01773:
01774: final public void MethodDeclarator() throws ParseException {
01775: /*@bgen(jjtree) MethodDeclarator */
01776: SimpleNode jjtn000 = new SimpleNode(JJTMETHODDECLARATOR);
01777: boolean jjtc000 = true;
01778: jjtree.openNodeScope(jjtn000);
01779: jjtreeOpenNodeScope(jjtn000);
01780: try {
01781: jj_consume_token(IDENTIFIER);
01782: FormalParameters();
01783: label_14: while (true) {
01784: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01785: case LBRACKET:
01786: ;
01787: break;
01788: default:
01789: break label_14;
01790: }
01791: jj_consume_token(LBRACKET);
01792: jj_consume_token(RBRACKET);
01793: }
01794: } catch (Throwable jjte000) {
01795: if (jjtc000) {
01796: jjtree.clearNodeScope(jjtn000);
01797: jjtc000 = false;
01798: } else {
01799: jjtree.popNode();
01800: }
01801: if (jjte000 instanceof RuntimeException) {
01802: {
01803: if (true)
01804: throw (RuntimeException) jjte000;
01805: }
01806: }
01807: if (jjte000 instanceof ParseException) {
01808: {
01809: if (true)
01810: throw (ParseException) jjte000;
01811: }
01812: }
01813: {
01814: if (true)
01815: throw (Error) jjte000;
01816: }
01817: } finally {
01818: if (jjtc000) {
01819: jjtree.closeNodeScope(jjtn000, true);
01820: jjtreeCloseNodeScope(jjtn000);
01821: }
01822: }
01823: }
01824:
01825: final public void FormalParameters() throws ParseException {
01826: /*@bgen(jjtree) FormalParameters */
01827: SimpleNode jjtn000 = new SimpleNode(JJTFORMALPARAMETERS);
01828: boolean jjtc000 = true;
01829: jjtree.openNodeScope(jjtn000);
01830: jjtreeOpenNodeScope(jjtn000);
01831: try {
01832: jj_consume_token(LPAREN);
01833: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01834: case ABSTRACT:
01835: case BOOLEAN:
01836: case BYTE:
01837: case CHAR:
01838: case DOUBLE:
01839: case FINAL:
01840: case FLOAT:
01841: case INT:
01842: case LONG:
01843: case NATIVE:
01844: case PRIVATE:
01845: case PROTECTED:
01846: case PUBLIC:
01847: case SHORT:
01848: case STATIC:
01849: case STRICTFP:
01850: case SYNCHRONIZED:
01851: case TRANSIENT:
01852: case VOLATILE:
01853: case IDENTIFIER:
01854: case AT:
01855: FormalParameter();
01856: label_15: while (true) {
01857: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01858: case COMMA:
01859: ;
01860: break;
01861: default:
01862: break label_15;
01863: }
01864: jj_consume_token(COMMA);
01865: FormalParameter();
01866: }
01867: break;
01868: default:
01869: ;
01870: }
01871: jj_consume_token(RPAREN);
01872: } catch (Throwable jjte000) {
01873: if (jjtc000) {
01874: jjtree.clearNodeScope(jjtn000);
01875: jjtc000 = false;
01876: } else {
01877: jjtree.popNode();
01878: }
01879: if (jjte000 instanceof RuntimeException) {
01880: {
01881: if (true)
01882: throw (RuntimeException) jjte000;
01883: }
01884: }
01885: if (jjte000 instanceof ParseException) {
01886: {
01887: if (true)
01888: throw (ParseException) jjte000;
01889: }
01890: }
01891: {
01892: if (true)
01893: throw (Error) jjte000;
01894: }
01895: } finally {
01896: if (jjtc000) {
01897: jjtree.closeNodeScope(jjtn000, true);
01898: jjtreeCloseNodeScope(jjtn000);
01899: }
01900: }
01901: }
01902:
01903: final public void FormalParameter() throws ParseException {
01904: /*@bgen(jjtree) FormalParameter */
01905: SimpleNode jjtn000 = new SimpleNode(JJTFORMALPARAMETER);
01906: boolean jjtc000 = true;
01907: jjtree.openNodeScope(jjtn000);
01908: jjtreeOpenNodeScope(jjtn000);
01909: try {
01910: Modifiers();
01911: Type();
01912: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01913: case ELLIPSIS:
01914: jj_consume_token(ELLIPSIS);
01915: break;
01916: default:
01917: ;
01918: }
01919: VariableDeclaratorId();
01920: } catch (Throwable jjte000) {
01921: if (jjtc000) {
01922: jjtree.clearNodeScope(jjtn000);
01923: jjtc000 = false;
01924: } else {
01925: jjtree.popNode();
01926: }
01927: if (jjte000 instanceof RuntimeException) {
01928: {
01929: if (true)
01930: throw (RuntimeException) jjte000;
01931: }
01932: }
01933: if (jjte000 instanceof ParseException) {
01934: {
01935: if (true)
01936: throw (ParseException) jjte000;
01937: }
01938: }
01939: {
01940: if (true)
01941: throw (Error) jjte000;
01942: }
01943: } finally {
01944: if (jjtc000) {
01945: jjtree.closeNodeScope(jjtn000, true);
01946: jjtreeCloseNodeScope(jjtn000);
01947: }
01948: }
01949: }
01950:
01951: final public void ConstructorDeclaration() throws ParseException {
01952: /*@bgen(jjtree) ConstructorDeclaration */
01953: SimpleNode jjtn000 = new SimpleNode(JJTCONSTRUCTORDECLARATION);
01954: boolean jjtc000 = true;
01955: jjtree.openNodeScope(jjtn000);
01956: jjtreeOpenNodeScope(jjtn000);
01957: try {
01958: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01959: case LT:
01960: TypeParameters();
01961: break;
01962: default:
01963: ;
01964: }
01965: jj_consume_token(IDENTIFIER);
01966: FormalParameters();
01967: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01968: case THROWS:
01969: jj_consume_token(THROWS);
01970: NameList();
01971: break;
01972: default:
01973: ;
01974: }
01975: jj_consume_token(LBRACE);
01976: if (jj_2_12(2147483647)) {
01977: ExplicitConstructorInvocation();
01978: } else {
01979: ;
01980: }
01981: label_16: while (true) {
01982: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
01983: case ABSTRACT:
01984: case ASSERT:
01985: case BOOLEAN:
01986: case BREAK:
01987: case BYTE:
01988: case CHAR:
01989: case CLASS:
01990: case CONTINUE:
01991: case DO:
01992: case DOUBLE:
01993: case FALSE:
01994: case FINAL:
01995: case FLOAT:
01996: case FOR:
01997: case IF:
01998: case INT:
01999: case INTERFACE:
02000: case LONG:
02001: case NATIVE:
02002: case NEW:
02003: case NULL:
02004: case PRIVATE:
02005: case PROTECTED:
02006: case PUBLIC:
02007: case RETURN:
02008: case SHORT:
02009: case STATIC:
02010: case STRICTFP:
02011: case SUPER:
02012: case SWITCH:
02013: case SYNCHRONIZED:
02014: case THIS:
02015: case THROW:
02016: case TRANSIENT:
02017: case TRUE:
02018: case TRY:
02019: case VOID:
02020: case VOLATILE:
02021: case WHILE:
02022: case INTEGER_LITERAL:
02023: case FLOATING_POINT_LITERAL:
02024: case CHARACTER_LITERAL:
02025: case STRING_LITERAL:
02026: case IDENTIFIER:
02027: case LPAREN:
02028: case LBRACE:
02029: case SEMICOLON:
02030: case AT:
02031: case INCR:
02032: case DECR:
02033: ;
02034: break;
02035: default:
02036: break label_16;
02037: }
02038: BlockStatement();
02039: }
02040: jj_consume_token(RBRACE);
02041: } catch (Throwable jjte000) {
02042: if (jjtc000) {
02043: jjtree.clearNodeScope(jjtn000);
02044: jjtc000 = false;
02045: } else {
02046: jjtree.popNode();
02047: }
02048: if (jjte000 instanceof RuntimeException) {
02049: {
02050: if (true)
02051: throw (RuntimeException) jjte000;
02052: }
02053: }
02054: if (jjte000 instanceof ParseException) {
02055: {
02056: if (true)
02057: throw (ParseException) jjte000;
02058: }
02059: }
02060: {
02061: if (true)
02062: throw (Error) jjte000;
02063: }
02064: } finally {
02065: if (jjtc000) {
02066: jjtree.closeNodeScope(jjtn000, true);
02067: jjtreeCloseNodeScope(jjtn000);
02068: }
02069: }
02070: }
02071:
02072: final public void ExplicitConstructorInvocation()
02073: throws ParseException {
02074: /*@bgen(jjtree) ExplicitConstructorInvocation */
02075: SimpleNode jjtn000 = new SimpleNode(
02076: JJTEXPLICITCONSTRUCTORINVOCATION);
02077: boolean jjtc000 = true;
02078: jjtree.openNodeScope(jjtn000);
02079: jjtreeOpenNodeScope(jjtn000);
02080: try {
02081: label_17: while (true) {
02082: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02083: case IDENTIFIER:
02084: ;
02085: break;
02086: default:
02087: break label_17;
02088: }
02089: jj_consume_token(IDENTIFIER);
02090: jj_consume_token(DOT);
02091: }
02092: if (jj_2_13(2)) {
02093: jj_consume_token(THIS);
02094: jj_consume_token(DOT);
02095: } else {
02096: ;
02097: }
02098: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02099: case LT:
02100: TypeArguments();
02101: break;
02102: default:
02103: ;
02104: }
02105: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02106: case THIS:
02107: jj_consume_token(THIS);
02108: break;
02109: case SUPER:
02110: jj_consume_token(SUPER);
02111: break;
02112: default:
02113: jj_consume_token(-1);
02114: throw new ParseException();
02115: }
02116: Arguments();
02117: jj_consume_token(SEMICOLON);
02118: } catch (Throwable jjte000) {
02119: if (jjtc000) {
02120: jjtree.clearNodeScope(jjtn000);
02121: jjtc000 = false;
02122: } else {
02123: jjtree.popNode();
02124: }
02125: if (jjte000 instanceof RuntimeException) {
02126: {
02127: if (true)
02128: throw (RuntimeException) jjte000;
02129: }
02130: }
02131: if (jjte000 instanceof ParseException) {
02132: {
02133: if (true)
02134: throw (ParseException) jjte000;
02135: }
02136: }
02137: {
02138: if (true)
02139: throw (Error) jjte000;
02140: }
02141: } finally {
02142: if (jjtc000) {
02143: jjtree.closeNodeScope(jjtn000, true);
02144: jjtreeCloseNodeScope(jjtn000);
02145: }
02146: }
02147: }
02148:
02149: final public void Initializer() throws ParseException {
02150: /*@bgen(jjtree) Initializer */
02151: SimpleNode jjtn000 = new SimpleNode(JJTINITIALIZER);
02152: boolean jjtc000 = true;
02153: jjtree.openNodeScope(jjtn000);
02154: jjtreeOpenNodeScope(jjtn000);
02155: try {
02156: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02157: case STATIC:
02158: jj_consume_token(STATIC);
02159: break;
02160: default:
02161: ;
02162: }
02163: Block();
02164: } catch (Throwable jjte000) {
02165: if (jjtc000) {
02166: jjtree.clearNodeScope(jjtn000);
02167: jjtc000 = false;
02168: } else {
02169: jjtree.popNode();
02170: }
02171: if (jjte000 instanceof RuntimeException) {
02172: {
02173: if (true)
02174: throw (RuntimeException) jjte000;
02175: }
02176: }
02177: if (jjte000 instanceof ParseException) {
02178: {
02179: if (true)
02180: throw (ParseException) jjte000;
02181: }
02182: }
02183: {
02184: if (true)
02185: throw (Error) jjte000;
02186: }
02187: } finally {
02188: if (jjtc000) {
02189: jjtree.closeNodeScope(jjtn000, true);
02190: jjtreeCloseNodeScope(jjtn000);
02191: }
02192: }
02193: }
02194:
02195: /*
02196: * Type, name and expression syntax follows.
02197: */
02198: final public void Type() throws ParseException {
02199: /*@bgen(jjtree) Type */
02200: SimpleNode jjtn000 = new SimpleNode(JJTTYPE);
02201: boolean jjtc000 = true;
02202: jjtree.openNodeScope(jjtn000);
02203: jjtreeOpenNodeScope(jjtn000);
02204: try {
02205: if (jj_2_14(2)) {
02206: ReferenceType();
02207: } else {
02208: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02209: case BOOLEAN:
02210: case BYTE:
02211: case CHAR:
02212: case DOUBLE:
02213: case FLOAT:
02214: case INT:
02215: case LONG:
02216: case SHORT:
02217: PrimitiveType();
02218: break;
02219: default:
02220: jj_consume_token(-1);
02221: throw new ParseException();
02222: }
02223: }
02224: } catch (Throwable jjte000) {
02225: if (jjtc000) {
02226: jjtree.clearNodeScope(jjtn000);
02227: jjtc000 = false;
02228: } else {
02229: jjtree.popNode();
02230: }
02231: if (jjte000 instanceof RuntimeException) {
02232: {
02233: if (true)
02234: throw (RuntimeException) jjte000;
02235: }
02236: }
02237: if (jjte000 instanceof ParseException) {
02238: {
02239: if (true)
02240: throw (ParseException) jjte000;
02241: }
02242: }
02243: {
02244: if (true)
02245: throw (Error) jjte000;
02246: }
02247: } finally {
02248: if (jjtc000) {
02249: jjtree.closeNodeScope(jjtn000, true);
02250: jjtreeCloseNodeScope(jjtn000);
02251: }
02252: }
02253: }
02254:
02255: final public void ReferenceType() throws ParseException {
02256: /*@bgen(jjtree) ReferenceType */
02257: SimpleNode jjtn000 = new SimpleNode(JJTREFERENCETYPE);
02258: boolean jjtc000 = true;
02259: jjtree.openNodeScope(jjtn000);
02260: jjtreeOpenNodeScope(jjtn000);
02261: try {
02262: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02263: case BOOLEAN:
02264: case BYTE:
02265: case CHAR:
02266: case DOUBLE:
02267: case FLOAT:
02268: case INT:
02269: case LONG:
02270: case SHORT:
02271: PrimitiveType();
02272: label_18: while (true) {
02273: jj_consume_token(LBRACKET);
02274: jj_consume_token(RBRACKET);
02275: if (jj_2_15(2)) {
02276: ;
02277: } else {
02278: break label_18;
02279: }
02280: }
02281: break;
02282: case IDENTIFIER:
02283: ClassOrInterfaceType();
02284: label_19: while (true) {
02285: if (jj_2_16(2)) {
02286: ;
02287: } else {
02288: break label_19;
02289: }
02290: jj_consume_token(LBRACKET);
02291: jj_consume_token(RBRACKET);
02292: }
02293: break;
02294: default:
02295: jj_consume_token(-1);
02296: throw new ParseException();
02297: }
02298: } catch (Throwable jjte000) {
02299: if (jjtc000) {
02300: jjtree.clearNodeScope(jjtn000);
02301: jjtc000 = false;
02302: } else {
02303: jjtree.popNode();
02304: }
02305: if (jjte000 instanceof RuntimeException) {
02306: {
02307: if (true)
02308: throw (RuntimeException) jjte000;
02309: }
02310: }
02311: if (jjte000 instanceof ParseException) {
02312: {
02313: if (true)
02314: throw (ParseException) jjte000;
02315: }
02316: }
02317: {
02318: if (true)
02319: throw (Error) jjte000;
02320: }
02321: } finally {
02322: if (jjtc000) {
02323: jjtree.closeNodeScope(jjtn000, true);
02324: jjtreeCloseNodeScope(jjtn000);
02325: }
02326: }
02327: }
02328:
02329: final public void ClassOrInterfaceType() throws ParseException {
02330: /*@bgen(jjtree) ClassOrInterfaceType */
02331: SimpleNode jjtn000 = new SimpleNode(JJTCLASSORINTERFACETYPE);
02332: boolean jjtc000 = true;
02333: jjtree.openNodeScope(jjtn000);
02334: jjtreeOpenNodeScope(jjtn000);
02335: try {
02336: jj_consume_token(IDENTIFIER);
02337: if (jj_2_17(2)) {
02338: TypeArguments();
02339: } else {
02340: ;
02341: }
02342: label_20: while (true) {
02343: if (jj_2_18(2)) {
02344: ;
02345: } else {
02346: break label_20;
02347: }
02348: jj_consume_token(DOT);
02349: jj_consume_token(IDENTIFIER);
02350: if (jj_2_19(2)) {
02351: TypeArguments();
02352: } else {
02353: ;
02354: }
02355: }
02356: } catch (Throwable jjte000) {
02357: if (jjtc000) {
02358: jjtree.clearNodeScope(jjtn000);
02359: jjtc000 = false;
02360: } else {
02361: jjtree.popNode();
02362: }
02363: if (jjte000 instanceof RuntimeException) {
02364: {
02365: if (true)
02366: throw (RuntimeException) jjte000;
02367: }
02368: }
02369: if (jjte000 instanceof ParseException) {
02370: {
02371: if (true)
02372: throw (ParseException) jjte000;
02373: }
02374: }
02375: {
02376: if (true)
02377: throw (Error) jjte000;
02378: }
02379: } finally {
02380: if (jjtc000) {
02381: jjtree.closeNodeScope(jjtn000, true);
02382: jjtreeCloseNodeScope(jjtn000);
02383: }
02384: }
02385: }
02386:
02387: final public void TypeArguments() throws ParseException {
02388: /*@bgen(jjtree) TypeArguments */
02389: SimpleNode jjtn000 = new SimpleNode(JJTTYPEARGUMENTS);
02390: boolean jjtc000 = true;
02391: jjtree.openNodeScope(jjtn000);
02392: jjtreeOpenNodeScope(jjtn000);
02393: try {
02394: jj_consume_token(LT);
02395: TypeArgument();
02396: label_21: while (true) {
02397: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02398: case COMMA:
02399: ;
02400: break;
02401: default:
02402: break label_21;
02403: }
02404: jj_consume_token(COMMA);
02405: TypeArgument();
02406: }
02407: jj_consume_token(GT);
02408: } catch (Throwable jjte000) {
02409: if (jjtc000) {
02410: jjtree.clearNodeScope(jjtn000);
02411: jjtc000 = false;
02412: } else {
02413: jjtree.popNode();
02414: }
02415: if (jjte000 instanceof RuntimeException) {
02416: {
02417: if (true)
02418: throw (RuntimeException) jjte000;
02419: }
02420: }
02421: if (jjte000 instanceof ParseException) {
02422: {
02423: if (true)
02424: throw (ParseException) jjte000;
02425: }
02426: }
02427: {
02428: if (true)
02429: throw (Error) jjte000;
02430: }
02431: } finally {
02432: if (jjtc000) {
02433: jjtree.closeNodeScope(jjtn000, true);
02434: jjtreeCloseNodeScope(jjtn000);
02435: }
02436: }
02437: }
02438:
02439: final public void TypeArgument() throws ParseException {
02440: /*@bgen(jjtree) TypeArgument */
02441: SimpleNode jjtn000 = new SimpleNode(JJTTYPEARGUMENT);
02442: boolean jjtc000 = true;
02443: jjtree.openNodeScope(jjtn000);
02444: jjtreeOpenNodeScope(jjtn000);
02445: try {
02446: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02447: case BOOLEAN:
02448: case BYTE:
02449: case CHAR:
02450: case DOUBLE:
02451: case FLOAT:
02452: case INT:
02453: case LONG:
02454: case SHORT:
02455: case IDENTIFIER:
02456: ReferenceType();
02457: break;
02458: case HOOK:
02459: jj_consume_token(HOOK);
02460: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02461: case EXTENDS:
02462: case SUPER:
02463: WildcardBounds();
02464: break;
02465: default:
02466: ;
02467: }
02468: break;
02469: default:
02470: jj_consume_token(-1);
02471: throw new ParseException();
02472: }
02473: } catch (Throwable jjte000) {
02474: if (jjtc000) {
02475: jjtree.clearNodeScope(jjtn000);
02476: jjtc000 = false;
02477: } else {
02478: jjtree.popNode();
02479: }
02480: if (jjte000 instanceof RuntimeException) {
02481: {
02482: if (true)
02483: throw (RuntimeException) jjte000;
02484: }
02485: }
02486: if (jjte000 instanceof ParseException) {
02487: {
02488: if (true)
02489: throw (ParseException) jjte000;
02490: }
02491: }
02492: {
02493: if (true)
02494: throw (Error) jjte000;
02495: }
02496: } finally {
02497: if (jjtc000) {
02498: jjtree.closeNodeScope(jjtn000, true);
02499: jjtreeCloseNodeScope(jjtn000);
02500: }
02501: }
02502: }
02503:
02504: final public void WildcardBounds() throws ParseException {
02505: /*@bgen(jjtree) WildcardBounds */
02506: SimpleNode jjtn000 = new SimpleNode(JJTWILDCARDBOUNDS);
02507: boolean jjtc000 = true;
02508: jjtree.openNodeScope(jjtn000);
02509: jjtreeOpenNodeScope(jjtn000);
02510: try {
02511: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02512: case EXTENDS:
02513: jj_consume_token(EXTENDS);
02514: ReferenceType();
02515: break;
02516: case SUPER:
02517: jj_consume_token(SUPER);
02518: ReferenceType();
02519: break;
02520: default:
02521: jj_consume_token(-1);
02522: throw new ParseException();
02523: }
02524: } catch (Throwable jjte000) {
02525: if (jjtc000) {
02526: jjtree.clearNodeScope(jjtn000);
02527: jjtc000 = false;
02528: } else {
02529: jjtree.popNode();
02530: }
02531: if (jjte000 instanceof RuntimeException) {
02532: {
02533: if (true)
02534: throw (RuntimeException) jjte000;
02535: }
02536: }
02537: if (jjte000 instanceof ParseException) {
02538: {
02539: if (true)
02540: throw (ParseException) jjte000;
02541: }
02542: }
02543: {
02544: if (true)
02545: throw (Error) jjte000;
02546: }
02547: } finally {
02548: if (jjtc000) {
02549: jjtree.closeNodeScope(jjtn000, true);
02550: jjtreeCloseNodeScope(jjtn000);
02551: }
02552: }
02553: }
02554:
02555: final public void PrimitiveType() throws ParseException {
02556: /*@bgen(jjtree) PrimitiveType */
02557: SimpleNode jjtn000 = new SimpleNode(JJTPRIMITIVETYPE);
02558: boolean jjtc000 = true;
02559: jjtree.openNodeScope(jjtn000);
02560: jjtreeOpenNodeScope(jjtn000);
02561: try {
02562: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02563: case BOOLEAN:
02564: jj_consume_token(BOOLEAN);
02565: break;
02566: case CHAR:
02567: jj_consume_token(CHAR);
02568: break;
02569: case BYTE:
02570: jj_consume_token(BYTE);
02571: break;
02572: case SHORT:
02573: jj_consume_token(SHORT);
02574: break;
02575: case INT:
02576: jj_consume_token(INT);
02577: break;
02578: case LONG:
02579: jj_consume_token(LONG);
02580: break;
02581: case FLOAT:
02582: jj_consume_token(FLOAT);
02583: break;
02584: case DOUBLE:
02585: jj_consume_token(DOUBLE);
02586: break;
02587: default:
02588: jj_consume_token(-1);
02589: throw new ParseException();
02590: }
02591: } finally {
02592: if (jjtc000) {
02593: jjtree.closeNodeScope(jjtn000, true);
02594: jjtreeCloseNodeScope(jjtn000);
02595: }
02596: }
02597: }
02598:
02599: final public void ResultType() throws ParseException {
02600: /*@bgen(jjtree) ResultType */
02601: SimpleNode jjtn000 = new SimpleNode(JJTRESULTTYPE);
02602: boolean jjtc000 = true;
02603: jjtree.openNodeScope(jjtn000);
02604: jjtreeOpenNodeScope(jjtn000);
02605: try {
02606: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02607: case VOID:
02608: jj_consume_token(VOID);
02609: break;
02610: case BOOLEAN:
02611: case BYTE:
02612: case CHAR:
02613: case DOUBLE:
02614: case FLOAT:
02615: case INT:
02616: case LONG:
02617: case SHORT:
02618: case IDENTIFIER:
02619: Type();
02620: break;
02621: default:
02622: jj_consume_token(-1);
02623: throw new ParseException();
02624: }
02625: } catch (Throwable jjte000) {
02626: if (jjtc000) {
02627: jjtree.clearNodeScope(jjtn000);
02628: jjtc000 = false;
02629: } else {
02630: jjtree.popNode();
02631: }
02632: if (jjte000 instanceof RuntimeException) {
02633: {
02634: if (true)
02635: throw (RuntimeException) jjte000;
02636: }
02637: }
02638: if (jjte000 instanceof ParseException) {
02639: {
02640: if (true)
02641: throw (ParseException) jjte000;
02642: }
02643: }
02644: {
02645: if (true)
02646: throw (Error) jjte000;
02647: }
02648: } finally {
02649: if (jjtc000) {
02650: jjtree.closeNodeScope(jjtn000, true);
02651: jjtreeCloseNodeScope(jjtn000);
02652: }
02653: }
02654: }
02655:
02656: final public void Name() throws ParseException {
02657: /*@bgen(jjtree) Name */
02658: SimpleNode jjtn000 = new SimpleNode(JJTNAME);
02659: boolean jjtc000 = true;
02660: jjtree.openNodeScope(jjtn000);
02661: jjtreeOpenNodeScope(jjtn000);
02662: try {
02663: jj_consume_token(IDENTIFIER);
02664: label_22: while (true) {
02665: if (jj_2_20(2)) {
02666: ;
02667: } else {
02668: break label_22;
02669: }
02670: jj_consume_token(DOT);
02671: jj_consume_token(IDENTIFIER);
02672: }
02673: } finally {
02674: if (jjtc000) {
02675: jjtree.closeNodeScope(jjtn000, true);
02676: jjtreeCloseNodeScope(jjtn000);
02677: }
02678: }
02679: }
02680:
02681: final public void NameList() throws ParseException {
02682: /*@bgen(jjtree) NameList */
02683: SimpleNode jjtn000 = new SimpleNode(JJTNAMELIST);
02684: boolean jjtc000 = true;
02685: jjtree.openNodeScope(jjtn000);
02686: jjtreeOpenNodeScope(jjtn000);
02687: try {
02688: Name();
02689: label_23: while (true) {
02690: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02691: case COMMA:
02692: ;
02693: break;
02694: default:
02695: break label_23;
02696: }
02697: jj_consume_token(COMMA);
02698: Name();
02699: }
02700: } catch (Throwable jjte000) {
02701: if (jjtc000) {
02702: jjtree.clearNodeScope(jjtn000);
02703: jjtc000 = false;
02704: } else {
02705: jjtree.popNode();
02706: }
02707: if (jjte000 instanceof RuntimeException) {
02708: {
02709: if (true)
02710: throw (RuntimeException) jjte000;
02711: }
02712: }
02713: if (jjte000 instanceof ParseException) {
02714: {
02715: if (true)
02716: throw (ParseException) jjte000;
02717: }
02718: }
02719: {
02720: if (true)
02721: throw (Error) jjte000;
02722: }
02723: } finally {
02724: if (jjtc000) {
02725: jjtree.closeNodeScope(jjtn000, true);
02726: jjtreeCloseNodeScope(jjtn000);
02727: }
02728: }
02729: }
02730:
02731: /*
02732: * Expression syntax follows.
02733: */
02734: final public void Expression() throws ParseException {
02735: /*@bgen(jjtree) Expression */
02736: SimpleNode jjtn000 = new SimpleNode(JJTEXPRESSION);
02737: boolean jjtc000 = true;
02738: jjtree.openNodeScope(jjtn000);
02739: jjtreeOpenNodeScope(jjtn000);
02740: try {
02741: ConditionalExpression();
02742: if (jj_2_21(2)) {
02743: AssignmentOperator();
02744: Expression();
02745: } else {
02746: ;
02747: }
02748: } catch (Throwable jjte000) {
02749: if (jjtc000) {
02750: jjtree.clearNodeScope(jjtn000);
02751: jjtc000 = false;
02752: } else {
02753: jjtree.popNode();
02754: }
02755: if (jjte000 instanceof RuntimeException) {
02756: {
02757: if (true)
02758: throw (RuntimeException) jjte000;
02759: }
02760: }
02761: if (jjte000 instanceof ParseException) {
02762: {
02763: if (true)
02764: throw (ParseException) jjte000;
02765: }
02766: }
02767: {
02768: if (true)
02769: throw (Error) jjte000;
02770: }
02771: } finally {
02772: if (jjtc000) {
02773: jjtree.closeNodeScope(jjtn000, true);
02774: jjtreeCloseNodeScope(jjtn000);
02775: }
02776: }
02777: }
02778:
02779: final public void AssignmentOperator() throws ParseException {
02780: /*@bgen(jjtree) AssignmentOperator */
02781: SimpleNode jjtn000 = new SimpleNode(JJTASSIGNMENTOPERATOR);
02782: boolean jjtc000 = true;
02783: jjtree.openNodeScope(jjtn000);
02784: jjtreeOpenNodeScope(jjtn000);
02785: try {
02786: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02787: case ASSIGN:
02788: jj_consume_token(ASSIGN);
02789: break;
02790: case STARASSIGN:
02791: jj_consume_token(STARASSIGN);
02792: break;
02793: case SLASHASSIGN:
02794: jj_consume_token(SLASHASSIGN);
02795: break;
02796: case REMASSIGN:
02797: jj_consume_token(REMASSIGN);
02798: break;
02799: case PLUSASSIGN:
02800: jj_consume_token(PLUSASSIGN);
02801: break;
02802: case MINUSASSIGN:
02803: jj_consume_token(MINUSASSIGN);
02804: break;
02805: case LSHIFTASSIGN:
02806: jj_consume_token(LSHIFTASSIGN);
02807: break;
02808: case RSIGNEDSHIFTASSIGN:
02809: jj_consume_token(RSIGNEDSHIFTASSIGN);
02810: break;
02811: case RUNSIGNEDSHIFTASSIGN:
02812: jj_consume_token(RUNSIGNEDSHIFTASSIGN);
02813: break;
02814: case ANDASSIGN:
02815: jj_consume_token(ANDASSIGN);
02816: break;
02817: case XORASSIGN:
02818: jj_consume_token(XORASSIGN);
02819: break;
02820: case ORASSIGN:
02821: jj_consume_token(ORASSIGN);
02822: break;
02823: default:
02824: jj_consume_token(-1);
02825: throw new ParseException();
02826: }
02827: } finally {
02828: if (jjtc000) {
02829: jjtree.closeNodeScope(jjtn000, true);
02830: jjtreeCloseNodeScope(jjtn000);
02831: }
02832: }
02833: }
02834:
02835: final public void AssignmentExpression() throws ParseException {
02836: /*@bgen(jjtree) AssignmentExpression */
02837: SimpleNode jjtn000 = new SimpleNode(JJTASSIGNMENTEXPRESSION);
02838: boolean jjtc000 = true;
02839: jjtree.openNodeScope(jjtn000);
02840: jjtreeOpenNodeScope(jjtn000);
02841: try {
02842: PrimaryExpression();
02843: AssignmentOperator();
02844: Expression();
02845: } catch (Throwable jjte000) {
02846: if (jjtc000) {
02847: jjtree.clearNodeScope(jjtn000);
02848: jjtc000 = false;
02849: } else {
02850: jjtree.popNode();
02851: }
02852: if (jjte000 instanceof RuntimeException) {
02853: {
02854: if (true)
02855: throw (RuntimeException) jjte000;
02856: }
02857: }
02858: if (jjte000 instanceof ParseException) {
02859: {
02860: if (true)
02861: throw (ParseException) jjte000;
02862: }
02863: }
02864: {
02865: if (true)
02866: throw (Error) jjte000;
02867: }
02868: } finally {
02869: if (jjtc000) {
02870: jjtree.closeNodeScope(jjtn000, true);
02871: jjtreeCloseNodeScope(jjtn000);
02872: }
02873: }
02874: }
02875:
02876: final public void ConditionalExpression() throws ParseException {
02877: /*@bgen(jjtree) ConditionalExpression */
02878: SimpleNode jjtn000 = new SimpleNode(JJTCONDITIONALEXPRESSION);
02879: boolean jjtc000 = true;
02880: jjtree.openNodeScope(jjtn000);
02881: jjtreeOpenNodeScope(jjtn000);
02882: try {
02883: ConditionalOrExpression();
02884: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02885: case HOOK:
02886: jj_consume_token(HOOK);
02887: Expression();
02888: jj_consume_token(COLON);
02889: Expression();
02890: break;
02891: default:
02892: ;
02893: }
02894: } catch (Throwable jjte000) {
02895: if (jjtc000) {
02896: jjtree.clearNodeScope(jjtn000);
02897: jjtc000 = false;
02898: } else {
02899: jjtree.popNode();
02900: }
02901: if (jjte000 instanceof RuntimeException) {
02902: {
02903: if (true)
02904: throw (RuntimeException) jjte000;
02905: }
02906: }
02907: if (jjte000 instanceof ParseException) {
02908: {
02909: if (true)
02910: throw (ParseException) jjte000;
02911: }
02912: }
02913: {
02914: if (true)
02915: throw (Error) jjte000;
02916: }
02917: } finally {
02918: if (jjtc000) {
02919: jjtree.closeNodeScope(jjtn000, true);
02920: jjtreeCloseNodeScope(jjtn000);
02921: }
02922: }
02923: }
02924:
02925: final public void ConditionalOrExpression() throws ParseException {
02926: /*@bgen(jjtree) ConditionalOrExpression */
02927: SimpleNode jjtn000 = new SimpleNode(JJTCONDITIONALOREXPRESSION);
02928: boolean jjtc000 = true;
02929: jjtree.openNodeScope(jjtn000);
02930: jjtreeOpenNodeScope(jjtn000);
02931: try {
02932: ConditionalAndExpression();
02933: label_24: while (true) {
02934: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02935: case SC_OR:
02936: ;
02937: break;
02938: default:
02939: break label_24;
02940: }
02941: jj_consume_token(SC_OR);
02942: ConditionalAndExpression();
02943: }
02944: } catch (Throwable jjte000) {
02945: if (jjtc000) {
02946: jjtree.clearNodeScope(jjtn000);
02947: jjtc000 = false;
02948: } else {
02949: jjtree.popNode();
02950: }
02951: if (jjte000 instanceof RuntimeException) {
02952: {
02953: if (true)
02954: throw (RuntimeException) jjte000;
02955: }
02956: }
02957: if (jjte000 instanceof ParseException) {
02958: {
02959: if (true)
02960: throw (ParseException) jjte000;
02961: }
02962: }
02963: {
02964: if (true)
02965: throw (Error) jjte000;
02966: }
02967: } finally {
02968: if (jjtc000) {
02969: jjtree.closeNodeScope(jjtn000, true);
02970: jjtreeCloseNodeScope(jjtn000);
02971: }
02972: }
02973: }
02974:
02975: final public void ConditionalAndExpression() throws ParseException {
02976: /*@bgen(jjtree) ConditionalAndExpression */
02977: SimpleNode jjtn000 = new SimpleNode(JJTCONDITIONALANDEXPRESSION);
02978: boolean jjtc000 = true;
02979: jjtree.openNodeScope(jjtn000);
02980: jjtreeOpenNodeScope(jjtn000);
02981: try {
02982: InclusiveOrExpression();
02983: label_25: while (true) {
02984: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
02985: case SC_AND:
02986: ;
02987: break;
02988: default:
02989: break label_25;
02990: }
02991: jj_consume_token(SC_AND);
02992: InclusiveOrExpression();
02993: }
02994: } catch (Throwable jjte000) {
02995: if (jjtc000) {
02996: jjtree.clearNodeScope(jjtn000);
02997: jjtc000 = false;
02998: } else {
02999: jjtree.popNode();
03000: }
03001: if (jjte000 instanceof RuntimeException) {
03002: {
03003: if (true)
03004: throw (RuntimeException) jjte000;
03005: }
03006: }
03007: if (jjte000 instanceof ParseException) {
03008: {
03009: if (true)
03010: throw (ParseException) jjte000;
03011: }
03012: }
03013: {
03014: if (true)
03015: throw (Error) jjte000;
03016: }
03017: } finally {
03018: if (jjtc000) {
03019: jjtree.closeNodeScope(jjtn000, true);
03020: jjtreeCloseNodeScope(jjtn000);
03021: }
03022: }
03023: }
03024:
03025: final public void InclusiveOrExpression() throws ParseException {
03026: /*@bgen(jjtree) InclusiveOrExpression */
03027: SimpleNode jjtn000 = new SimpleNode(JJTINCLUSIVEOREXPRESSION);
03028: boolean jjtc000 = true;
03029: jjtree.openNodeScope(jjtn000);
03030: jjtreeOpenNodeScope(jjtn000);
03031: try {
03032: ExclusiveOrExpression();
03033: label_26: while (true) {
03034: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03035: case BIT_OR:
03036: ;
03037: break;
03038: default:
03039: break label_26;
03040: }
03041: jj_consume_token(BIT_OR);
03042: ExclusiveOrExpression();
03043: }
03044: } catch (Throwable jjte000) {
03045: if (jjtc000) {
03046: jjtree.clearNodeScope(jjtn000);
03047: jjtc000 = false;
03048: } else {
03049: jjtree.popNode();
03050: }
03051: if (jjte000 instanceof RuntimeException) {
03052: {
03053: if (true)
03054: throw (RuntimeException) jjte000;
03055: }
03056: }
03057: if (jjte000 instanceof ParseException) {
03058: {
03059: if (true)
03060: throw (ParseException) jjte000;
03061: }
03062: }
03063: {
03064: if (true)
03065: throw (Error) jjte000;
03066: }
03067: } finally {
03068: if (jjtc000) {
03069: jjtree.closeNodeScope(jjtn000, true);
03070: jjtreeCloseNodeScope(jjtn000);
03071: }
03072: }
03073: }
03074:
03075: final public void ExclusiveOrExpression() throws ParseException {
03076: /*@bgen(jjtree) ExclusiveOrExpression */
03077: SimpleNode jjtn000 = new SimpleNode(JJTEXCLUSIVEOREXPRESSION);
03078: boolean jjtc000 = true;
03079: jjtree.openNodeScope(jjtn000);
03080: jjtreeOpenNodeScope(jjtn000);
03081: try {
03082: AndExpression();
03083: label_27: while (true) {
03084: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03085: case XOR:
03086: ;
03087: break;
03088: default:
03089: break label_27;
03090: }
03091: jj_consume_token(XOR);
03092: AndExpression();
03093: }
03094: } catch (Throwable jjte000) {
03095: if (jjtc000) {
03096: jjtree.clearNodeScope(jjtn000);
03097: jjtc000 = false;
03098: } else {
03099: jjtree.popNode();
03100: }
03101: if (jjte000 instanceof RuntimeException) {
03102: {
03103: if (true)
03104: throw (RuntimeException) jjte000;
03105: }
03106: }
03107: if (jjte000 instanceof ParseException) {
03108: {
03109: if (true)
03110: throw (ParseException) jjte000;
03111: }
03112: }
03113: {
03114: if (true)
03115: throw (Error) jjte000;
03116: }
03117: } finally {
03118: if (jjtc000) {
03119: jjtree.closeNodeScope(jjtn000, true);
03120: jjtreeCloseNodeScope(jjtn000);
03121: }
03122: }
03123: }
03124:
03125: final public void AndExpression() throws ParseException {
03126: /*@bgen(jjtree) AndExpression */
03127: SimpleNode jjtn000 = new SimpleNode(JJTANDEXPRESSION);
03128: boolean jjtc000 = true;
03129: jjtree.openNodeScope(jjtn000);
03130: jjtreeOpenNodeScope(jjtn000);
03131: try {
03132: EqualityExpression();
03133: label_28: while (true) {
03134: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03135: case BIT_AND:
03136: ;
03137: break;
03138: default:
03139: break label_28;
03140: }
03141: jj_consume_token(BIT_AND);
03142: EqualityExpression();
03143: }
03144: } catch (Throwable jjte000) {
03145: if (jjtc000) {
03146: jjtree.clearNodeScope(jjtn000);
03147: jjtc000 = false;
03148: } else {
03149: jjtree.popNode();
03150: }
03151: if (jjte000 instanceof RuntimeException) {
03152: {
03153: if (true)
03154: throw (RuntimeException) jjte000;
03155: }
03156: }
03157: if (jjte000 instanceof ParseException) {
03158: {
03159: if (true)
03160: throw (ParseException) jjte000;
03161: }
03162: }
03163: {
03164: if (true)
03165: throw (Error) jjte000;
03166: }
03167: } finally {
03168: if (jjtc000) {
03169: jjtree.closeNodeScope(jjtn000, true);
03170: jjtreeCloseNodeScope(jjtn000);
03171: }
03172: }
03173: }
03174:
03175: final public void EqualityExpression() throws ParseException {
03176: /*@bgen(jjtree) EqualityExpression */
03177: SimpleNode jjtn000 = new SimpleNode(JJTEQUALITYEXPRESSION);
03178: boolean jjtc000 = true;
03179: jjtree.openNodeScope(jjtn000);
03180: jjtreeOpenNodeScope(jjtn000);
03181: try {
03182: InstanceOfExpression();
03183: label_29: while (true) {
03184: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03185: case EQ:
03186: case NE:
03187: ;
03188: break;
03189: default:
03190: break label_29;
03191: }
03192: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03193: case EQ:
03194: jj_consume_token(EQ);
03195: break;
03196: case NE:
03197: jj_consume_token(NE);
03198: break;
03199: default:
03200: jj_consume_token(-1);
03201: throw new ParseException();
03202: }
03203: InstanceOfExpression();
03204: }
03205: } catch (Throwable jjte000) {
03206: if (jjtc000) {
03207: jjtree.clearNodeScope(jjtn000);
03208: jjtc000 = false;
03209: } else {
03210: jjtree.popNode();
03211: }
03212: if (jjte000 instanceof RuntimeException) {
03213: {
03214: if (true)
03215: throw (RuntimeException) jjte000;
03216: }
03217: }
03218: if (jjte000 instanceof ParseException) {
03219: {
03220: if (true)
03221: throw (ParseException) jjte000;
03222: }
03223: }
03224: {
03225: if (true)
03226: throw (Error) jjte000;
03227: }
03228: } finally {
03229: if (jjtc000) {
03230: jjtree.closeNodeScope(jjtn000, true);
03231: jjtreeCloseNodeScope(jjtn000);
03232: }
03233: }
03234: }
03235:
03236: final public void InstanceOfExpression() throws ParseException {
03237: /*@bgen(jjtree) InstanceOfExpression */
03238: SimpleNode jjtn000 = new SimpleNode(JJTINSTANCEOFEXPRESSION);
03239: boolean jjtc000 = true;
03240: jjtree.openNodeScope(jjtn000);
03241: jjtreeOpenNodeScope(jjtn000);
03242: try {
03243: RelationalExpression();
03244: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03245: case INSTANCEOF:
03246: jj_consume_token(INSTANCEOF);
03247: Type();
03248: break;
03249: default:
03250: ;
03251: }
03252: } catch (Throwable jjte000) {
03253: if (jjtc000) {
03254: jjtree.clearNodeScope(jjtn000);
03255: jjtc000 = false;
03256: } else {
03257: jjtree.popNode();
03258: }
03259: if (jjte000 instanceof RuntimeException) {
03260: {
03261: if (true)
03262: throw (RuntimeException) jjte000;
03263: }
03264: }
03265: if (jjte000 instanceof ParseException) {
03266: {
03267: if (true)
03268: throw (ParseException) jjte000;
03269: }
03270: }
03271: {
03272: if (true)
03273: throw (Error) jjte000;
03274: }
03275: } finally {
03276: if (jjtc000) {
03277: jjtree.closeNodeScope(jjtn000, true);
03278: jjtreeCloseNodeScope(jjtn000);
03279: }
03280: }
03281: }
03282:
03283: final public void RelationalExpression() throws ParseException {
03284: /*@bgen(jjtree) RelationalExpression */
03285: SimpleNode jjtn000 = new SimpleNode(JJTRELATIONALEXPRESSION);
03286: boolean jjtc000 = true;
03287: jjtree.openNodeScope(jjtn000);
03288: jjtreeOpenNodeScope(jjtn000);
03289: try {
03290: ShiftExpression();
03291: label_30: while (true) {
03292: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03293: case LT:
03294: case LE:
03295: case GE:
03296: case GT:
03297: ;
03298: break;
03299: default:
03300: break label_30;
03301: }
03302: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03303: case LT:
03304: jj_consume_token(LT);
03305: break;
03306: case GT:
03307: jj_consume_token(GT);
03308: break;
03309: case LE:
03310: jj_consume_token(LE);
03311: break;
03312: case GE:
03313: jj_consume_token(GE);
03314: break;
03315: default:
03316: jj_consume_token(-1);
03317: throw new ParseException();
03318: }
03319: ShiftExpression();
03320: }
03321: } catch (Throwable jjte000) {
03322: if (jjtc000) {
03323: jjtree.clearNodeScope(jjtn000);
03324: jjtc000 = false;
03325: } else {
03326: jjtree.popNode();
03327: }
03328: if (jjte000 instanceof RuntimeException) {
03329: {
03330: if (true)
03331: throw (RuntimeException) jjte000;
03332: }
03333: }
03334: if (jjte000 instanceof ParseException) {
03335: {
03336: if (true)
03337: throw (ParseException) jjte000;
03338: }
03339: }
03340: {
03341: if (true)
03342: throw (Error) jjte000;
03343: }
03344: } finally {
03345: if (jjtc000) {
03346: jjtree.closeNodeScope(jjtn000, true);
03347: jjtreeCloseNodeScope(jjtn000);
03348: }
03349: }
03350: }
03351:
03352: final public void ShiftExpression() throws ParseException {
03353: /*@bgen(jjtree) ShiftExpression */
03354: SimpleNode jjtn000 = new SimpleNode(JJTSHIFTEXPRESSION);
03355: boolean jjtc000 = true;
03356: jjtree.openNodeScope(jjtn000);
03357: jjtreeOpenNodeScope(jjtn000);
03358: try {
03359: AdditiveExpression();
03360: label_31: while (true) {
03361: if (jj_2_22(1)) {
03362: ;
03363: } else {
03364: break label_31;
03365: }
03366: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03367: case LSHIFT:
03368: jj_consume_token(LSHIFT);
03369: break;
03370: default:
03371: if (jj_2_23(1)) {
03372: RSIGNEDSHIFT();
03373: } else if (jj_2_24(1)) {
03374: RUNSIGNEDSHIFT();
03375: } else {
03376: jj_consume_token(-1);
03377: throw new ParseException();
03378: }
03379: }
03380: AdditiveExpression();
03381: }
03382: } catch (Throwable jjte000) {
03383: if (jjtc000) {
03384: jjtree.clearNodeScope(jjtn000);
03385: jjtc000 = false;
03386: } else {
03387: jjtree.popNode();
03388: }
03389: if (jjte000 instanceof RuntimeException) {
03390: {
03391: if (true)
03392: throw (RuntimeException) jjte000;
03393: }
03394: }
03395: if (jjte000 instanceof ParseException) {
03396: {
03397: if (true)
03398: throw (ParseException) jjte000;
03399: }
03400: }
03401: {
03402: if (true)
03403: throw (Error) jjte000;
03404: }
03405: } finally {
03406: if (jjtc000) {
03407: jjtree.closeNodeScope(jjtn000, true);
03408: jjtreeCloseNodeScope(jjtn000);
03409: }
03410: }
03411: }
03412:
03413: final public void AdditiveExpression() throws ParseException {
03414: /*@bgen(jjtree) AdditiveExpression */
03415: SimpleNode jjtn000 = new SimpleNode(JJTADDITIVEEXPRESSION);
03416: boolean jjtc000 = true;
03417: jjtree.openNodeScope(jjtn000);
03418: jjtreeOpenNodeScope(jjtn000);
03419: try {
03420: MultiplicativeExpression();
03421: label_32: while (true) {
03422: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03423: case PLUS:
03424: case MINUS:
03425: ;
03426: break;
03427: default:
03428: break label_32;
03429: }
03430: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03431: case PLUS:
03432: jj_consume_token(PLUS);
03433: break;
03434: case MINUS:
03435: jj_consume_token(MINUS);
03436: break;
03437: default:
03438: jj_consume_token(-1);
03439: throw new ParseException();
03440: }
03441: MultiplicativeExpression();
03442: }
03443: } catch (Throwable jjte000) {
03444: if (jjtc000) {
03445: jjtree.clearNodeScope(jjtn000);
03446: jjtc000 = false;
03447: } else {
03448: jjtree.popNode();
03449: }
03450: if (jjte000 instanceof RuntimeException) {
03451: {
03452: if (true)
03453: throw (RuntimeException) jjte000;
03454: }
03455: }
03456: if (jjte000 instanceof ParseException) {
03457: {
03458: if (true)
03459: throw (ParseException) jjte000;
03460: }
03461: }
03462: {
03463: if (true)
03464: throw (Error) jjte000;
03465: }
03466: } finally {
03467: if (jjtc000) {
03468: jjtree.closeNodeScope(jjtn000, true);
03469: jjtreeCloseNodeScope(jjtn000);
03470: }
03471: }
03472: }
03473:
03474: final public void MultiplicativeExpression() throws ParseException {
03475: /*@bgen(jjtree) MultiplicativeExpression */
03476: SimpleNode jjtn000 = new SimpleNode(JJTMULTIPLICATIVEEXPRESSION);
03477: boolean jjtc000 = true;
03478: jjtree.openNodeScope(jjtn000);
03479: jjtreeOpenNodeScope(jjtn000);
03480: try {
03481: UnaryExpression();
03482: label_33: while (true) {
03483: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03484: case STAR:
03485: case SLASH:
03486: case REM:
03487: ;
03488: break;
03489: default:
03490: break label_33;
03491: }
03492: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03493: case STAR:
03494: jj_consume_token(STAR);
03495: break;
03496: case SLASH:
03497: jj_consume_token(SLASH);
03498: break;
03499: case REM:
03500: jj_consume_token(REM);
03501: break;
03502: default:
03503: jj_consume_token(-1);
03504: throw new ParseException();
03505: }
03506: UnaryExpression();
03507: }
03508: } catch (Throwable jjte000) {
03509: if (jjtc000) {
03510: jjtree.clearNodeScope(jjtn000);
03511: jjtc000 = false;
03512: } else {
03513: jjtree.popNode();
03514: }
03515: if (jjte000 instanceof RuntimeException) {
03516: {
03517: if (true)
03518: throw (RuntimeException) jjte000;
03519: }
03520: }
03521: if (jjte000 instanceof ParseException) {
03522: {
03523: if (true)
03524: throw (ParseException) jjte000;
03525: }
03526: }
03527: {
03528: if (true)
03529: throw (Error) jjte000;
03530: }
03531: } finally {
03532: if (jjtc000) {
03533: jjtree.closeNodeScope(jjtn000, true);
03534: jjtreeCloseNodeScope(jjtn000);
03535: }
03536: }
03537: }
03538:
03539: final public void UnaryExpression() throws ParseException {
03540: /*@bgen(jjtree) UnaryExpression */
03541: SimpleNode jjtn000 = new SimpleNode(JJTUNARYEXPRESSION);
03542: boolean jjtc000 = true;
03543: jjtree.openNodeScope(jjtn000);
03544: jjtreeOpenNodeScope(jjtn000);
03545: try {
03546: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03547: case PLUS:
03548: case MINUS:
03549: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03550: case PLUS:
03551: jj_consume_token(PLUS);
03552: break;
03553: case MINUS:
03554: jj_consume_token(MINUS);
03555: break;
03556: default:
03557: jj_consume_token(-1);
03558: throw new ParseException();
03559: }
03560: UnaryExpression();
03561: break;
03562: case INCR:
03563: PreIncrementExpression();
03564: break;
03565: case DECR:
03566: PreDecrementExpression();
03567: break;
03568: case BOOLEAN:
03569: case BYTE:
03570: case CHAR:
03571: case DOUBLE:
03572: case FALSE:
03573: case FLOAT:
03574: case INT:
03575: case LONG:
03576: case NEW:
03577: case NULL:
03578: case SHORT:
03579: case SUPER:
03580: case THIS:
03581: case TRUE:
03582: case VOID:
03583: case INTEGER_LITERAL:
03584: case FLOATING_POINT_LITERAL:
03585: case CHARACTER_LITERAL:
03586: case STRING_LITERAL:
03587: case IDENTIFIER:
03588: case LPAREN:
03589: case BANG:
03590: case TILDE:
03591: UnaryExpressionNotPlusMinus();
03592: break;
03593: default:
03594: jj_consume_token(-1);
03595: throw new ParseException();
03596: }
03597: } catch (Throwable jjte000) {
03598: if (jjtc000) {
03599: jjtree.clearNodeScope(jjtn000);
03600: jjtc000 = false;
03601: } else {
03602: jjtree.popNode();
03603: }
03604: if (jjte000 instanceof RuntimeException) {
03605: {
03606: if (true)
03607: throw (RuntimeException) jjte000;
03608: }
03609: }
03610: if (jjte000 instanceof ParseException) {
03611: {
03612: if (true)
03613: throw (ParseException) jjte000;
03614: }
03615: }
03616: {
03617: if (true)
03618: throw (Error) jjte000;
03619: }
03620: } finally {
03621: if (jjtc000) {
03622: jjtree.closeNodeScope(jjtn000, true);
03623: jjtreeCloseNodeScope(jjtn000);
03624: }
03625: }
03626: }
03627:
03628: final public void PreIncrementExpression() throws ParseException {
03629: /*@bgen(jjtree) PreIncrementExpression */
03630: SimpleNode jjtn000 = new SimpleNode(JJTPREINCREMENTEXPRESSION);
03631: boolean jjtc000 = true;
03632: jjtree.openNodeScope(jjtn000);
03633: jjtreeOpenNodeScope(jjtn000);
03634: try {
03635: jj_consume_token(INCR);
03636: PrimaryExpression();
03637: } catch (Throwable jjte000) {
03638: if (jjtc000) {
03639: jjtree.clearNodeScope(jjtn000);
03640: jjtc000 = false;
03641: } else {
03642: jjtree.popNode();
03643: }
03644: if (jjte000 instanceof RuntimeException) {
03645: {
03646: if (true)
03647: throw (RuntimeException) jjte000;
03648: }
03649: }
03650: if (jjte000 instanceof ParseException) {
03651: {
03652: if (true)
03653: throw (ParseException) jjte000;
03654: }
03655: }
03656: {
03657: if (true)
03658: throw (Error) jjte000;
03659: }
03660: } finally {
03661: if (jjtc000) {
03662: jjtree.closeNodeScope(jjtn000, true);
03663: jjtreeCloseNodeScope(jjtn000);
03664: }
03665: }
03666: }
03667:
03668: final public void PreDecrementExpression() throws ParseException {
03669: /*@bgen(jjtree) PreDecrementExpression */
03670: SimpleNode jjtn000 = new SimpleNode(JJTPREDECREMENTEXPRESSION);
03671: boolean jjtc000 = true;
03672: jjtree.openNodeScope(jjtn000);
03673: jjtreeOpenNodeScope(jjtn000);
03674: try {
03675: jj_consume_token(DECR);
03676: PrimaryExpression();
03677: } catch (Throwable jjte000) {
03678: if (jjtc000) {
03679: jjtree.clearNodeScope(jjtn000);
03680: jjtc000 = false;
03681: } else {
03682: jjtree.popNode();
03683: }
03684: if (jjte000 instanceof RuntimeException) {
03685: {
03686: if (true)
03687: throw (RuntimeException) jjte000;
03688: }
03689: }
03690: if (jjte000 instanceof ParseException) {
03691: {
03692: if (true)
03693: throw (ParseException) jjte000;
03694: }
03695: }
03696: {
03697: if (true)
03698: throw (Error) jjte000;
03699: }
03700: } finally {
03701: if (jjtc000) {
03702: jjtree.closeNodeScope(jjtn000, true);
03703: jjtreeCloseNodeScope(jjtn000);
03704: }
03705: }
03706: }
03707:
03708: final public void UnaryExpressionNotPlusMinus()
03709: throws ParseException {
03710: /*@bgen(jjtree) UnaryExpressionNotPlusMinus */
03711: SimpleNode jjtn000 = new SimpleNode(
03712: JJTUNARYEXPRESSIONNOTPLUSMINUS);
03713: boolean jjtc000 = true;
03714: jjtree.openNodeScope(jjtn000);
03715: jjtreeOpenNodeScope(jjtn000);
03716: try {
03717: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03718: case BANG:
03719: case TILDE:
03720: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03721: case TILDE:
03722: jj_consume_token(TILDE);
03723: break;
03724: case BANG:
03725: jj_consume_token(BANG);
03726: break;
03727: default:
03728: jj_consume_token(-1);
03729: throw new ParseException();
03730: }
03731: UnaryExpression();
03732: break;
03733: default:
03734: if (jj_2_25(2147483647)) {
03735: CastExpression();
03736: } else {
03737: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03738: case BOOLEAN:
03739: case BYTE:
03740: case CHAR:
03741: case DOUBLE:
03742: case FALSE:
03743: case FLOAT:
03744: case INT:
03745: case LONG:
03746: case NEW:
03747: case NULL:
03748: case SHORT:
03749: case SUPER:
03750: case THIS:
03751: case TRUE:
03752: case VOID:
03753: case INTEGER_LITERAL:
03754: case FLOATING_POINT_LITERAL:
03755: case CHARACTER_LITERAL:
03756: case STRING_LITERAL:
03757: case IDENTIFIER:
03758: case LPAREN:
03759: PostfixExpression();
03760: break;
03761: default:
03762: jj_consume_token(-1);
03763: throw new ParseException();
03764: }
03765: }
03766: }
03767: } catch (Throwable jjte000) {
03768: if (jjtc000) {
03769: jjtree.clearNodeScope(jjtn000);
03770: jjtc000 = false;
03771: } else {
03772: jjtree.popNode();
03773: }
03774: if (jjte000 instanceof RuntimeException) {
03775: {
03776: if (true)
03777: throw (RuntimeException) jjte000;
03778: }
03779: }
03780: if (jjte000 instanceof ParseException) {
03781: {
03782: if (true)
03783: throw (ParseException) jjte000;
03784: }
03785: }
03786: {
03787: if (true)
03788: throw (Error) jjte000;
03789: }
03790: } finally {
03791: if (jjtc000) {
03792: jjtree.closeNodeScope(jjtn000, true);
03793: jjtreeCloseNodeScope(jjtn000);
03794: }
03795: }
03796: }
03797:
03798: // This production is to determine lookahead only. The LOOKAHEAD specifications
03799: // below are not used, but they are there just to indicate that we know about
03800: // this.
03801: final public void CastLookahead() throws ParseException {
03802: /*@bgen(jjtree) CastLookahead */
03803: SimpleNode jjtn000 = new SimpleNode(JJTCASTLOOKAHEAD);
03804: boolean jjtc000 = true;
03805: jjtree.openNodeScope(jjtn000);
03806: jjtreeOpenNodeScope(jjtn000);
03807: try {
03808: if (jj_2_26(2)) {
03809: jj_consume_token(LPAREN);
03810: PrimitiveType();
03811: } else if (jj_2_27(2147483647)) {
03812: jj_consume_token(LPAREN);
03813: Type();
03814: jj_consume_token(LBRACKET);
03815: jj_consume_token(RBRACKET);
03816: } else {
03817: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03818: case LPAREN:
03819: jj_consume_token(LPAREN);
03820: Type();
03821: jj_consume_token(RPAREN);
03822: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03823: case TILDE:
03824: jj_consume_token(TILDE);
03825: break;
03826: case BANG:
03827: jj_consume_token(BANG);
03828: break;
03829: case LPAREN:
03830: jj_consume_token(LPAREN);
03831: break;
03832: case IDENTIFIER:
03833: jj_consume_token(IDENTIFIER);
03834: break;
03835: case THIS:
03836: jj_consume_token(THIS);
03837: break;
03838: case SUPER:
03839: jj_consume_token(SUPER);
03840: break;
03841: case NEW:
03842: jj_consume_token(NEW);
03843: break;
03844: case FALSE:
03845: case NULL:
03846: case TRUE:
03847: case INTEGER_LITERAL:
03848: case FLOATING_POINT_LITERAL:
03849: case CHARACTER_LITERAL:
03850: case STRING_LITERAL:
03851: Literal();
03852: break;
03853: default:
03854: jj_consume_token(-1);
03855: throw new ParseException();
03856: }
03857: break;
03858: default:
03859: jj_consume_token(-1);
03860: throw new ParseException();
03861: }
03862: }
03863: } catch (Throwable jjte000) {
03864: if (jjtc000) {
03865: jjtree.clearNodeScope(jjtn000);
03866: jjtc000 = false;
03867: } else {
03868: jjtree.popNode();
03869: }
03870: if (jjte000 instanceof RuntimeException) {
03871: {
03872: if (true)
03873: throw (RuntimeException) jjte000;
03874: }
03875: }
03876: if (jjte000 instanceof ParseException) {
03877: {
03878: if (true)
03879: throw (ParseException) jjte000;
03880: }
03881: }
03882: {
03883: if (true)
03884: throw (Error) jjte000;
03885: }
03886: } finally {
03887: if (jjtc000) {
03888: jjtree.closeNodeScope(jjtn000, true);
03889: jjtreeCloseNodeScope(jjtn000);
03890: }
03891: }
03892: }
03893:
03894: final public void PostfixExpression() throws ParseException {
03895: /*@bgen(jjtree) PostfixExpression */
03896: SimpleNode jjtn000 = new SimpleNode(JJTPOSTFIXEXPRESSION);
03897: boolean jjtc000 = true;
03898: jjtree.openNodeScope(jjtn000);
03899: jjtreeOpenNodeScope(jjtn000);
03900: try {
03901: PrimaryExpression();
03902: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03903: case INCR:
03904: case DECR:
03905: PostfixOperator();
03906: break;
03907: default:
03908: ;
03909: }
03910: } catch (Throwable jjte000) {
03911: if (jjtc000) {
03912: jjtree.clearNodeScope(jjtn000);
03913: jjtc000 = false;
03914: } else {
03915: jjtree.popNode();
03916: }
03917: if (jjte000 instanceof RuntimeException) {
03918: {
03919: if (true)
03920: throw (RuntimeException) jjte000;
03921: }
03922: }
03923: if (jjte000 instanceof ParseException) {
03924: {
03925: if (true)
03926: throw (ParseException) jjte000;
03927: }
03928: }
03929: {
03930: if (true)
03931: throw (Error) jjte000;
03932: }
03933: } finally {
03934: if (jjtc000) {
03935: jjtree.closeNodeScope(jjtn000, true);
03936: jjtreeCloseNodeScope(jjtn000);
03937: }
03938: }
03939: }
03940:
03941: final public void PostfixOperator() throws ParseException {
03942: /*@bgen(jjtree) PostfixOperator */
03943: SimpleNode jjtn000 = new SimpleNode(JJTPOSTFIXOPERATOR);
03944: boolean jjtc000 = true;
03945: jjtree.openNodeScope(jjtn000);
03946: jjtreeOpenNodeScope(jjtn000);
03947: try {
03948: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03949: case INCR:
03950: jj_consume_token(INCR);
03951: break;
03952: case DECR:
03953: jj_consume_token(DECR);
03954: break;
03955: default:
03956: jj_consume_token(-1);
03957: throw new ParseException();
03958: }
03959: } finally {
03960: if (jjtc000) {
03961: jjtree.closeNodeScope(jjtn000, true);
03962: jjtreeCloseNodeScope(jjtn000);
03963: }
03964: }
03965: }
03966:
03967: final public void CastExpression() throws ParseException {
03968: /*@bgen(jjtree) CastExpression */
03969: SimpleNode jjtn000 = new SimpleNode(JJTCASTEXPRESSION);
03970: boolean jjtc000 = true;
03971: jjtree.openNodeScope(jjtn000);
03972: jjtreeOpenNodeScope(jjtn000);
03973: try {
03974: if (jj_2_28(2147483647)) {
03975: jj_consume_token(LPAREN);
03976: Type();
03977: jj_consume_token(RPAREN);
03978: UnaryExpression();
03979: } else {
03980: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
03981: case LPAREN:
03982: jj_consume_token(LPAREN);
03983: Type();
03984: jj_consume_token(RPAREN);
03985: UnaryExpressionNotPlusMinus();
03986: break;
03987: default:
03988: jj_consume_token(-1);
03989: throw new ParseException();
03990: }
03991: }
03992: } catch (Throwable jjte000) {
03993: if (jjtc000) {
03994: jjtree.clearNodeScope(jjtn000);
03995: jjtc000 = false;
03996: } else {
03997: jjtree.popNode();
03998: }
03999: if (jjte000 instanceof RuntimeException) {
04000: {
04001: if (true)
04002: throw (RuntimeException) jjte000;
04003: }
04004: }
04005: if (jjte000 instanceof ParseException) {
04006: {
04007: if (true)
04008: throw (ParseException) jjte000;
04009: }
04010: }
04011: {
04012: if (true)
04013: throw (Error) jjte000;
04014: }
04015: } finally {
04016: if (jjtc000) {
04017: jjtree.closeNodeScope(jjtn000, true);
04018: jjtreeCloseNodeScope(jjtn000);
04019: }
04020: }
04021: }
04022:
04023: final public void PrimaryExpression() throws ParseException {
04024: /*@bgen(jjtree) PrimaryExpression */
04025: SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYEXPRESSION);
04026: boolean jjtc000 = true;
04027: jjtree.openNodeScope(jjtn000);
04028: jjtreeOpenNodeScope(jjtn000);
04029: try {
04030: PrimaryPrefix();
04031: label_34: while (true) {
04032: if (jj_2_29(2)) {
04033: ;
04034: } else {
04035: break label_34;
04036: }
04037: PrimarySuffix();
04038: }
04039: } catch (Throwable jjte000) {
04040: if (jjtc000) {
04041: jjtree.clearNodeScope(jjtn000);
04042: jjtc000 = false;
04043: } else {
04044: jjtree.popNode();
04045: }
04046: if (jjte000 instanceof RuntimeException) {
04047: {
04048: if (true)
04049: throw (RuntimeException) jjte000;
04050: }
04051: }
04052: if (jjte000 instanceof ParseException) {
04053: {
04054: if (true)
04055: throw (ParseException) jjte000;
04056: }
04057: }
04058: {
04059: if (true)
04060: throw (Error) jjte000;
04061: }
04062: } finally {
04063: if (jjtc000) {
04064: jjtree.closeNodeScope(jjtn000, true);
04065: jjtreeCloseNodeScope(jjtn000);
04066: }
04067: }
04068: }
04069:
04070: final public void MemberSelector() throws ParseException {
04071: /*@bgen(jjtree) MemberSelector */
04072: SimpleNode jjtn000 = new SimpleNode(JJTMEMBERSELECTOR);
04073: boolean jjtc000 = true;
04074: jjtree.openNodeScope(jjtn000);
04075: jjtreeOpenNodeScope(jjtn000);
04076: try {
04077: jj_consume_token(DOT);
04078: TypeArguments();
04079: jj_consume_token(IDENTIFIER);
04080: } catch (Throwable jjte000) {
04081: if (jjtc000) {
04082: jjtree.clearNodeScope(jjtn000);
04083: jjtc000 = false;
04084: } else {
04085: jjtree.popNode();
04086: }
04087: if (jjte000 instanceof RuntimeException) {
04088: {
04089: if (true)
04090: throw (RuntimeException) jjte000;
04091: }
04092: }
04093: if (jjte000 instanceof ParseException) {
04094: {
04095: if (true)
04096: throw (ParseException) jjte000;
04097: }
04098: }
04099: {
04100: if (true)
04101: throw (Error) jjte000;
04102: }
04103: } finally {
04104: if (jjtc000) {
04105: jjtree.closeNodeScope(jjtn000, true);
04106: jjtreeCloseNodeScope(jjtn000);
04107: }
04108: }
04109: }
04110:
04111: final public void PrimaryPrefix() throws ParseException {
04112: /*@bgen(jjtree) PrimaryPrefix */
04113: SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYPREFIX);
04114: boolean jjtc000 = true;
04115: jjtree.openNodeScope(jjtn000);
04116: jjtreeOpenNodeScope(jjtn000);
04117: try {
04118: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04119: case FALSE:
04120: case NULL:
04121: case TRUE:
04122: case INTEGER_LITERAL:
04123: case FLOATING_POINT_LITERAL:
04124: case CHARACTER_LITERAL:
04125: case STRING_LITERAL:
04126: Literal();
04127: break;
04128: default:
04129: if (jj_2_30(2147483647)) {
04130: label_35: while (true) {
04131: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04132: case IDENTIFIER:
04133: ;
04134: break;
04135: default:
04136: break label_35;
04137: }
04138: jj_consume_token(IDENTIFIER);
04139: jj_consume_token(DOT);
04140: }
04141: jj_consume_token(THIS);
04142: } else {
04143: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04144: case SUPER:
04145: jj_consume_token(SUPER);
04146: jj_consume_token(DOT);
04147: jj_consume_token(IDENTIFIER);
04148: break;
04149: case LPAREN:
04150: jj_consume_token(LPAREN);
04151: Expression();
04152: jj_consume_token(RPAREN);
04153: break;
04154: case NEW:
04155: AllocationExpression();
04156: break;
04157: default:
04158: if (jj_2_31(2147483647)) {
04159: ResultType();
04160: jj_consume_token(DOT);
04161: jj_consume_token(CLASS);
04162: } else {
04163: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04164: case IDENTIFIER:
04165: Name();
04166: break;
04167: default:
04168: jj_consume_token(-1);
04169: throw new ParseException();
04170: }
04171: }
04172: }
04173: }
04174: }
04175: } catch (Throwable jjte000) {
04176: if (jjtc000) {
04177: jjtree.clearNodeScope(jjtn000);
04178: jjtc000 = false;
04179: } else {
04180: jjtree.popNode();
04181: }
04182: if (jjte000 instanceof RuntimeException) {
04183: {
04184: if (true)
04185: throw (RuntimeException) jjte000;
04186: }
04187: }
04188: if (jjte000 instanceof ParseException) {
04189: {
04190: if (true)
04191: throw (ParseException) jjte000;
04192: }
04193: }
04194: {
04195: if (true)
04196: throw (Error) jjte000;
04197: }
04198: } finally {
04199: if (jjtc000) {
04200: jjtree.closeNodeScope(jjtn000, true);
04201: jjtreeCloseNodeScope(jjtn000);
04202: }
04203: }
04204: }
04205:
04206: final public void PrimarySuffix() throws ParseException {
04207: /*@bgen(jjtree) PrimarySuffix */
04208: SimpleNode jjtn000 = new SimpleNode(JJTPRIMARYSUFFIX);
04209: boolean jjtc000 = true;
04210: jjtree.openNodeScope(jjtn000);
04211: jjtreeOpenNodeScope(jjtn000);
04212: try {
04213: if (jj_2_32(2147483647)) {
04214: jj_consume_token(DOT);
04215: jj_consume_token(SUPER);
04216: } else if (jj_2_33(2147483647)) {
04217: jj_consume_token(DOT);
04218: jj_consume_token(THIS);
04219: } else if (jj_2_34(2)) {
04220: jj_consume_token(DOT);
04221: AllocationExpression();
04222: } else if (jj_2_35(3)) {
04223: MemberSelector();
04224: } else {
04225: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04226: case LBRACKET:
04227: jj_consume_token(LBRACKET);
04228: Expression();
04229: jj_consume_token(RBRACKET);
04230: break;
04231: case DOT:
04232: jj_consume_token(DOT);
04233: jj_consume_token(IDENTIFIER);
04234: break;
04235: case LPAREN:
04236: Arguments();
04237: break;
04238: default:
04239: jj_consume_token(-1);
04240: throw new ParseException();
04241: }
04242: }
04243: } catch (Throwable jjte000) {
04244: if (jjtc000) {
04245: jjtree.clearNodeScope(jjtn000);
04246: jjtc000 = false;
04247: } else {
04248: jjtree.popNode();
04249: }
04250: if (jjte000 instanceof RuntimeException) {
04251: {
04252: if (true)
04253: throw (RuntimeException) jjte000;
04254: }
04255: }
04256: if (jjte000 instanceof ParseException) {
04257: {
04258: if (true)
04259: throw (ParseException) jjte000;
04260: }
04261: }
04262: {
04263: if (true)
04264: throw (Error) jjte000;
04265: }
04266: } finally {
04267: if (jjtc000) {
04268: jjtree.closeNodeScope(jjtn000, true);
04269: jjtreeCloseNodeScope(jjtn000);
04270: }
04271: }
04272: }
04273:
04274: final public void Literal() throws ParseException {
04275: /*@bgen(jjtree) Literal */
04276: SimpleNode jjtn000 = new SimpleNode(JJTLITERAL);
04277: boolean jjtc000 = true;
04278: jjtree.openNodeScope(jjtn000);
04279: jjtreeOpenNodeScope(jjtn000);
04280: try {
04281: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04282: case INTEGER_LITERAL:
04283: jj_consume_token(INTEGER_LITERAL);
04284: break;
04285: case FLOATING_POINT_LITERAL:
04286: jj_consume_token(FLOATING_POINT_LITERAL);
04287: break;
04288: case CHARACTER_LITERAL:
04289: jj_consume_token(CHARACTER_LITERAL);
04290: break;
04291: case STRING_LITERAL:
04292: jj_consume_token(STRING_LITERAL);
04293: break;
04294: case FALSE:
04295: case TRUE:
04296: BooleanLiteral();
04297: break;
04298: case NULL:
04299: NullLiteral();
04300: break;
04301: default:
04302: jj_consume_token(-1);
04303: throw new ParseException();
04304: }
04305: } catch (Throwable jjte000) {
04306: if (jjtc000) {
04307: jjtree.clearNodeScope(jjtn000);
04308: jjtc000 = false;
04309: } else {
04310: jjtree.popNode();
04311: }
04312: if (jjte000 instanceof RuntimeException) {
04313: {
04314: if (true)
04315: throw (RuntimeException) jjte000;
04316: }
04317: }
04318: if (jjte000 instanceof ParseException) {
04319: {
04320: if (true)
04321: throw (ParseException) jjte000;
04322: }
04323: }
04324: {
04325: if (true)
04326: throw (Error) jjte000;
04327: }
04328: } finally {
04329: if (jjtc000) {
04330: jjtree.closeNodeScope(jjtn000, true);
04331: jjtreeCloseNodeScope(jjtn000);
04332: }
04333: }
04334: }
04335:
04336: final public void BooleanLiteral() throws ParseException {
04337: /*@bgen(jjtree) BooleanLiteral */
04338: SimpleNode jjtn000 = new SimpleNode(JJTBOOLEANLITERAL);
04339: boolean jjtc000 = true;
04340: jjtree.openNodeScope(jjtn000);
04341: jjtreeOpenNodeScope(jjtn000);
04342: try {
04343: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04344: case TRUE:
04345: jj_consume_token(TRUE);
04346: break;
04347: case FALSE:
04348: jj_consume_token(FALSE);
04349: break;
04350: default:
04351: jj_consume_token(-1);
04352: throw new ParseException();
04353: }
04354: } finally {
04355: if (jjtc000) {
04356: jjtree.closeNodeScope(jjtn000, true);
04357: jjtreeCloseNodeScope(jjtn000);
04358: }
04359: }
04360: }
04361:
04362: final public void NullLiteral() throws ParseException {
04363: /*@bgen(jjtree) NullLiteral */
04364: SimpleNode jjtn000 = new SimpleNode(JJTNULLLITERAL);
04365: boolean jjtc000 = true;
04366: jjtree.openNodeScope(jjtn000);
04367: jjtreeOpenNodeScope(jjtn000);
04368: try {
04369: jj_consume_token(NULL);
04370: } finally {
04371: if (jjtc000) {
04372: jjtree.closeNodeScope(jjtn000, true);
04373: jjtreeCloseNodeScope(jjtn000);
04374: }
04375: }
04376: }
04377:
04378: final public void Arguments() throws ParseException {
04379: /*@bgen(jjtree) Arguments */
04380: SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTS);
04381: boolean jjtc000 = true;
04382: jjtree.openNodeScope(jjtn000);
04383: jjtreeOpenNodeScope(jjtn000);
04384: try {
04385: jj_consume_token(LPAREN);
04386: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04387: case BOOLEAN:
04388: case BYTE:
04389: case CHAR:
04390: case DOUBLE:
04391: case FALSE:
04392: case FLOAT:
04393: case INT:
04394: case LONG:
04395: case NEW:
04396: case NULL:
04397: case SHORT:
04398: case SUPER:
04399: case THIS:
04400: case TRUE:
04401: case VOID:
04402: case INTEGER_LITERAL:
04403: case FLOATING_POINT_LITERAL:
04404: case CHARACTER_LITERAL:
04405: case STRING_LITERAL:
04406: case IDENTIFIER:
04407: case LPAREN:
04408: case BANG:
04409: case TILDE:
04410: case INCR:
04411: case DECR:
04412: case PLUS:
04413: case MINUS:
04414: ArgumentList();
04415: break;
04416: default:
04417: ;
04418: }
04419: jj_consume_token(RPAREN);
04420: } catch (Throwable jjte000) {
04421: if (jjtc000) {
04422: jjtree.clearNodeScope(jjtn000);
04423: jjtc000 = false;
04424: } else {
04425: jjtree.popNode();
04426: }
04427: if (jjte000 instanceof RuntimeException) {
04428: {
04429: if (true)
04430: throw (RuntimeException) jjte000;
04431: }
04432: }
04433: if (jjte000 instanceof ParseException) {
04434: {
04435: if (true)
04436: throw (ParseException) jjte000;
04437: }
04438: }
04439: {
04440: if (true)
04441: throw (Error) jjte000;
04442: }
04443: } finally {
04444: if (jjtc000) {
04445: jjtree.closeNodeScope(jjtn000, true);
04446: jjtreeCloseNodeScope(jjtn000);
04447: }
04448: }
04449: }
04450:
04451: final public void ArgumentList() throws ParseException {
04452: /*@bgen(jjtree) ArgumentList */
04453: SimpleNode jjtn000 = new SimpleNode(JJTARGUMENTLIST);
04454: boolean jjtc000 = true;
04455: jjtree.openNodeScope(jjtn000);
04456: jjtreeOpenNodeScope(jjtn000);
04457: try {
04458: Expression();
04459: label_36: while (true) {
04460: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04461: case COMMA:
04462: ;
04463: break;
04464: default:
04465: break label_36;
04466: }
04467: jj_consume_token(COMMA);
04468: Expression();
04469: }
04470: } catch (Throwable jjte000) {
04471: if (jjtc000) {
04472: jjtree.clearNodeScope(jjtn000);
04473: jjtc000 = false;
04474: } else {
04475: jjtree.popNode();
04476: }
04477: if (jjte000 instanceof RuntimeException) {
04478: {
04479: if (true)
04480: throw (RuntimeException) jjte000;
04481: }
04482: }
04483: if (jjte000 instanceof ParseException) {
04484: {
04485: if (true)
04486: throw (ParseException) jjte000;
04487: }
04488: }
04489: {
04490: if (true)
04491: throw (Error) jjte000;
04492: }
04493: } finally {
04494: if (jjtc000) {
04495: jjtree.closeNodeScope(jjtn000, true);
04496: jjtreeCloseNodeScope(jjtn000);
04497: }
04498: }
04499: }
04500:
04501: final public void AllocationExpression() throws ParseException {
04502: /*@bgen(jjtree) AllocationExpression */
04503: SimpleNode jjtn000 = new SimpleNode(JJTALLOCATIONEXPRESSION);
04504: boolean jjtc000 = true;
04505: jjtree.openNodeScope(jjtn000);
04506: jjtreeOpenNodeScope(jjtn000);
04507: try {
04508: if (jj_2_36(2)) {
04509: jj_consume_token(NEW);
04510: PrimitiveType();
04511: ArrayDimsAndInits();
04512: } else {
04513: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04514: case NEW:
04515: jj_consume_token(NEW);
04516: ClassOrInterfaceType();
04517: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04518: case LT:
04519: TypeArguments();
04520: break;
04521: default:
04522: ;
04523: }
04524: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04525: case LBRACKET:
04526: ArrayDimsAndInits();
04527: break;
04528: case LPAREN:
04529: Arguments();
04530: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04531: case LBRACE:
04532: ClassOrInterfaceBody(false);
04533: break;
04534: default:
04535: ;
04536: }
04537: break;
04538: default:
04539: jj_consume_token(-1);
04540: throw new ParseException();
04541: }
04542: break;
04543: default:
04544: jj_consume_token(-1);
04545: throw new ParseException();
04546: }
04547: }
04548: } catch (Throwable jjte000) {
04549: if (jjtc000) {
04550: jjtree.clearNodeScope(jjtn000);
04551: jjtc000 = false;
04552: } else {
04553: jjtree.popNode();
04554: }
04555: if (jjte000 instanceof RuntimeException) {
04556: {
04557: if (true)
04558: throw (RuntimeException) jjte000;
04559: }
04560: }
04561: if (jjte000 instanceof ParseException) {
04562: {
04563: if (true)
04564: throw (ParseException) jjte000;
04565: }
04566: }
04567: {
04568: if (true)
04569: throw (Error) jjte000;
04570: }
04571: } finally {
04572: if (jjtc000) {
04573: jjtree.closeNodeScope(jjtn000, true);
04574: jjtreeCloseNodeScope(jjtn000);
04575: }
04576: }
04577: }
04578:
04579: /*
04580: * The third LOOKAHEAD specification below is to parse to PrimarySuffix
04581: * if there is an expression between the "[...]".
04582: */
04583: final public void ArrayDimsAndInits() throws ParseException {
04584: /*@bgen(jjtree) ArrayDimsAndInits */
04585: SimpleNode jjtn000 = new SimpleNode(JJTARRAYDIMSANDINITS);
04586: boolean jjtc000 = true;
04587: jjtree.openNodeScope(jjtn000);
04588: jjtreeOpenNodeScope(jjtn000);
04589: try {
04590: if (jj_2_39(2)) {
04591: label_37: while (true) {
04592: jj_consume_token(LBRACKET);
04593: Expression();
04594: jj_consume_token(RBRACKET);
04595: if (jj_2_37(2)) {
04596: ;
04597: } else {
04598: break label_37;
04599: }
04600: }
04601: label_38: while (true) {
04602: if (jj_2_38(2)) {
04603: ;
04604: } else {
04605: break label_38;
04606: }
04607: jj_consume_token(LBRACKET);
04608: jj_consume_token(RBRACKET);
04609: }
04610: } else {
04611: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04612: case LBRACKET:
04613: label_39: while (true) {
04614: jj_consume_token(LBRACKET);
04615: jj_consume_token(RBRACKET);
04616: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04617: case LBRACKET:
04618: ;
04619: break;
04620: default:
04621: break label_39;
04622: }
04623: }
04624: ArrayInitializer();
04625: break;
04626: default:
04627: jj_consume_token(-1);
04628: throw new ParseException();
04629: }
04630: }
04631: } catch (Throwable jjte000) {
04632: if (jjtc000) {
04633: jjtree.clearNodeScope(jjtn000);
04634: jjtc000 = false;
04635: } else {
04636: jjtree.popNode();
04637: }
04638: if (jjte000 instanceof RuntimeException) {
04639: {
04640: if (true)
04641: throw (RuntimeException) jjte000;
04642: }
04643: }
04644: if (jjte000 instanceof ParseException) {
04645: {
04646: if (true)
04647: throw (ParseException) jjte000;
04648: }
04649: }
04650: {
04651: if (true)
04652: throw (Error) jjte000;
04653: }
04654: } finally {
04655: if (jjtc000) {
04656: jjtree.closeNodeScope(jjtn000, true);
04657: jjtreeCloseNodeScope(jjtn000);
04658: }
04659: }
04660: }
04661:
04662: /*
04663: * Statement syntax follows.
04664: */
04665: final public void Statement() throws ParseException {
04666: /*@bgen(jjtree) Statement */
04667: SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENT);
04668: boolean jjtc000 = true;
04669: jjtree.openNodeScope(jjtn000);
04670: jjtreeOpenNodeScope(jjtn000);
04671: try {
04672: if (jj_2_40(2)) {
04673: LabeledStatement();
04674: } else {
04675: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04676: case ASSERT:
04677: AssertStatement();
04678: break;
04679: case LBRACE:
04680: Block();
04681: break;
04682: case SEMICOLON:
04683: EmptyStatement();
04684: break;
04685: case BOOLEAN:
04686: case BYTE:
04687: case CHAR:
04688: case DOUBLE:
04689: case FALSE:
04690: case FLOAT:
04691: case INT:
04692: case LONG:
04693: case NEW:
04694: case NULL:
04695: case SHORT:
04696: case SUPER:
04697: case THIS:
04698: case TRUE:
04699: case VOID:
04700: case INTEGER_LITERAL:
04701: case FLOATING_POINT_LITERAL:
04702: case CHARACTER_LITERAL:
04703: case STRING_LITERAL:
04704: case IDENTIFIER:
04705: case LPAREN:
04706: case INCR:
04707: case DECR:
04708: StatementExpression();
04709: jj_consume_token(SEMICOLON);
04710: break;
04711: case SWITCH:
04712: SwitchStatement();
04713: break;
04714: case IF:
04715: IfStatement();
04716: break;
04717: case WHILE:
04718: WhileStatement();
04719: break;
04720: case DO:
04721: DoStatement();
04722: break;
04723: case FOR:
04724: ForStatement();
04725: break;
04726: case BREAK:
04727: BreakStatement();
04728: break;
04729: case CONTINUE:
04730: ContinueStatement();
04731: break;
04732: case RETURN:
04733: ReturnStatement();
04734: break;
04735: case THROW:
04736: ThrowStatement();
04737: break;
04738: case SYNCHRONIZED:
04739: SynchronizedStatement();
04740: break;
04741: case TRY:
04742: TryStatement();
04743: break;
04744: default:
04745: jj_consume_token(-1);
04746: throw new ParseException();
04747: }
04748: }
04749: } catch (Throwable jjte000) {
04750: if (jjtc000) {
04751: jjtree.clearNodeScope(jjtn000);
04752: jjtc000 = false;
04753: } else {
04754: jjtree.popNode();
04755: }
04756: if (jjte000 instanceof RuntimeException) {
04757: {
04758: if (true)
04759: throw (RuntimeException) jjte000;
04760: }
04761: }
04762: if (jjte000 instanceof ParseException) {
04763: {
04764: if (true)
04765: throw (ParseException) jjte000;
04766: }
04767: }
04768: {
04769: if (true)
04770: throw (Error) jjte000;
04771: }
04772: } finally {
04773: if (jjtc000) {
04774: jjtree.closeNodeScope(jjtn000, true);
04775: jjtreeCloseNodeScope(jjtn000);
04776: }
04777: }
04778: }
04779:
04780: final public void AssertStatement() throws ParseException {
04781: /*@bgen(jjtree) AssertStatement */
04782: SimpleNode jjtn000 = new SimpleNode(JJTASSERTSTATEMENT);
04783: boolean jjtc000 = true;
04784: jjtree.openNodeScope(jjtn000);
04785: jjtreeOpenNodeScope(jjtn000);
04786: try {
04787: jj_consume_token(ASSERT);
04788: Expression();
04789: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04790: case COLON:
04791: jj_consume_token(COLON);
04792: Expression();
04793: break;
04794: default:
04795: ;
04796: }
04797: jj_consume_token(SEMICOLON);
04798: } catch (Throwable jjte000) {
04799: if (jjtc000) {
04800: jjtree.clearNodeScope(jjtn000);
04801: jjtc000 = false;
04802: } else {
04803: jjtree.popNode();
04804: }
04805: if (jjte000 instanceof RuntimeException) {
04806: {
04807: if (true)
04808: throw (RuntimeException) jjte000;
04809: }
04810: }
04811: if (jjte000 instanceof ParseException) {
04812: {
04813: if (true)
04814: throw (ParseException) jjte000;
04815: }
04816: }
04817: {
04818: if (true)
04819: throw (Error) jjte000;
04820: }
04821: } finally {
04822: if (jjtc000) {
04823: jjtree.closeNodeScope(jjtn000, true);
04824: jjtreeCloseNodeScope(jjtn000);
04825: }
04826: }
04827: }
04828:
04829: final public void LabeledStatement() throws ParseException {
04830: /*@bgen(jjtree) LabeledStatement */
04831: SimpleNode jjtn000 = new SimpleNode(JJTLABELEDSTATEMENT);
04832: boolean jjtc000 = true;
04833: jjtree.openNodeScope(jjtn000);
04834: jjtreeOpenNodeScope(jjtn000);
04835: try {
04836: jj_consume_token(IDENTIFIER);
04837: jj_consume_token(COLON);
04838: Statement();
04839: } catch (Throwable jjte000) {
04840: if (jjtc000) {
04841: jjtree.clearNodeScope(jjtn000);
04842: jjtc000 = false;
04843: } else {
04844: jjtree.popNode();
04845: }
04846: if (jjte000 instanceof RuntimeException) {
04847: {
04848: if (true)
04849: throw (RuntimeException) jjte000;
04850: }
04851: }
04852: if (jjte000 instanceof ParseException) {
04853: {
04854: if (true)
04855: throw (ParseException) jjte000;
04856: }
04857: }
04858: {
04859: if (true)
04860: throw (Error) jjte000;
04861: }
04862: } finally {
04863: if (jjtc000) {
04864: jjtree.closeNodeScope(jjtn000, true);
04865: jjtreeCloseNodeScope(jjtn000);
04866: }
04867: }
04868: }
04869:
04870: final public void Block() throws ParseException {
04871: /*@bgen(jjtree) Block */
04872: SimpleNode jjtn000 = new SimpleNode(JJTBLOCK);
04873: boolean jjtc000 = true;
04874: jjtree.openNodeScope(jjtn000);
04875: jjtreeOpenNodeScope(jjtn000);
04876: try {
04877: jj_consume_token(LBRACE);
04878: label_40: while (true) {
04879: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04880: case ABSTRACT:
04881: case ASSERT:
04882: case BOOLEAN:
04883: case BREAK:
04884: case BYTE:
04885: case CHAR:
04886: case CLASS:
04887: case CONTINUE:
04888: case DO:
04889: case DOUBLE:
04890: case FALSE:
04891: case FINAL:
04892: case FLOAT:
04893: case FOR:
04894: case IF:
04895: case INT:
04896: case INTERFACE:
04897: case LONG:
04898: case NATIVE:
04899: case NEW:
04900: case NULL:
04901: case PRIVATE:
04902: case PROTECTED:
04903: case PUBLIC:
04904: case RETURN:
04905: case SHORT:
04906: case STATIC:
04907: case STRICTFP:
04908: case SUPER:
04909: case SWITCH:
04910: case SYNCHRONIZED:
04911: case THIS:
04912: case THROW:
04913: case TRANSIENT:
04914: case TRUE:
04915: case TRY:
04916: case VOID:
04917: case VOLATILE:
04918: case WHILE:
04919: case INTEGER_LITERAL:
04920: case FLOATING_POINT_LITERAL:
04921: case CHARACTER_LITERAL:
04922: case STRING_LITERAL:
04923: case IDENTIFIER:
04924: case LPAREN:
04925: case LBRACE:
04926: case SEMICOLON:
04927: case AT:
04928: case INCR:
04929: case DECR:
04930: ;
04931: break;
04932: default:
04933: break label_40;
04934: }
04935: BlockStatement();
04936: }
04937: jj_consume_token(RBRACE);
04938: } catch (Throwable jjte000) {
04939: if (jjtc000) {
04940: jjtree.clearNodeScope(jjtn000);
04941: jjtc000 = false;
04942: } else {
04943: jjtree.popNode();
04944: }
04945: if (jjte000 instanceof RuntimeException) {
04946: {
04947: if (true)
04948: throw (RuntimeException) jjte000;
04949: }
04950: }
04951: if (jjte000 instanceof ParseException) {
04952: {
04953: if (true)
04954: throw (ParseException) jjte000;
04955: }
04956: }
04957: {
04958: if (true)
04959: throw (Error) jjte000;
04960: }
04961: } finally {
04962: if (jjtc000) {
04963: jjtree.closeNodeScope(jjtn000, true);
04964: jjtreeCloseNodeScope(jjtn000);
04965: }
04966: }
04967: }
04968:
04969: final public void BlockStatement() throws ParseException {
04970: /*@bgen(jjtree) BlockStatement */
04971: SimpleNode jjtn000 = new SimpleNode(JJTBLOCKSTATEMENT);
04972: boolean jjtc000 = true;
04973: jjtree.openNodeScope(jjtn000);
04974: jjtreeOpenNodeScope(jjtn000);
04975: try {
04976: if (jj_2_41(2147483647)) {
04977: LocalVariableDeclaration();
04978: jj_consume_token(SEMICOLON);
04979: } else {
04980: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
04981: case ASSERT:
04982: case BOOLEAN:
04983: case BREAK:
04984: case BYTE:
04985: case CHAR:
04986: case CONTINUE:
04987: case DO:
04988: case DOUBLE:
04989: case FALSE:
04990: case FLOAT:
04991: case FOR:
04992: case IF:
04993: case INT:
04994: case LONG:
04995: case NEW:
04996: case NULL:
04997: case RETURN:
04998: case SHORT:
04999: case SUPER:
05000: case SWITCH:
05001: case SYNCHRONIZED:
05002: case THIS:
05003: case THROW:
05004: case TRUE:
05005: case TRY:
05006: case VOID:
05007: case WHILE:
05008: case INTEGER_LITERAL:
05009: case FLOATING_POINT_LITERAL:
05010: case CHARACTER_LITERAL:
05011: case STRING_LITERAL:
05012: case IDENTIFIER:
05013: case LPAREN:
05014: case LBRACE:
05015: case SEMICOLON:
05016: case INCR:
05017: case DECR:
05018: Statement();
05019: break;
05020: case CLASS:
05021: case INTERFACE:
05022: ClassOrInterfaceDeclaration(0);
05023: break;
05024: default:
05025: jj_consume_token(-1);
05026: throw new ParseException();
05027: }
05028: }
05029: } catch (Throwable jjte000) {
05030: if (jjtc000) {
05031: jjtree.clearNodeScope(jjtn000);
05032: jjtc000 = false;
05033: } else {
05034: jjtree.popNode();
05035: }
05036: if (jjte000 instanceof RuntimeException) {
05037: {
05038: if (true)
05039: throw (RuntimeException) jjte000;
05040: }
05041: }
05042: if (jjte000 instanceof ParseException) {
05043: {
05044: if (true)
05045: throw (ParseException) jjte000;
05046: }
05047: }
05048: {
05049: if (true)
05050: throw (Error) jjte000;
05051: }
05052: } finally {
05053: if (jjtc000) {
05054: jjtree.closeNodeScope(jjtn000, true);
05055: jjtreeCloseNodeScope(jjtn000);
05056: }
05057: }
05058: }
05059:
05060: final public void LocalVariableDeclaration() throws ParseException {
05061: /*@bgen(jjtree) LocalVariableDeclaration */
05062: SimpleNode jjtn000 = new SimpleNode(JJTLOCALVARIABLEDECLARATION);
05063: boolean jjtc000 = true;
05064: jjtree.openNodeScope(jjtn000);
05065: jjtreeOpenNodeScope(jjtn000);
05066: try {
05067: Modifiers();
05068: Type();
05069: VariableDeclarator();
05070: label_41: while (true) {
05071: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05072: case COMMA:
05073: ;
05074: break;
05075: default:
05076: break label_41;
05077: }
05078: jj_consume_token(COMMA);
05079: VariableDeclarator();
05080: }
05081: } catch (Throwable jjte000) {
05082: if (jjtc000) {
05083: jjtree.clearNodeScope(jjtn000);
05084: jjtc000 = false;
05085: } else {
05086: jjtree.popNode();
05087: }
05088: if (jjte000 instanceof RuntimeException) {
05089: {
05090: if (true)
05091: throw (RuntimeException) jjte000;
05092: }
05093: }
05094: if (jjte000 instanceof ParseException) {
05095: {
05096: if (true)
05097: throw (ParseException) jjte000;
05098: }
05099: }
05100: {
05101: if (true)
05102: throw (Error) jjte000;
05103: }
05104: } finally {
05105: if (jjtc000) {
05106: jjtree.closeNodeScope(jjtn000, true);
05107: jjtreeCloseNodeScope(jjtn000);
05108: }
05109: }
05110: }
05111:
05112: final public void EmptyStatement() throws ParseException {
05113: /*@bgen(jjtree) EmptyStatement */
05114: SimpleNode jjtn000 = new SimpleNode(JJTEMPTYSTATEMENT);
05115: boolean jjtc000 = true;
05116: jjtree.openNodeScope(jjtn000);
05117: jjtreeOpenNodeScope(jjtn000);
05118: try {
05119: jj_consume_token(SEMICOLON);
05120: } finally {
05121: if (jjtc000) {
05122: jjtree.closeNodeScope(jjtn000, true);
05123: jjtreeCloseNodeScope(jjtn000);
05124: }
05125: }
05126: }
05127:
05128: final public void StatementExpression() throws ParseException {
05129: /*@bgen(jjtree) StatementExpression */
05130: SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENTEXPRESSION);
05131: boolean jjtc000 = true;
05132: jjtree.openNodeScope(jjtn000);
05133: jjtreeOpenNodeScope(jjtn000);
05134: try {
05135: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05136: case INCR:
05137: PreIncrementExpression();
05138: break;
05139: case DECR:
05140: PreDecrementExpression();
05141: break;
05142: default:
05143: if (jj_2_42(2147483647)) {
05144: AssignmentExpression();
05145: } else {
05146: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05147: case BOOLEAN:
05148: case BYTE:
05149: case CHAR:
05150: case DOUBLE:
05151: case FALSE:
05152: case FLOAT:
05153: case INT:
05154: case LONG:
05155: case NEW:
05156: case NULL:
05157: case SHORT:
05158: case SUPER:
05159: case THIS:
05160: case TRUE:
05161: case VOID:
05162: case INTEGER_LITERAL:
05163: case FLOATING_POINT_LITERAL:
05164: case CHARACTER_LITERAL:
05165: case STRING_LITERAL:
05166: case IDENTIFIER:
05167: case LPAREN:
05168: PostfixExpression();
05169: break;
05170: default:
05171: jj_consume_token(-1);
05172: throw new ParseException();
05173: }
05174: }
05175: }
05176: } catch (Throwable jjte000) {
05177: if (jjtc000) {
05178: jjtree.clearNodeScope(jjtn000);
05179: jjtc000 = false;
05180: } else {
05181: jjtree.popNode();
05182: }
05183: if (jjte000 instanceof RuntimeException) {
05184: {
05185: if (true)
05186: throw (RuntimeException) jjte000;
05187: }
05188: }
05189: if (jjte000 instanceof ParseException) {
05190: {
05191: if (true)
05192: throw (ParseException) jjte000;
05193: }
05194: }
05195: {
05196: if (true)
05197: throw (Error) jjte000;
05198: }
05199: } finally {
05200: if (jjtc000) {
05201: jjtree.closeNodeScope(jjtn000, true);
05202: jjtreeCloseNodeScope(jjtn000);
05203: }
05204: }
05205: }
05206:
05207: final public void SwitchStatement() throws ParseException {
05208: /*@bgen(jjtree) SwitchStatement */
05209: SimpleNode jjtn000 = new SimpleNode(JJTSWITCHSTATEMENT);
05210: boolean jjtc000 = true;
05211: jjtree.openNodeScope(jjtn000);
05212: jjtreeOpenNodeScope(jjtn000);
05213: try {
05214: jj_consume_token(SWITCH);
05215: jj_consume_token(LPAREN);
05216: Expression();
05217: jj_consume_token(RPAREN);
05218: jj_consume_token(LBRACE);
05219: label_42: while (true) {
05220: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05221: case CASE:
05222: case _DEFAULT:
05223: ;
05224: break;
05225: default:
05226: break label_42;
05227: }
05228: SwitchLabel();
05229: label_43: while (true) {
05230: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05231: case ABSTRACT:
05232: case ASSERT:
05233: case BOOLEAN:
05234: case BREAK:
05235: case BYTE:
05236: case CHAR:
05237: case CLASS:
05238: case CONTINUE:
05239: case DO:
05240: case DOUBLE:
05241: case FALSE:
05242: case FINAL:
05243: case FLOAT:
05244: case FOR:
05245: case IF:
05246: case INT:
05247: case INTERFACE:
05248: case LONG:
05249: case NATIVE:
05250: case NEW:
05251: case NULL:
05252: case PRIVATE:
05253: case PROTECTED:
05254: case PUBLIC:
05255: case RETURN:
05256: case SHORT:
05257: case STATIC:
05258: case STRICTFP:
05259: case SUPER:
05260: case SWITCH:
05261: case SYNCHRONIZED:
05262: case THIS:
05263: case THROW:
05264: case TRANSIENT:
05265: case TRUE:
05266: case TRY:
05267: case VOID:
05268: case VOLATILE:
05269: case WHILE:
05270: case INTEGER_LITERAL:
05271: case FLOATING_POINT_LITERAL:
05272: case CHARACTER_LITERAL:
05273: case STRING_LITERAL:
05274: case IDENTIFIER:
05275: case LPAREN:
05276: case LBRACE:
05277: case SEMICOLON:
05278: case AT:
05279: case INCR:
05280: case DECR:
05281: ;
05282: break;
05283: default:
05284: break label_43;
05285: }
05286: BlockStatement();
05287: }
05288: }
05289: jj_consume_token(RBRACE);
05290: } catch (Throwable jjte000) {
05291: if (jjtc000) {
05292: jjtree.clearNodeScope(jjtn000);
05293: jjtc000 = false;
05294: } else {
05295: jjtree.popNode();
05296: }
05297: if (jjte000 instanceof RuntimeException) {
05298: {
05299: if (true)
05300: throw (RuntimeException) jjte000;
05301: }
05302: }
05303: if (jjte000 instanceof ParseException) {
05304: {
05305: if (true)
05306: throw (ParseException) jjte000;
05307: }
05308: }
05309: {
05310: if (true)
05311: throw (Error) jjte000;
05312: }
05313: } finally {
05314: if (jjtc000) {
05315: jjtree.closeNodeScope(jjtn000, true);
05316: jjtreeCloseNodeScope(jjtn000);
05317: }
05318: }
05319: }
05320:
05321: final public void SwitchLabel() throws ParseException {
05322: /*@bgen(jjtree) SwitchLabel */
05323: SimpleNode jjtn000 = new SimpleNode(JJTSWITCHLABEL);
05324: boolean jjtc000 = true;
05325: jjtree.openNodeScope(jjtn000);
05326: jjtreeOpenNodeScope(jjtn000);
05327: try {
05328: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05329: case CASE:
05330: jj_consume_token(CASE);
05331: Expression();
05332: jj_consume_token(COLON);
05333: break;
05334: case _DEFAULT:
05335: jj_consume_token(_DEFAULT);
05336: jj_consume_token(COLON);
05337: break;
05338: default:
05339: jj_consume_token(-1);
05340: throw new ParseException();
05341: }
05342: } catch (Throwable jjte000) {
05343: if (jjtc000) {
05344: jjtree.clearNodeScope(jjtn000);
05345: jjtc000 = false;
05346: } else {
05347: jjtree.popNode();
05348: }
05349: if (jjte000 instanceof RuntimeException) {
05350: {
05351: if (true)
05352: throw (RuntimeException) jjte000;
05353: }
05354: }
05355: if (jjte000 instanceof ParseException) {
05356: {
05357: if (true)
05358: throw (ParseException) jjte000;
05359: }
05360: }
05361: {
05362: if (true)
05363: throw (Error) jjte000;
05364: }
05365: } finally {
05366: if (jjtc000) {
05367: jjtree.closeNodeScope(jjtn000, true);
05368: jjtreeCloseNodeScope(jjtn000);
05369: }
05370: }
05371: }
05372:
05373: final public void IfStatement() throws ParseException {
05374: /*@bgen(jjtree) IfStatement */
05375: SimpleNode jjtn000 = new SimpleNode(JJTIFSTATEMENT);
05376: boolean jjtc000 = true;
05377: jjtree.openNodeScope(jjtn000);
05378: jjtreeOpenNodeScope(jjtn000);
05379: try {
05380: jj_consume_token(IF);
05381: jj_consume_token(LPAREN);
05382: Expression();
05383: jj_consume_token(RPAREN);
05384: Statement();
05385: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05386: case ELSE:
05387: jj_consume_token(ELSE);
05388: Statement();
05389: break;
05390: default:
05391: ;
05392: }
05393: } catch (Throwable jjte000) {
05394: if (jjtc000) {
05395: jjtree.clearNodeScope(jjtn000);
05396: jjtc000 = false;
05397: } else {
05398: jjtree.popNode();
05399: }
05400: if (jjte000 instanceof RuntimeException) {
05401: {
05402: if (true)
05403: throw (RuntimeException) jjte000;
05404: }
05405: }
05406: if (jjte000 instanceof ParseException) {
05407: {
05408: if (true)
05409: throw (ParseException) jjte000;
05410: }
05411: }
05412: {
05413: if (true)
05414: throw (Error) jjte000;
05415: }
05416: } finally {
05417: if (jjtc000) {
05418: jjtree.closeNodeScope(jjtn000, true);
05419: jjtreeCloseNodeScope(jjtn000);
05420: }
05421: }
05422: }
05423:
05424: final public void WhileStatement() throws ParseException {
05425: /*@bgen(jjtree) WhileStatement */
05426: SimpleNode jjtn000 = new SimpleNode(JJTWHILESTATEMENT);
05427: boolean jjtc000 = true;
05428: jjtree.openNodeScope(jjtn000);
05429: jjtreeOpenNodeScope(jjtn000);
05430: try {
05431: jj_consume_token(WHILE);
05432: jj_consume_token(LPAREN);
05433: Expression();
05434: jj_consume_token(RPAREN);
05435: Statement();
05436: } catch (Throwable jjte000) {
05437: if (jjtc000) {
05438: jjtree.clearNodeScope(jjtn000);
05439: jjtc000 = false;
05440: } else {
05441: jjtree.popNode();
05442: }
05443: if (jjte000 instanceof RuntimeException) {
05444: {
05445: if (true)
05446: throw (RuntimeException) jjte000;
05447: }
05448: }
05449: if (jjte000 instanceof ParseException) {
05450: {
05451: if (true)
05452: throw (ParseException) jjte000;
05453: }
05454: }
05455: {
05456: if (true)
05457: throw (Error) jjte000;
05458: }
05459: } finally {
05460: if (jjtc000) {
05461: jjtree.closeNodeScope(jjtn000, true);
05462: jjtreeCloseNodeScope(jjtn000);
05463: }
05464: }
05465: }
05466:
05467: final public void DoStatement() throws ParseException {
05468: /*@bgen(jjtree) DoStatement */
05469: SimpleNode jjtn000 = new SimpleNode(JJTDOSTATEMENT);
05470: boolean jjtc000 = true;
05471: jjtree.openNodeScope(jjtn000);
05472: jjtreeOpenNodeScope(jjtn000);
05473: try {
05474: jj_consume_token(DO);
05475: Statement();
05476: jj_consume_token(WHILE);
05477: jj_consume_token(LPAREN);
05478: Expression();
05479: jj_consume_token(RPAREN);
05480: jj_consume_token(SEMICOLON);
05481: } catch (Throwable jjte000) {
05482: if (jjtc000) {
05483: jjtree.clearNodeScope(jjtn000);
05484: jjtc000 = false;
05485: } else {
05486: jjtree.popNode();
05487: }
05488: if (jjte000 instanceof RuntimeException) {
05489: {
05490: if (true)
05491: throw (RuntimeException) jjte000;
05492: }
05493: }
05494: if (jjte000 instanceof ParseException) {
05495: {
05496: if (true)
05497: throw (ParseException) jjte000;
05498: }
05499: }
05500: {
05501: if (true)
05502: throw (Error) jjte000;
05503: }
05504: } finally {
05505: if (jjtc000) {
05506: jjtree.closeNodeScope(jjtn000, true);
05507: jjtreeCloseNodeScope(jjtn000);
05508: }
05509: }
05510: }
05511:
05512: final public void ForStatement() throws ParseException {
05513: /*@bgen(jjtree) ForStatement */
05514: SimpleNode jjtn000 = new SimpleNode(JJTFORSTATEMENT);
05515: boolean jjtc000 = true;
05516: jjtree.openNodeScope(jjtn000);
05517: jjtreeOpenNodeScope(jjtn000);
05518: try {
05519: jj_consume_token(FOR);
05520: jj_consume_token(LPAREN);
05521: if (jj_2_43(2147483647)) {
05522: Modifiers();
05523: Type();
05524: jj_consume_token(IDENTIFIER);
05525: jj_consume_token(COLON);
05526: Expression();
05527: } else {
05528: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05529: case ABSTRACT:
05530: case BOOLEAN:
05531: case BYTE:
05532: case CHAR:
05533: case DOUBLE:
05534: case FALSE:
05535: case FINAL:
05536: case FLOAT:
05537: case INT:
05538: case LONG:
05539: case NATIVE:
05540: case NEW:
05541: case NULL:
05542: case PRIVATE:
05543: case PROTECTED:
05544: case PUBLIC:
05545: case SHORT:
05546: case STATIC:
05547: case STRICTFP:
05548: case SUPER:
05549: case SYNCHRONIZED:
05550: case THIS:
05551: case TRANSIENT:
05552: case TRUE:
05553: case VOID:
05554: case VOLATILE:
05555: case INTEGER_LITERAL:
05556: case FLOATING_POINT_LITERAL:
05557: case CHARACTER_LITERAL:
05558: case STRING_LITERAL:
05559: case IDENTIFIER:
05560: case LPAREN:
05561: case SEMICOLON:
05562: case AT:
05563: case INCR:
05564: case DECR:
05565: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05566: case ABSTRACT:
05567: case BOOLEAN:
05568: case BYTE:
05569: case CHAR:
05570: case DOUBLE:
05571: case FALSE:
05572: case FINAL:
05573: case FLOAT:
05574: case INT:
05575: case LONG:
05576: case NATIVE:
05577: case NEW:
05578: case NULL:
05579: case PRIVATE:
05580: case PROTECTED:
05581: case PUBLIC:
05582: case SHORT:
05583: case STATIC:
05584: case STRICTFP:
05585: case SUPER:
05586: case SYNCHRONIZED:
05587: case THIS:
05588: case TRANSIENT:
05589: case TRUE:
05590: case VOID:
05591: case VOLATILE:
05592: case INTEGER_LITERAL:
05593: case FLOATING_POINT_LITERAL:
05594: case CHARACTER_LITERAL:
05595: case STRING_LITERAL:
05596: case IDENTIFIER:
05597: case LPAREN:
05598: case AT:
05599: case INCR:
05600: case DECR:
05601: ForInit();
05602: break;
05603: default:
05604: ;
05605: }
05606: jj_consume_token(SEMICOLON);
05607: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05608: case BOOLEAN:
05609: case BYTE:
05610: case CHAR:
05611: case DOUBLE:
05612: case FALSE:
05613: case FLOAT:
05614: case INT:
05615: case LONG:
05616: case NEW:
05617: case NULL:
05618: case SHORT:
05619: case SUPER:
05620: case THIS:
05621: case TRUE:
05622: case VOID:
05623: case INTEGER_LITERAL:
05624: case FLOATING_POINT_LITERAL:
05625: case CHARACTER_LITERAL:
05626: case STRING_LITERAL:
05627: case IDENTIFIER:
05628: case LPAREN:
05629: case BANG:
05630: case TILDE:
05631: case INCR:
05632: case DECR:
05633: case PLUS:
05634: case MINUS:
05635: Expression();
05636: break;
05637: default:
05638: ;
05639: }
05640: jj_consume_token(SEMICOLON);
05641: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05642: case BOOLEAN:
05643: case BYTE:
05644: case CHAR:
05645: case DOUBLE:
05646: case FALSE:
05647: case FLOAT:
05648: case INT:
05649: case LONG:
05650: case NEW:
05651: case NULL:
05652: case SHORT:
05653: case SUPER:
05654: case THIS:
05655: case TRUE:
05656: case VOID:
05657: case INTEGER_LITERAL:
05658: case FLOATING_POINT_LITERAL:
05659: case CHARACTER_LITERAL:
05660: case STRING_LITERAL:
05661: case IDENTIFIER:
05662: case LPAREN:
05663: case INCR:
05664: case DECR:
05665: ForUpdate();
05666: break;
05667: default:
05668: ;
05669: }
05670: break;
05671: default:
05672: jj_consume_token(-1);
05673: throw new ParseException();
05674: }
05675: }
05676: jj_consume_token(RPAREN);
05677: Statement();
05678: } catch (Throwable jjte000) {
05679: if (jjtc000) {
05680: jjtree.clearNodeScope(jjtn000);
05681: jjtc000 = false;
05682: } else {
05683: jjtree.popNode();
05684: }
05685: if (jjte000 instanceof RuntimeException) {
05686: {
05687: if (true)
05688: throw (RuntimeException) jjte000;
05689: }
05690: }
05691: if (jjte000 instanceof ParseException) {
05692: {
05693: if (true)
05694: throw (ParseException) jjte000;
05695: }
05696: }
05697: {
05698: if (true)
05699: throw (Error) jjte000;
05700: }
05701: } finally {
05702: if (jjtc000) {
05703: jjtree.closeNodeScope(jjtn000, true);
05704: jjtreeCloseNodeScope(jjtn000);
05705: }
05706: }
05707: }
05708:
05709: final public void ForInit() throws ParseException {
05710: /*@bgen(jjtree) ForInit */
05711: SimpleNode jjtn000 = new SimpleNode(JJTFORINIT);
05712: boolean jjtc000 = true;
05713: jjtree.openNodeScope(jjtn000);
05714: jjtreeOpenNodeScope(jjtn000);
05715: try {
05716: if (jj_2_44(2147483647)) {
05717: LocalVariableDeclaration();
05718: } else {
05719: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05720: case BOOLEAN:
05721: case BYTE:
05722: case CHAR:
05723: case DOUBLE:
05724: case FALSE:
05725: case FLOAT:
05726: case INT:
05727: case LONG:
05728: case NEW:
05729: case NULL:
05730: case SHORT:
05731: case SUPER:
05732: case THIS:
05733: case TRUE:
05734: case VOID:
05735: case INTEGER_LITERAL:
05736: case FLOATING_POINT_LITERAL:
05737: case CHARACTER_LITERAL:
05738: case STRING_LITERAL:
05739: case IDENTIFIER:
05740: case LPAREN:
05741: case INCR:
05742: case DECR:
05743: StatementExpressionList();
05744: break;
05745: default:
05746: jj_consume_token(-1);
05747: throw new ParseException();
05748: }
05749: }
05750: } catch (Throwable jjte000) {
05751: if (jjtc000) {
05752: jjtree.clearNodeScope(jjtn000);
05753: jjtc000 = false;
05754: } else {
05755: jjtree.popNode();
05756: }
05757: if (jjte000 instanceof RuntimeException) {
05758: {
05759: if (true)
05760: throw (RuntimeException) jjte000;
05761: }
05762: }
05763: if (jjte000 instanceof ParseException) {
05764: {
05765: if (true)
05766: throw (ParseException) jjte000;
05767: }
05768: }
05769: {
05770: if (true)
05771: throw (Error) jjte000;
05772: }
05773: } finally {
05774: if (jjtc000) {
05775: jjtree.closeNodeScope(jjtn000, true);
05776: jjtreeCloseNodeScope(jjtn000);
05777: }
05778: }
05779: }
05780:
05781: final public void StatementExpressionList() throws ParseException {
05782: /*@bgen(jjtree) StatementExpressionList */
05783: SimpleNode jjtn000 = new SimpleNode(JJTSTATEMENTEXPRESSIONLIST);
05784: boolean jjtc000 = true;
05785: jjtree.openNodeScope(jjtn000);
05786: jjtreeOpenNodeScope(jjtn000);
05787: try {
05788: StatementExpression();
05789: label_44: while (true) {
05790: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05791: case COMMA:
05792: ;
05793: break;
05794: default:
05795: break label_44;
05796: }
05797: jj_consume_token(COMMA);
05798: StatementExpression();
05799: }
05800: } catch (Throwable jjte000) {
05801: if (jjtc000) {
05802: jjtree.clearNodeScope(jjtn000);
05803: jjtc000 = false;
05804: } else {
05805: jjtree.popNode();
05806: }
05807: if (jjte000 instanceof RuntimeException) {
05808: {
05809: if (true)
05810: throw (RuntimeException) jjte000;
05811: }
05812: }
05813: if (jjte000 instanceof ParseException) {
05814: {
05815: if (true)
05816: throw (ParseException) jjte000;
05817: }
05818: }
05819: {
05820: if (true)
05821: throw (Error) jjte000;
05822: }
05823: } finally {
05824: if (jjtc000) {
05825: jjtree.closeNodeScope(jjtn000, true);
05826: jjtreeCloseNodeScope(jjtn000);
05827: }
05828: }
05829: }
05830:
05831: final public void ForUpdate() throws ParseException {
05832: /*@bgen(jjtree) ForUpdate */
05833: SimpleNode jjtn000 = new SimpleNode(JJTFORUPDATE);
05834: boolean jjtc000 = true;
05835: jjtree.openNodeScope(jjtn000);
05836: jjtreeOpenNodeScope(jjtn000);
05837: try {
05838: StatementExpressionList();
05839: } catch (Throwable jjte000) {
05840: if (jjtc000) {
05841: jjtree.clearNodeScope(jjtn000);
05842: jjtc000 = false;
05843: } else {
05844: jjtree.popNode();
05845: }
05846: if (jjte000 instanceof RuntimeException) {
05847: {
05848: if (true)
05849: throw (RuntimeException) jjte000;
05850: }
05851: }
05852: if (jjte000 instanceof ParseException) {
05853: {
05854: if (true)
05855: throw (ParseException) jjte000;
05856: }
05857: }
05858: {
05859: if (true)
05860: throw (Error) jjte000;
05861: }
05862: } finally {
05863: if (jjtc000) {
05864: jjtree.closeNodeScope(jjtn000, true);
05865: jjtreeCloseNodeScope(jjtn000);
05866: }
05867: }
05868: }
05869:
05870: final public void BreakStatement() throws ParseException {
05871: /*@bgen(jjtree) BreakStatement */
05872: SimpleNode jjtn000 = new SimpleNode(JJTBREAKSTATEMENT);
05873: boolean jjtc000 = true;
05874: jjtree.openNodeScope(jjtn000);
05875: jjtreeOpenNodeScope(jjtn000);
05876: try {
05877: jj_consume_token(BREAK);
05878: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05879: case IDENTIFIER:
05880: jj_consume_token(IDENTIFIER);
05881: break;
05882: default:
05883: ;
05884: }
05885: jj_consume_token(SEMICOLON);
05886: } finally {
05887: if (jjtc000) {
05888: jjtree.closeNodeScope(jjtn000, true);
05889: jjtreeCloseNodeScope(jjtn000);
05890: }
05891: }
05892: }
05893:
05894: final public void ContinueStatement() throws ParseException {
05895: /*@bgen(jjtree) ContinueStatement */
05896: SimpleNode jjtn000 = new SimpleNode(JJTCONTINUESTATEMENT);
05897: boolean jjtc000 = true;
05898: jjtree.openNodeScope(jjtn000);
05899: jjtreeOpenNodeScope(jjtn000);
05900: try {
05901: jj_consume_token(CONTINUE);
05902: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05903: case IDENTIFIER:
05904: jj_consume_token(IDENTIFIER);
05905: break;
05906: default:
05907: ;
05908: }
05909: jj_consume_token(SEMICOLON);
05910: } finally {
05911: if (jjtc000) {
05912: jjtree.closeNodeScope(jjtn000, true);
05913: jjtreeCloseNodeScope(jjtn000);
05914: }
05915: }
05916: }
05917:
05918: final public void ReturnStatement() throws ParseException {
05919: /*@bgen(jjtree) ReturnStatement */
05920: SimpleNode jjtn000 = new SimpleNode(JJTRETURNSTATEMENT);
05921: boolean jjtc000 = true;
05922: jjtree.openNodeScope(jjtn000);
05923: jjtreeOpenNodeScope(jjtn000);
05924: try {
05925: jj_consume_token(RETURN);
05926: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
05927: case BOOLEAN:
05928: case BYTE:
05929: case CHAR:
05930: case DOUBLE:
05931: case FALSE:
05932: case FLOAT:
05933: case INT:
05934: case LONG:
05935: case NEW:
05936: case NULL:
05937: case SHORT:
05938: case SUPER:
05939: case THIS:
05940: case TRUE:
05941: case VOID:
05942: case INTEGER_LITERAL:
05943: case FLOATING_POINT_LITERAL:
05944: case CHARACTER_LITERAL:
05945: case STRING_LITERAL:
05946: case IDENTIFIER:
05947: case LPAREN:
05948: case BANG:
05949: case TILDE:
05950: case INCR:
05951: case DECR:
05952: case PLUS:
05953: case MINUS:
05954: Expression();
05955: break;
05956: default:
05957: ;
05958: }
05959: jj_consume_token(SEMICOLON);
05960: } catch (Throwable jjte000) {
05961: if (jjtc000) {
05962: jjtree.clearNodeScope(jjtn000);
05963: jjtc000 = false;
05964: } else {
05965: jjtree.popNode();
05966: }
05967: if (jjte000 instanceof RuntimeException) {
05968: {
05969: if (true)
05970: throw (RuntimeException) jjte000;
05971: }
05972: }
05973: if (jjte000 instanceof ParseException) {
05974: {
05975: if (true)
05976: throw (ParseException) jjte000;
05977: }
05978: }
05979: {
05980: if (true)
05981: throw (Error) jjte000;
05982: }
05983: } finally {
05984: if (jjtc000) {
05985: jjtree.closeNodeScope(jjtn000, true);
05986: jjtreeCloseNodeScope(jjtn000);
05987: }
05988: }
05989: }
05990:
05991: final public void ThrowStatement() throws ParseException {
05992: /*@bgen(jjtree) ThrowStatement */
05993: SimpleNode jjtn000 = new SimpleNode(JJTTHROWSTATEMENT);
05994: boolean jjtc000 = true;
05995: jjtree.openNodeScope(jjtn000);
05996: jjtreeOpenNodeScope(jjtn000);
05997: try {
05998: jj_consume_token(THROW);
05999: Expression();
06000: jj_consume_token(SEMICOLON);
06001: } catch (Throwable jjte000) {
06002: if (jjtc000) {
06003: jjtree.clearNodeScope(jjtn000);
06004: jjtc000 = false;
06005: } else {
06006: jjtree.popNode();
06007: }
06008: if (jjte000 instanceof RuntimeException) {
06009: {
06010: if (true)
06011: throw (RuntimeException) jjte000;
06012: }
06013: }
06014: if (jjte000 instanceof ParseException) {
06015: {
06016: if (true)
06017: throw (ParseException) jjte000;
06018: }
06019: }
06020: {
06021: if (true)
06022: throw (Error) jjte000;
06023: }
06024: } finally {
06025: if (jjtc000) {
06026: jjtree.closeNodeScope(jjtn000, true);
06027: jjtreeCloseNodeScope(jjtn000);
06028: }
06029: }
06030: }
06031:
06032: final public void SynchronizedStatement() throws ParseException {
06033: /*@bgen(jjtree) SynchronizedStatement */
06034: SimpleNode jjtn000 = new SimpleNode(JJTSYNCHRONIZEDSTATEMENT);
06035: boolean jjtc000 = true;
06036: jjtree.openNodeScope(jjtn000);
06037: jjtreeOpenNodeScope(jjtn000);
06038: try {
06039: jj_consume_token(SYNCHRONIZED);
06040: jj_consume_token(LPAREN);
06041: Expression();
06042: jj_consume_token(RPAREN);
06043: Block();
06044: } catch (Throwable jjte000) {
06045: if (jjtc000) {
06046: jjtree.clearNodeScope(jjtn000);
06047: jjtc000 = false;
06048: } else {
06049: jjtree.popNode();
06050: }
06051: if (jjte000 instanceof RuntimeException) {
06052: {
06053: if (true)
06054: throw (RuntimeException) jjte000;
06055: }
06056: }
06057: if (jjte000 instanceof ParseException) {
06058: {
06059: if (true)
06060: throw (ParseException) jjte000;
06061: }
06062: }
06063: {
06064: if (true)
06065: throw (Error) jjte000;
06066: }
06067: } finally {
06068: if (jjtc000) {
06069: jjtree.closeNodeScope(jjtn000, true);
06070: jjtreeCloseNodeScope(jjtn000);
06071: }
06072: }
06073: }
06074:
06075: final public void TryStatement() throws ParseException {
06076: /*@bgen(jjtree) TryStatement */
06077: SimpleNode jjtn000 = new SimpleNode(JJTTRYSTATEMENT);
06078: boolean jjtc000 = true;
06079: jjtree.openNodeScope(jjtn000);
06080: jjtreeOpenNodeScope(jjtn000);
06081: try {
06082: jj_consume_token(TRY);
06083: Block();
06084: label_45: while (true) {
06085: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06086: case CATCH:
06087: ;
06088: break;
06089: default:
06090: break label_45;
06091: }
06092: jj_consume_token(CATCH);
06093: jj_consume_token(LPAREN);
06094: FormalParameter();
06095: jj_consume_token(RPAREN);
06096: Block();
06097: }
06098: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06099: case FINALLY:
06100: jj_consume_token(FINALLY);
06101: Block();
06102: break;
06103: default:
06104: ;
06105: }
06106: } catch (Throwable jjte000) {
06107: if (jjtc000) {
06108: jjtree.clearNodeScope(jjtn000);
06109: jjtc000 = false;
06110: } else {
06111: jjtree.popNode();
06112: }
06113: if (jjte000 instanceof RuntimeException) {
06114: {
06115: if (true)
06116: throw (RuntimeException) jjte000;
06117: }
06118: }
06119: if (jjte000 instanceof ParseException) {
06120: {
06121: if (true)
06122: throw (ParseException) jjte000;
06123: }
06124: }
06125: {
06126: if (true)
06127: throw (Error) jjte000;
06128: }
06129: } finally {
06130: if (jjtc000) {
06131: jjtree.closeNodeScope(jjtn000, true);
06132: jjtreeCloseNodeScope(jjtn000);
06133: }
06134: }
06135: }
06136:
06137: /* We use productions to match >>>, >> and > so that we can keep the
06138: * type declaration syntax with generics clean
06139: */
06140: final public void RUNSIGNEDSHIFT() throws ParseException {
06141: /*@bgen(jjtree) RUNSIGNEDSHIFT */
06142: SimpleNode jjtn000 = new SimpleNode(JJTRUNSIGNEDSHIFT);
06143: boolean jjtc000 = true;
06144: jjtree.openNodeScope(jjtn000);
06145: jjtreeOpenNodeScope(jjtn000);
06146: try {
06147: if (getToken(1).kind == GT
06148: && ((Token.GTToken) getToken(1)).realKind == RUNSIGNEDSHIFT) {
06149:
06150: } else {
06151: jj_consume_token(-1);
06152: throw new ParseException();
06153: }
06154: jj_consume_token(GT);
06155: jj_consume_token(GT);
06156: jj_consume_token(GT);
06157: } finally {
06158: if (jjtc000) {
06159: jjtree.closeNodeScope(jjtn000, true);
06160: jjtreeCloseNodeScope(jjtn000);
06161: }
06162: }
06163: }
06164:
06165: final public void RSIGNEDSHIFT() throws ParseException {
06166: /*@bgen(jjtree) RSIGNEDSHIFT */
06167: SimpleNode jjtn000 = new SimpleNode(JJTRSIGNEDSHIFT);
06168: boolean jjtc000 = true;
06169: jjtree.openNodeScope(jjtn000);
06170: jjtreeOpenNodeScope(jjtn000);
06171: try {
06172: if (getToken(1).kind == GT
06173: && ((Token.GTToken) getToken(1)).realKind == RSIGNEDSHIFT) {
06174:
06175: } else {
06176: jj_consume_token(-1);
06177: throw new ParseException();
06178: }
06179: jj_consume_token(GT);
06180: jj_consume_token(GT);
06181: } finally {
06182: if (jjtc000) {
06183: jjtree.closeNodeScope(jjtn000, true);
06184: jjtreeCloseNodeScope(jjtn000);
06185: }
06186: }
06187: }
06188:
06189: /* Annotation syntax follows. */
06190: final public void Annotation() throws ParseException {
06191: /*@bgen(jjtree) Annotation */
06192: SimpleNode jjtn000 = new SimpleNode(JJTANNOTATION);
06193: boolean jjtc000 = true;
06194: jjtree.openNodeScope(jjtn000);
06195: jjtreeOpenNodeScope(jjtn000);
06196: try {
06197: if (jj_2_45(2147483647)) {
06198: NormalAnnotation();
06199: } else if (jj_2_46(2147483647)) {
06200: SingleMemberAnnotation();
06201: } else {
06202: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06203: case AT:
06204: MarkerAnnotation();
06205: break;
06206: default:
06207: jj_consume_token(-1);
06208: throw new ParseException();
06209: }
06210: }
06211: } catch (Throwable jjte000) {
06212: if (jjtc000) {
06213: jjtree.clearNodeScope(jjtn000);
06214: jjtc000 = false;
06215: } else {
06216: jjtree.popNode();
06217: }
06218: if (jjte000 instanceof RuntimeException) {
06219: {
06220: if (true)
06221: throw (RuntimeException) jjte000;
06222: }
06223: }
06224: if (jjte000 instanceof ParseException) {
06225: {
06226: if (true)
06227: throw (ParseException) jjte000;
06228: }
06229: }
06230: {
06231: if (true)
06232: throw (Error) jjte000;
06233: }
06234: } finally {
06235: if (jjtc000) {
06236: jjtree.closeNodeScope(jjtn000, true);
06237: jjtreeCloseNodeScope(jjtn000);
06238: }
06239: }
06240: }
06241:
06242: final public void NormalAnnotation() throws ParseException {
06243: /*@bgen(jjtree) NormalAnnotation */
06244: SimpleNode jjtn000 = new SimpleNode(JJTNORMALANNOTATION);
06245: boolean jjtc000 = true;
06246: jjtree.openNodeScope(jjtn000);
06247: jjtreeOpenNodeScope(jjtn000);
06248: try {
06249: jj_consume_token(AT);
06250: Name();
06251: jj_consume_token(LPAREN);
06252: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06253: case IDENTIFIER:
06254: MemberValuePairs();
06255: break;
06256: default:
06257: ;
06258: }
06259: jj_consume_token(RPAREN);
06260: } catch (Throwable jjte000) {
06261: if (jjtc000) {
06262: jjtree.clearNodeScope(jjtn000);
06263: jjtc000 = false;
06264: } else {
06265: jjtree.popNode();
06266: }
06267: if (jjte000 instanceof RuntimeException) {
06268: {
06269: if (true)
06270: throw (RuntimeException) jjte000;
06271: }
06272: }
06273: if (jjte000 instanceof ParseException) {
06274: {
06275: if (true)
06276: throw (ParseException) jjte000;
06277: }
06278: }
06279: {
06280: if (true)
06281: throw (Error) jjte000;
06282: }
06283: } finally {
06284: if (jjtc000) {
06285: jjtree.closeNodeScope(jjtn000, true);
06286: jjtreeCloseNodeScope(jjtn000);
06287: }
06288: }
06289: }
06290:
06291: final public void MarkerAnnotation() throws ParseException {
06292: /*@bgen(jjtree) MarkerAnnotation */
06293: SimpleNode jjtn000 = new SimpleNode(JJTMARKERANNOTATION);
06294: boolean jjtc000 = true;
06295: jjtree.openNodeScope(jjtn000);
06296: jjtreeOpenNodeScope(jjtn000);
06297: try {
06298: jj_consume_token(AT);
06299: Name();
06300: } catch (Throwable jjte000) {
06301: if (jjtc000) {
06302: jjtree.clearNodeScope(jjtn000);
06303: jjtc000 = false;
06304: } else {
06305: jjtree.popNode();
06306: }
06307: if (jjte000 instanceof RuntimeException) {
06308: {
06309: if (true)
06310: throw (RuntimeException) jjte000;
06311: }
06312: }
06313: if (jjte000 instanceof ParseException) {
06314: {
06315: if (true)
06316: throw (ParseException) jjte000;
06317: }
06318: }
06319: {
06320: if (true)
06321: throw (Error) jjte000;
06322: }
06323: } finally {
06324: if (jjtc000) {
06325: jjtree.closeNodeScope(jjtn000, true);
06326: jjtreeCloseNodeScope(jjtn000);
06327: }
06328: }
06329: }
06330:
06331: final public void SingleMemberAnnotation() throws ParseException {
06332: /*@bgen(jjtree) SingleMemberAnnotation */
06333: SimpleNode jjtn000 = new SimpleNode(JJTSINGLEMEMBERANNOTATION);
06334: boolean jjtc000 = true;
06335: jjtree.openNodeScope(jjtn000);
06336: jjtreeOpenNodeScope(jjtn000);
06337: try {
06338: jj_consume_token(AT);
06339: Name();
06340: jj_consume_token(LPAREN);
06341: MemberValue();
06342: jj_consume_token(RPAREN);
06343: } catch (Throwable jjte000) {
06344: if (jjtc000) {
06345: jjtree.clearNodeScope(jjtn000);
06346: jjtc000 = false;
06347: } else {
06348: jjtree.popNode();
06349: }
06350: if (jjte000 instanceof RuntimeException) {
06351: {
06352: if (true)
06353: throw (RuntimeException) jjte000;
06354: }
06355: }
06356: if (jjte000 instanceof ParseException) {
06357: {
06358: if (true)
06359: throw (ParseException) jjte000;
06360: }
06361: }
06362: {
06363: if (true)
06364: throw (Error) jjte000;
06365: }
06366: } finally {
06367: if (jjtc000) {
06368: jjtree.closeNodeScope(jjtn000, true);
06369: jjtreeCloseNodeScope(jjtn000);
06370: }
06371: }
06372: }
06373:
06374: final public void MemberValuePairs() throws ParseException {
06375: /*@bgen(jjtree) MemberValuePairs */
06376: SimpleNode jjtn000 = new SimpleNode(JJTMEMBERVALUEPAIRS);
06377: boolean jjtc000 = true;
06378: jjtree.openNodeScope(jjtn000);
06379: jjtreeOpenNodeScope(jjtn000);
06380: try {
06381: MemberValuePair();
06382: label_46: while (true) {
06383: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06384: case COMMA:
06385: ;
06386: break;
06387: default:
06388: break label_46;
06389: }
06390: jj_consume_token(COMMA);
06391: MemberValuePair();
06392: }
06393: } catch (Throwable jjte000) {
06394: if (jjtc000) {
06395: jjtree.clearNodeScope(jjtn000);
06396: jjtc000 = false;
06397: } else {
06398: jjtree.popNode();
06399: }
06400: if (jjte000 instanceof RuntimeException) {
06401: {
06402: if (true)
06403: throw (RuntimeException) jjte000;
06404: }
06405: }
06406: if (jjte000 instanceof ParseException) {
06407: {
06408: if (true)
06409: throw (ParseException) jjte000;
06410: }
06411: }
06412: {
06413: if (true)
06414: throw (Error) jjte000;
06415: }
06416: } finally {
06417: if (jjtc000) {
06418: jjtree.closeNodeScope(jjtn000, true);
06419: jjtreeCloseNodeScope(jjtn000);
06420: }
06421: }
06422: }
06423:
06424: final public void MemberValuePair() throws ParseException {
06425: /*@bgen(jjtree) MemberValuePair */
06426: SimpleNode jjtn000 = new SimpleNode(JJTMEMBERVALUEPAIR);
06427: boolean jjtc000 = true;
06428: jjtree.openNodeScope(jjtn000);
06429: jjtreeOpenNodeScope(jjtn000);
06430: try {
06431: jj_consume_token(IDENTIFIER);
06432: jj_consume_token(ASSIGN);
06433: MemberValue();
06434: } catch (Throwable jjte000) {
06435: if (jjtc000) {
06436: jjtree.clearNodeScope(jjtn000);
06437: jjtc000 = false;
06438: } else {
06439: jjtree.popNode();
06440: }
06441: if (jjte000 instanceof RuntimeException) {
06442: {
06443: if (true)
06444: throw (RuntimeException) jjte000;
06445: }
06446: }
06447: if (jjte000 instanceof ParseException) {
06448: {
06449: if (true)
06450: throw (ParseException) jjte000;
06451: }
06452: }
06453: {
06454: if (true)
06455: throw (Error) jjte000;
06456: }
06457: } finally {
06458: if (jjtc000) {
06459: jjtree.closeNodeScope(jjtn000, true);
06460: jjtreeCloseNodeScope(jjtn000);
06461: }
06462: }
06463: }
06464:
06465: final public void MemberValue() throws ParseException {
06466: /*@bgen(jjtree) MemberValue */
06467: SimpleNode jjtn000 = new SimpleNode(JJTMEMBERVALUE);
06468: boolean jjtc000 = true;
06469: jjtree.openNodeScope(jjtn000);
06470: jjtreeOpenNodeScope(jjtn000);
06471: try {
06472: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06473: case AT:
06474: Annotation();
06475: break;
06476: case LBRACE:
06477: MemberValueArrayInitializer();
06478: break;
06479: case BOOLEAN:
06480: case BYTE:
06481: case CHAR:
06482: case DOUBLE:
06483: case FALSE:
06484: case FLOAT:
06485: case INT:
06486: case LONG:
06487: case NEW:
06488: case NULL:
06489: case SHORT:
06490: case SUPER:
06491: case THIS:
06492: case TRUE:
06493: case VOID:
06494: case INTEGER_LITERAL:
06495: case FLOATING_POINT_LITERAL:
06496: case CHARACTER_LITERAL:
06497: case STRING_LITERAL:
06498: case IDENTIFIER:
06499: case LPAREN:
06500: case BANG:
06501: case TILDE:
06502: case INCR:
06503: case DECR:
06504: case PLUS:
06505: case MINUS:
06506: ConditionalExpression();
06507: break;
06508: default:
06509: jj_consume_token(-1);
06510: throw new ParseException();
06511: }
06512: } catch (Throwable jjte000) {
06513: if (jjtc000) {
06514: jjtree.clearNodeScope(jjtn000);
06515: jjtc000 = false;
06516: } else {
06517: jjtree.popNode();
06518: }
06519: if (jjte000 instanceof RuntimeException) {
06520: {
06521: if (true)
06522: throw (RuntimeException) jjte000;
06523: }
06524: }
06525: if (jjte000 instanceof ParseException) {
06526: {
06527: if (true)
06528: throw (ParseException) jjte000;
06529: }
06530: }
06531: {
06532: if (true)
06533: throw (Error) jjte000;
06534: }
06535: } finally {
06536: if (jjtc000) {
06537: jjtree.closeNodeScope(jjtn000, true);
06538: jjtreeCloseNodeScope(jjtn000);
06539: }
06540: }
06541: }
06542:
06543: final public void MemberValueArrayInitializer()
06544: throws ParseException {
06545: /*@bgen(jjtree) MemberValueArrayInitializer */
06546: SimpleNode jjtn000 = new SimpleNode(
06547: JJTMEMBERVALUEARRAYINITIALIZER);
06548: boolean jjtc000 = true;
06549: jjtree.openNodeScope(jjtn000);
06550: jjtreeOpenNodeScope(jjtn000);
06551: try {
06552: jj_consume_token(LBRACE);
06553: MemberValue();
06554: label_47: while (true) {
06555: if (jj_2_47(2)) {
06556: ;
06557: } else {
06558: break label_47;
06559: }
06560: jj_consume_token(COMMA);
06561: MemberValue();
06562: }
06563: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06564: case COMMA:
06565: jj_consume_token(COMMA);
06566: break;
06567: default:
06568: ;
06569: }
06570: jj_consume_token(RBRACE);
06571: } catch (Throwable jjte000) {
06572: if (jjtc000) {
06573: jjtree.clearNodeScope(jjtn000);
06574: jjtc000 = false;
06575: } else {
06576: jjtree.popNode();
06577: }
06578: if (jjte000 instanceof RuntimeException) {
06579: {
06580: if (true)
06581: throw (RuntimeException) jjte000;
06582: }
06583: }
06584: if (jjte000 instanceof ParseException) {
06585: {
06586: if (true)
06587: throw (ParseException) jjte000;
06588: }
06589: }
06590: {
06591: if (true)
06592: throw (Error) jjte000;
06593: }
06594: } finally {
06595: if (jjtc000) {
06596: jjtree.closeNodeScope(jjtn000, true);
06597: jjtreeCloseNodeScope(jjtn000);
06598: }
06599: }
06600: }
06601:
06602: /* Annotation Types. */
06603: final public void AnnotationTypeDeclaration(int modifiers)
06604: throws ParseException {
06605: /*@bgen(jjtree) AnnotationTypeDeclaration */
06606: SimpleNode jjtn000 = new SimpleNode(
06607: JJTANNOTATIONTYPEDECLARATION);
06608: boolean jjtc000 = true;
06609: jjtree.openNodeScope(jjtn000);
06610: jjtreeOpenNodeScope(jjtn000);
06611: try {
06612: jj_consume_token(AT);
06613: jj_consume_token(INTERFACE);
06614: jj_consume_token(IDENTIFIER);
06615: AnnotationTypeBody();
06616: } catch (Throwable jjte000) {
06617: if (jjtc000) {
06618: jjtree.clearNodeScope(jjtn000);
06619: jjtc000 = false;
06620: } else {
06621: jjtree.popNode();
06622: }
06623: if (jjte000 instanceof RuntimeException) {
06624: {
06625: if (true)
06626: throw (RuntimeException) jjte000;
06627: }
06628: }
06629: if (jjte000 instanceof ParseException) {
06630: {
06631: if (true)
06632: throw (ParseException) jjte000;
06633: }
06634: }
06635: {
06636: if (true)
06637: throw (Error) jjte000;
06638: }
06639: } finally {
06640: if (jjtc000) {
06641: jjtree.closeNodeScope(jjtn000, true);
06642: jjtreeCloseNodeScope(jjtn000);
06643: }
06644: }
06645: }
06646:
06647: final public void AnnotationTypeBody() throws ParseException {
06648: /*@bgen(jjtree) AnnotationTypeBody */
06649: SimpleNode jjtn000 = new SimpleNode(JJTANNOTATIONTYPEBODY);
06650: boolean jjtc000 = true;
06651: jjtree.openNodeScope(jjtn000);
06652: jjtreeOpenNodeScope(jjtn000);
06653: try {
06654: jj_consume_token(LBRACE);
06655: label_48: while (true) {
06656: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06657: case ABSTRACT:
06658: case BOOLEAN:
06659: case BYTE:
06660: case CHAR:
06661: case CLASS:
06662: case DOUBLE:
06663: case ENUM:
06664: case FINAL:
06665: case FLOAT:
06666: case INT:
06667: case INTERFACE:
06668: case LONG:
06669: case NATIVE:
06670: case PRIVATE:
06671: case PROTECTED:
06672: case PUBLIC:
06673: case SHORT:
06674: case STATIC:
06675: case STRICTFP:
06676: case SYNCHRONIZED:
06677: case TRANSIENT:
06678: case VOLATILE:
06679: case IDENTIFIER:
06680: case SEMICOLON:
06681: case AT:
06682: ;
06683: break;
06684: default:
06685: break label_48;
06686: }
06687: AnnotationTypeMemberDeclaration();
06688: }
06689: jj_consume_token(RBRACE);
06690: } catch (Throwable jjte000) {
06691: if (jjtc000) {
06692: jjtree.clearNodeScope(jjtn000);
06693: jjtc000 = false;
06694: } else {
06695: jjtree.popNode();
06696: }
06697: if (jjte000 instanceof RuntimeException) {
06698: {
06699: if (true)
06700: throw (RuntimeException) jjte000;
06701: }
06702: }
06703: if (jjte000 instanceof ParseException) {
06704: {
06705: if (true)
06706: throw (ParseException) jjte000;
06707: }
06708: }
06709: {
06710: if (true)
06711: throw (Error) jjte000;
06712: }
06713: } finally {
06714: if (jjtc000) {
06715: jjtree.closeNodeScope(jjtn000, true);
06716: jjtreeCloseNodeScope(jjtn000);
06717: }
06718: }
06719: }
06720:
06721: final public void AnnotationTypeMemberDeclaration()
06722: throws ParseException {
06723: /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
06724: SimpleNode jjtn000 = new SimpleNode(
06725: JJTANNOTATIONTYPEMEMBERDECLARATION);
06726: boolean jjtc000 = true;
06727: jjtree.openNodeScope(jjtn000);
06728: jjtreeOpenNodeScope(jjtn000);
06729: int modifiers;
06730: try {
06731: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06732: case ABSTRACT:
06733: case BOOLEAN:
06734: case BYTE:
06735: case CHAR:
06736: case CLASS:
06737: case DOUBLE:
06738: case ENUM:
06739: case FINAL:
06740: case FLOAT:
06741: case INT:
06742: case INTERFACE:
06743: case LONG:
06744: case NATIVE:
06745: case PRIVATE:
06746: case PROTECTED:
06747: case PUBLIC:
06748: case SHORT:
06749: case STATIC:
06750: case STRICTFP:
06751: case SYNCHRONIZED:
06752: case TRANSIENT:
06753: case VOLATILE:
06754: case IDENTIFIER:
06755: case AT:
06756: modifiers = Modifiers();
06757: if (jj_2_48(2147483647)) {
06758: Type();
06759: jj_consume_token(IDENTIFIER);
06760: jj_consume_token(LPAREN);
06761: jj_consume_token(RPAREN);
06762: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06763: case _DEFAULT:
06764: DefaultValue();
06765: break;
06766: default:
06767: ;
06768: }
06769: jj_consume_token(SEMICOLON);
06770: } else {
06771: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
06772: case CLASS:
06773: case INTERFACE:
06774: ClassOrInterfaceDeclaration(modifiers);
06775: break;
06776: case ENUM:
06777: EnumDeclaration(modifiers);
06778: break;
06779: case AT:
06780: AnnotationTypeDeclaration(modifiers);
06781: break;
06782: case BOOLEAN:
06783: case BYTE:
06784: case CHAR:
06785: case DOUBLE:
06786: case FLOAT:
06787: case INT:
06788: case LONG:
06789: case SHORT:
06790: case IDENTIFIER:
06791: FieldDeclaration(modifiers);
06792: break;
06793: default:
06794: jj_consume_token(-1);
06795: throw new ParseException();
06796: }
06797: }
06798: break;
06799: case SEMICOLON:
06800: jj_consume_token(SEMICOLON);
06801: break;
06802: default:
06803: jj_consume_token(-1);
06804: throw new ParseException();
06805: }
06806: } catch (Throwable jjte000) {
06807: if (jjtc000) {
06808: jjtree.clearNodeScope(jjtn000);
06809: jjtc000 = false;
06810: } else {
06811: jjtree.popNode();
06812: }
06813: if (jjte000 instanceof RuntimeException) {
06814: {
06815: if (true)
06816: throw (RuntimeException) jjte000;
06817: }
06818: }
06819: if (jjte000 instanceof ParseException) {
06820: {
06821: if (true)
06822: throw (ParseException) jjte000;
06823: }
06824: }
06825: {
06826: if (true)
06827: throw (Error) jjte000;
06828: }
06829: } finally {
06830: if (jjtc000) {
06831: jjtree.closeNodeScope(jjtn000, true);
06832: jjtreeCloseNodeScope(jjtn000);
06833: }
06834: }
06835: }
06836:
06837: final public void DefaultValue() throws ParseException {
06838: /*@bgen(jjtree) DefaultValue */
06839: SimpleNode jjtn000 = new SimpleNode(JJTDEFAULTVALUE);
06840: boolean jjtc000 = true;
06841: jjtree.openNodeScope(jjtn000);
06842: jjtreeOpenNodeScope(jjtn000);
06843: try {
06844: jj_consume_token(_DEFAULT);
06845: MemberValue();
06846: } catch (Throwable jjte000) {
06847: if (jjtc000) {
06848: jjtree.clearNodeScope(jjtn000);
06849: jjtc000 = false;
06850: } else {
06851: jjtree.popNode();
06852: }
06853: if (jjte000 instanceof RuntimeException) {
06854: {
06855: if (true)
06856: throw (RuntimeException) jjte000;
06857: }
06858: }
06859: if (jjte000 instanceof ParseException) {
06860: {
06861: if (true)
06862: throw (ParseException) jjte000;
06863: }
06864: }
06865: {
06866: if (true)
06867: throw (Error) jjte000;
06868: }
06869: } finally {
06870: if (jjtc000) {
06871: jjtree.closeNodeScope(jjtn000, true);
06872: jjtreeCloseNodeScope(jjtn000);
06873: }
06874: }
06875: }
06876:
06877: final private boolean jj_2_1(int xla) {
06878: jj_la = xla;
06879: jj_lastpos = jj_scanpos = token;
06880: try {
06881: return !jj_3_1();
06882: } catch (LookaheadSuccess ls) {
06883: return true;
06884: }
06885: }
06886:
06887: final private boolean jj_2_2(int xla) {
06888: jj_la = xla;
06889: jj_lastpos = jj_scanpos = token;
06890: try {
06891: return !jj_3_2();
06892: } catch (LookaheadSuccess ls) {
06893: return true;
06894: }
06895: }
06896:
06897: final private boolean jj_2_3(int xla) {
06898: jj_la = xla;
06899: jj_lastpos = jj_scanpos = token;
06900: try {
06901: return !jj_3_3();
06902: } catch (LookaheadSuccess ls) {
06903: return true;
06904: }
06905: }
06906:
06907: final private boolean jj_2_4(int xla) {
06908: jj_la = xla;
06909: jj_lastpos = jj_scanpos = token;
06910: try {
06911: return !jj_3_4();
06912: } catch (LookaheadSuccess ls) {
06913: return true;
06914: }
06915: }
06916:
06917: final private boolean jj_2_5(int xla) {
06918: jj_la = xla;
06919: jj_lastpos = jj_scanpos = token;
06920: try {
06921: return !jj_3_5();
06922: } catch (LookaheadSuccess ls) {
06923: return true;
06924: }
06925: }
06926:
06927: final private boolean jj_2_6(int xla) {
06928: jj_la = xla;
06929: jj_lastpos = jj_scanpos = token;
06930: try {
06931: return !jj_3_6();
06932: } catch (LookaheadSuccess ls) {
06933: return true;
06934: }
06935: }
06936:
06937: final private boolean jj_2_7(int xla) {
06938: jj_la = xla;
06939: jj_lastpos = jj_scanpos = token;
06940: try {
06941: return !jj_3_7();
06942: } catch (LookaheadSuccess ls) {
06943: return true;
06944: }
06945: }
06946:
06947: final private boolean jj_2_8(int xla) {
06948: jj_la = xla;
06949: jj_lastpos = jj_scanpos = token;
06950: try {
06951: return !jj_3_8();
06952: } catch (LookaheadSuccess ls) {
06953: return true;
06954: }
06955: }
06956:
06957: final private boolean jj_2_9(int xla) {
06958: jj_la = xla;
06959: jj_lastpos = jj_scanpos = token;
06960: try {
06961: return !jj_3_9();
06962: } catch (LookaheadSuccess ls) {
06963: return true;
06964: }
06965: }
06966:
06967: final private boolean jj_2_10(int xla) {
06968: jj_la = xla;
06969: jj_lastpos = jj_scanpos = token;
06970: try {
06971: return !jj_3_10();
06972: } catch (LookaheadSuccess ls) {
06973: return true;
06974: }
06975: }
06976:
06977: final private boolean jj_2_11(int xla) {
06978: jj_la = xla;
06979: jj_lastpos = jj_scanpos = token;
06980: try {
06981: return !jj_3_11();
06982: } catch (LookaheadSuccess ls) {
06983: return true;
06984: }
06985: }
06986:
06987: final private boolean jj_2_12(int xla) {
06988: jj_la = xla;
06989: jj_lastpos = jj_scanpos = token;
06990: try {
06991: return !jj_3_12();
06992: } catch (LookaheadSuccess ls) {
06993: return true;
06994: }
06995: }
06996:
06997: final private boolean jj_2_13(int xla) {
06998: jj_la = xla;
06999: jj_lastpos = jj_scanpos = token;
07000: try {
07001: return !jj_3_13();
07002: } catch (LookaheadSuccess ls) {
07003: return true;
07004: }
07005: }
07006:
07007: final private boolean jj_2_14(int xla) {
07008: jj_la = xla;
07009: jj_lastpos = jj_scanpos = token;
07010: try {
07011: return !jj_3_14();
07012: } catch (LookaheadSuccess ls) {
07013: return true;
07014: }
07015: }
07016:
07017: final private boolean jj_2_15(int xla) {
07018: jj_la = xla;
07019: jj_lastpos = jj_scanpos = token;
07020: try {
07021: return !jj_3_15();
07022: } catch (LookaheadSuccess ls) {
07023: return true;
07024: }
07025: }
07026:
07027: final private boolean jj_2_16(int xla) {
07028: jj_la = xla;
07029: jj_lastpos = jj_scanpos = token;
07030: try {
07031: return !jj_3_16();
07032: } catch (LookaheadSuccess ls) {
07033: return true;
07034: }
07035: }
07036:
07037: final private boolean jj_2_17(int xla) {
07038: jj_la = xla;
07039: jj_lastpos = jj_scanpos = token;
07040: try {
07041: return !jj_3_17();
07042: } catch (LookaheadSuccess ls) {
07043: return true;
07044: }
07045: }
07046:
07047: final private boolean jj_2_18(int xla) {
07048: jj_la = xla;
07049: jj_lastpos = jj_scanpos = token;
07050: try {
07051: return !jj_3_18();
07052: } catch (LookaheadSuccess ls) {
07053: return true;
07054: }
07055: }
07056:
07057: final private boolean jj_2_19(int xla) {
07058: jj_la = xla;
07059: jj_lastpos = jj_scanpos = token;
07060: try {
07061: return !jj_3_19();
07062: } catch (LookaheadSuccess ls) {
07063: return true;
07064: }
07065: }
07066:
07067: final private boolean jj_2_20(int xla) {
07068: jj_la = xla;
07069: jj_lastpos = jj_scanpos = token;
07070: try {
07071: return !jj_3_20();
07072: } catch (LookaheadSuccess ls) {
07073: return true;
07074: }
07075: }
07076:
07077: final private boolean jj_2_21(int xla) {
07078: jj_la = xla;
07079: jj_lastpos = jj_scanpos = token;
07080: try {
07081: return !jj_3_21();
07082: } catch (LookaheadSuccess ls) {
07083: return true;
07084: }
07085: }
07086:
07087: final private boolean jj_2_22(int xla) {
07088: jj_la = xla;
07089: jj_lastpos = jj_scanpos = token;
07090: try {
07091: return !jj_3_22();
07092: } catch (LookaheadSuccess ls) {
07093: return true;
07094: }
07095: }
07096:
07097: final private boolean jj_2_23(int xla) {
07098: jj_la = xla;
07099: jj_lastpos = jj_scanpos = token;
07100: try {
07101: return !jj_3_23();
07102: } catch (LookaheadSuccess ls) {
07103: return true;
07104: }
07105: }
07106:
07107: final private boolean jj_2_24(int xla) {
07108: jj_la = xla;
07109: jj_lastpos = jj_scanpos = token;
07110: try {
07111: return !jj_3_24();
07112: } catch (LookaheadSuccess ls) {
07113: return true;
07114: }
07115: }
07116:
07117: final private boolean jj_2_25(int xla) {
07118: jj_la = xla;
07119: jj_lastpos = jj_scanpos = token;
07120: try {
07121: return !jj_3_25();
07122: } catch (LookaheadSuccess ls) {
07123: return true;
07124: }
07125: }
07126:
07127: final private boolean jj_2_26(int xla) {
07128: jj_la = xla;
07129: jj_lastpos = jj_scanpos = token;
07130: try {
07131: return !jj_3_26();
07132: } catch (LookaheadSuccess ls) {
07133: return true;
07134: }
07135: }
07136:
07137: final private boolean jj_2_27(int xla) {
07138: jj_la = xla;
07139: jj_lastpos = jj_scanpos = token;
07140: try {
07141: return !jj_3_27();
07142: } catch (LookaheadSuccess ls) {
07143: return true;
07144: }
07145: }
07146:
07147: final private boolean jj_2_28(int xla) {
07148: jj_la = xla;
07149: jj_lastpos = jj_scanpos = token;
07150: try {
07151: return !jj_3_28();
07152: } catch (LookaheadSuccess ls) {
07153: return true;
07154: }
07155: }
07156:
07157: final private boolean jj_2_29(int xla) {
07158: jj_la = xla;
07159: jj_lastpos = jj_scanpos = token;
07160: try {
07161: return !jj_3_29();
07162: } catch (LookaheadSuccess ls) {
07163: return true;
07164: }
07165: }
07166:
07167: final private boolean jj_2_30(int xla) {
07168: jj_la = xla;
07169: jj_lastpos = jj_scanpos = token;
07170: try {
07171: return !jj_3_30();
07172: } catch (LookaheadSuccess ls) {
07173: return true;
07174: }
07175: }
07176:
07177: final private boolean jj_2_31(int xla) {
07178: jj_la = xla;
07179: jj_lastpos = jj_scanpos = token;
07180: try {
07181: return !jj_3_31();
07182: } catch (LookaheadSuccess ls) {
07183: return true;
07184: }
07185: }
07186:
07187: final private boolean jj_2_32(int xla) {
07188: jj_la = xla;
07189: jj_lastpos = jj_scanpos = token;
07190: try {
07191: return !jj_3_32();
07192: } catch (LookaheadSuccess ls) {
07193: return true;
07194: }
07195: }
07196:
07197: final private boolean jj_2_33(int xla) {
07198: jj_la = xla;
07199: jj_lastpos = jj_scanpos = token;
07200: try {
07201: return !jj_3_33();
07202: } catch (LookaheadSuccess ls) {
07203: return true;
07204: }
07205: }
07206:
07207: final private boolean jj_2_34(int xla) {
07208: jj_la = xla;
07209: jj_lastpos = jj_scanpos = token;
07210: try {
07211: return !jj_3_34();
07212: } catch (LookaheadSuccess ls) {
07213: return true;
07214: }
07215: }
07216:
07217: final private boolean jj_2_35(int xla) {
07218: jj_la = xla;
07219: jj_lastpos = jj_scanpos = token;
07220: try {
07221: return !jj_3_35();
07222: } catch (LookaheadSuccess ls) {
07223: return true;
07224: }
07225: }
07226:
07227: final private boolean jj_2_36(int xla) {
07228: jj_la = xla;
07229: jj_lastpos = jj_scanpos = token;
07230: try {
07231: return !jj_3_36();
07232: } catch (LookaheadSuccess ls) {
07233: return true;
07234: }
07235: }
07236:
07237: final private boolean jj_2_37(int xla) {
07238: jj_la = xla;
07239: jj_lastpos = jj_scanpos = token;
07240: try {
07241: return !jj_3_37();
07242: } catch (LookaheadSuccess ls) {
07243: return true;
07244: }
07245: }
07246:
07247: final private boolean jj_2_38(int xla) {
07248: jj_la = xla;
07249: jj_lastpos = jj_scanpos = token;
07250: try {
07251: return !jj_3_38();
07252: } catch (LookaheadSuccess ls) {
07253: return true;
07254: }
07255: }
07256:
07257: final private boolean jj_2_39(int xla) {
07258: jj_la = xla;
07259: jj_lastpos = jj_scanpos = token;
07260: try {
07261: return !jj_3_39();
07262: } catch (LookaheadSuccess ls) {
07263: return true;
07264: }
07265: }
07266:
07267: final private boolean jj_2_40(int xla) {
07268: jj_la = xla;
07269: jj_lastpos = jj_scanpos = token;
07270: try {
07271: return !jj_3_40();
07272: } catch (LookaheadSuccess ls) {
07273: return true;
07274: }
07275: }
07276:
07277: final private boolean jj_2_41(int xla) {
07278: jj_la = xla;
07279: jj_lastpos = jj_scanpos = token;
07280: try {
07281: return !jj_3_41();
07282: } catch (LookaheadSuccess ls) {
07283: return true;
07284: }
07285: }
07286:
07287: final private boolean jj_2_42(int xla) {
07288: jj_la = xla;
07289: jj_lastpos = jj_scanpos = token;
07290: try {
07291: return !jj_3_42();
07292: } catch (LookaheadSuccess ls) {
07293: return true;
07294: }
07295: }
07296:
07297: final private boolean jj_2_43(int xla) {
07298: jj_la = xla;
07299: jj_lastpos = jj_scanpos = token;
07300: try {
07301: return !jj_3_43();
07302: } catch (LookaheadSuccess ls) {
07303: return true;
07304: }
07305: }
07306:
07307: final private boolean jj_2_44(int xla) {
07308: jj_la = xla;
07309: jj_lastpos = jj_scanpos = token;
07310: try {
07311: return !jj_3_44();
07312: } catch (LookaheadSuccess ls) {
07313: return true;
07314: }
07315: }
07316:
07317: final private boolean jj_2_45(int xla) {
07318: jj_la = xla;
07319: jj_lastpos = jj_scanpos = token;
07320: try {
07321: return !jj_3_45();
07322: } catch (LookaheadSuccess ls) {
07323: return true;
07324: }
07325: }
07326:
07327: final private boolean jj_2_46(int xla) {
07328: jj_la = xla;
07329: jj_lastpos = jj_scanpos = token;
07330: try {
07331: return !jj_3_46();
07332: } catch (LookaheadSuccess ls) {
07333: return true;
07334: }
07335: }
07336:
07337: final private boolean jj_2_47(int xla) {
07338: jj_la = xla;
07339: jj_lastpos = jj_scanpos = token;
07340: try {
07341: return !jj_3_47();
07342: } catch (LookaheadSuccess ls) {
07343: return true;
07344: }
07345: }
07346:
07347: final private boolean jj_2_48(int xla) {
07348: jj_la = xla;
07349: jj_lastpos = jj_scanpos = token;
07350: try {
07351: return !jj_3_48();
07352: } catch (LookaheadSuccess ls) {
07353: return true;
07354: }
07355: }
07356:
07357: final private boolean jj_3R_56() {
07358: if (jj_3R_101())
07359: return true;
07360: Token xsp;
07361: xsp = jj_scanpos;
07362: if (jj_3_21())
07363: jj_scanpos = xsp;
07364: return false;
07365: }
07366:
07367: final private boolean jj_3R_135() {
07368: if (jj_scan_token(COMMA))
07369: return true;
07370: if (jj_3R_91())
07371: return true;
07372: return false;
07373: }
07374:
07375: final private boolean jj_3R_99() {
07376: if (jj_3R_91())
07377: return true;
07378: Token xsp;
07379: while (true) {
07380: xsp = jj_scanpos;
07381: if (jj_3R_135()) {
07382: jj_scanpos = xsp;
07383: break;
07384: }
07385: }
07386: return false;
07387: }
07388:
07389: final private boolean jj_3_20() {
07390: if (jj_scan_token(DOT))
07391: return true;
07392: if (jj_scan_token(IDENTIFIER))
07393: return true;
07394: return false;
07395: }
07396:
07397: final private boolean jj_3R_91() {
07398: if (jj_scan_token(IDENTIFIER))
07399: return true;
07400: Token xsp;
07401: while (true) {
07402: xsp = jj_scanpos;
07403: if (jj_3_20()) {
07404: jj_scanpos = xsp;
07405: break;
07406: }
07407: }
07408: return false;
07409: }
07410:
07411: final private boolean jj_3R_122() {
07412: if (jj_3R_72())
07413: return true;
07414: return false;
07415: }
07416:
07417: final private boolean jj_3R_86() {
07418: Token xsp;
07419: xsp = jj_scanpos;
07420: if (jj_scan_token(58)) {
07421: jj_scanpos = xsp;
07422: if (jj_3R_122())
07423: return true;
07424: }
07425: return false;
07426: }
07427:
07428: final private boolean jj_3_19() {
07429: if (jj_3R_78())
07430: return true;
07431: return false;
07432: }
07433:
07434: final private boolean jj_3R_83() {
07435: Token xsp;
07436: xsp = jj_scanpos;
07437: if (jj_scan_token(10)) {
07438: jj_scanpos = xsp;
07439: if (jj_scan_token(15)) {
07440: jj_scanpos = xsp;
07441: if (jj_scan_token(12)) {
07442: jj_scanpos = xsp;
07443: if (jj_scan_token(46)) {
07444: jj_scanpos = xsp;
07445: if (jj_scan_token(35)) {
07446: jj_scanpos = xsp;
07447: if (jj_scan_token(37)) {
07448: jj_scanpos = xsp;
07449: if (jj_scan_token(28)) {
07450: jj_scanpos = xsp;
07451: if (jj_scan_token(21))
07452: return true;
07453: }
07454: }
07455: }
07456: }
07457: }
07458: }
07459: }
07460: return false;
07461: }
07462:
07463: final private boolean jj_3R_194() {
07464: if (jj_scan_token(COMMA))
07465: return true;
07466: if (jj_3R_112())
07467: return true;
07468: return false;
07469: }
07470:
07471: final private boolean jj_3R_290() {
07472: if (jj_scan_token(SUPER))
07473: return true;
07474: if (jj_3R_77())
07475: return true;
07476: return false;
07477: }
07478:
07479: final private boolean jj_3_16() {
07480: if (jj_scan_token(LBRACKET))
07481: return true;
07482: if (jj_scan_token(RBRACKET))
07483: return true;
07484: return false;
07485: }
07486:
07487: final private boolean jj_3R_289() {
07488: if (jj_scan_token(EXTENDS))
07489: return true;
07490: if (jj_3R_77())
07491: return true;
07492: return false;
07493: }
07494:
07495: final private boolean jj_3R_277() {
07496: Token xsp;
07497: xsp = jj_scanpos;
07498: if (jj_3R_289()) {
07499: jj_scanpos = xsp;
07500: if (jj_3R_290())
07501: return true;
07502: }
07503: return false;
07504: }
07505:
07506: final private boolean jj_3R_256() {
07507: if (jj_3R_277())
07508: return true;
07509: return false;
07510: }
07511:
07512: final private boolean jj_3R_151() {
07513: if (jj_scan_token(HOOK))
07514: return true;
07515: Token xsp;
07516: xsp = jj_scanpos;
07517: if (jj_3R_256())
07518: jj_scanpos = xsp;
07519: return false;
07520: }
07521:
07522: final private boolean jj_3_17() {
07523: if (jj_3R_78())
07524: return true;
07525: return false;
07526: }
07527:
07528: final private boolean jj_3R_112() {
07529: Token xsp;
07530: xsp = jj_scanpos;
07531: if (jj_3R_150()) {
07532: jj_scanpos = xsp;
07533: if (jj_3R_151())
07534: return true;
07535: }
07536: return false;
07537: }
07538:
07539: final private boolean jj_3R_150() {
07540: if (jj_3R_77())
07541: return true;
07542: return false;
07543: }
07544:
07545: final private boolean jj_3_15() {
07546: if (jj_scan_token(LBRACKET))
07547: return true;
07548: if (jj_scan_token(RBRACKET))
07549: return true;
07550: return false;
07551: }
07552:
07553: final private boolean jj_3R_78() {
07554: if (jj_scan_token(LT))
07555: return true;
07556: if (jj_3R_112())
07557: return true;
07558: Token xsp;
07559: while (true) {
07560: xsp = jj_scanpos;
07561: if (jj_3R_194()) {
07562: jj_scanpos = xsp;
07563: break;
07564: }
07565: }
07566: if (jj_scan_token(GT))
07567: return true;
07568: return false;
07569: }
07570:
07571: final private boolean jj_3_18() {
07572: if (jj_scan_token(DOT))
07573: return true;
07574: if (jj_scan_token(IDENTIFIER))
07575: return true;
07576: Token xsp;
07577: xsp = jj_scanpos;
07578: if (jj_3_19())
07579: jj_scanpos = xsp;
07580: return false;
07581: }
07582:
07583: final private boolean jj_3R_149() {
07584: if (jj_scan_token(IDENTIFIER))
07585: return true;
07586: Token xsp;
07587: xsp = jj_scanpos;
07588: if (jj_3_17())
07589: jj_scanpos = xsp;
07590: while (true) {
07591: xsp = jj_scanpos;
07592: if (jj_3_18()) {
07593: jj_scanpos = xsp;
07594: break;
07595: }
07596: }
07597: return false;
07598: }
07599:
07600: final private boolean jj_3R_111() {
07601: if (jj_3R_149())
07602: return true;
07603: Token xsp;
07604: while (true) {
07605: xsp = jj_scanpos;
07606: if (jj_3_16()) {
07607: jj_scanpos = xsp;
07608: break;
07609: }
07610: }
07611: return false;
07612: }
07613:
07614: final private boolean jj_3R_110() {
07615: if (jj_3R_83())
07616: return true;
07617: Token xsp;
07618: if (jj_3_15())
07619: return true;
07620: while (true) {
07621: xsp = jj_scanpos;
07622: if (jj_3_15()) {
07623: jj_scanpos = xsp;
07624: break;
07625: }
07626: }
07627: return false;
07628: }
07629:
07630: final private boolean jj_3R_77() {
07631: Token xsp;
07632: xsp = jj_scanpos;
07633: if (jj_3R_110()) {
07634: jj_scanpos = xsp;
07635: if (jj_3R_111())
07636: return true;
07637: }
07638: return false;
07639: }
07640:
07641: final private boolean jj_3_13() {
07642: if (jj_scan_token(THIS))
07643: return true;
07644: if (jj_scan_token(DOT))
07645: return true;
07646: return false;
07647: }
07648:
07649: final private boolean jj_3R_221() {
07650: if (jj_scan_token(THROWS))
07651: return true;
07652: if (jj_3R_99())
07653: return true;
07654: return false;
07655: }
07656:
07657: final private boolean jj_3R_103() {
07658: if (jj_3R_83())
07659: return true;
07660: return false;
07661: }
07662:
07663: final private boolean jj_3R_72() {
07664: Token xsp;
07665: xsp = jj_scanpos;
07666: if (jj_3_14()) {
07667: jj_scanpos = xsp;
07668: if (jj_3R_103())
07669: return true;
07670: }
07671: return false;
07672: }
07673:
07674: final private boolean jj_3_14() {
07675: if (jj_3R_77())
07676: return true;
07677: return false;
07678: }
07679:
07680: final private boolean jj_3R_74() {
07681: Token xsp;
07682: xsp = jj_scanpos;
07683: if (jj_scan_token(47))
07684: jj_scanpos = xsp;
07685: if (jj_3R_104())
07686: return true;
07687: return false;
07688: }
07689:
07690: final private boolean jj_3_12() {
07691: if (jj_3R_76())
07692: return true;
07693: return false;
07694: }
07695:
07696: final private boolean jj_3R_108() {
07697: if (jj_3R_78())
07698: return true;
07699: return false;
07700: }
07701:
07702: final private boolean jj_3R_107() {
07703: if (jj_scan_token(IDENTIFIER))
07704: return true;
07705: if (jj_scan_token(DOT))
07706: return true;
07707: return false;
07708: }
07709:
07710: final private boolean jj_3R_252() {
07711: if (jj_scan_token(LBRACKET))
07712: return true;
07713: if (jj_scan_token(RBRACKET))
07714: return true;
07715: return false;
07716: }
07717:
07718: final private boolean jj_3R_76() {
07719: Token xsp;
07720: while (true) {
07721: xsp = jj_scanpos;
07722: if (jj_3R_107()) {
07723: jj_scanpos = xsp;
07724: break;
07725: }
07726: }
07727: xsp = jj_scanpos;
07728: if (jj_3_13())
07729: jj_scanpos = xsp;
07730: xsp = jj_scanpos;
07731: if (jj_3R_108())
07732: jj_scanpos = xsp;
07733: xsp = jj_scanpos;
07734: if (jj_scan_token(52)) {
07735: jj_scanpos = xsp;
07736: if (jj_scan_token(49))
07737: return true;
07738: }
07739: if (jj_3R_109())
07740: return true;
07741: if (jj_scan_token(SEMICOLON))
07742: return true;
07743: return false;
07744: }
07745:
07746: final private boolean jj_3R_134() {
07747: if (jj_scan_token(COMMA))
07748: return true;
07749: if (jj_3R_133())
07750: return true;
07751: return false;
07752: }
07753:
07754: final private boolean jj_3R_223() {
07755: if (jj_3R_49())
07756: return true;
07757: return false;
07758: }
07759:
07760: final private boolean jj_3R_222() {
07761: if (jj_3R_76())
07762: return true;
07763: return false;
07764: }
07765:
07766: final private boolean jj_3R_220() {
07767: if (jj_3R_97())
07768: return true;
07769: return false;
07770: }
07771:
07772: final private boolean jj_3R_186() {
07773: Token xsp;
07774: xsp = jj_scanpos;
07775: if (jj_3R_220())
07776: jj_scanpos = xsp;
07777: if (jj_scan_token(IDENTIFIER))
07778: return true;
07779: if (jj_3R_53())
07780: return true;
07781: xsp = jj_scanpos;
07782: if (jj_3R_221())
07783: jj_scanpos = xsp;
07784: if (jj_scan_token(LBRACE))
07785: return true;
07786: xsp = jj_scanpos;
07787: if (jj_3R_222())
07788: jj_scanpos = xsp;
07789: while (true) {
07790: xsp = jj_scanpos;
07791: if (jj_3R_223()) {
07792: jj_scanpos = xsp;
07793: break;
07794: }
07795: }
07796: if (jj_scan_token(RBRACE))
07797: return true;
07798: return false;
07799: }
07800:
07801: final private boolean jj_3_11() {
07802: if (jj_scan_token(COMMA))
07803: return true;
07804: if (jj_3R_75())
07805: return true;
07806: return false;
07807: }
07808:
07809: final private boolean jj_3R_227() {
07810: if (jj_scan_token(THROWS))
07811: return true;
07812: if (jj_3R_99())
07813: return true;
07814: return false;
07815: }
07816:
07817: final private boolean jj_3R_98() {
07818: if (jj_3R_133())
07819: return true;
07820: Token xsp;
07821: while (true) {
07822: xsp = jj_scanpos;
07823: if (jj_3R_134()) {
07824: jj_scanpos = xsp;
07825: break;
07826: }
07827: }
07828: return false;
07829: }
07830:
07831: final private boolean jj_3R_133() {
07832: if (jj_3R_50())
07833: return true;
07834: if (jj_3R_72())
07835: return true;
07836: Token xsp;
07837: xsp = jj_scanpos;
07838: if (jj_scan_token(119))
07839: jj_scanpos = xsp;
07840: if (jj_3R_184())
07841: return true;
07842: return false;
07843: }
07844:
07845: final private boolean jj_3R_53() {
07846: if (jj_scan_token(LPAREN))
07847: return true;
07848: Token xsp;
07849: xsp = jj_scanpos;
07850: if (jj_3R_98())
07851: jj_scanpos = xsp;
07852: if (jj_scan_token(RPAREN))
07853: return true;
07854: return false;
07855: }
07856:
07857: final private boolean jj_3_48() {
07858: if (jj_3R_72())
07859: return true;
07860: if (jj_scan_token(IDENTIFIER))
07861: return true;
07862: if (jj_scan_token(LPAREN))
07863: return true;
07864: return false;
07865: }
07866:
07867: final private boolean jj_3R_226() {
07868: if (jj_scan_token(IDENTIFIER))
07869: return true;
07870: if (jj_3R_53())
07871: return true;
07872: Token xsp;
07873: while (true) {
07874: xsp = jj_scanpos;
07875: if (jj_3R_252()) {
07876: jj_scanpos = xsp;
07877: break;
07878: }
07879: }
07880: return false;
07881: }
07882:
07883: final private boolean jj_3R_228() {
07884: if (jj_3R_104())
07885: return true;
07886: return false;
07887: }
07888:
07889: final private boolean jj_3R_225() {
07890: if (jj_3R_97())
07891: return true;
07892: return false;
07893: }
07894:
07895: final private boolean jj_3R_292() {
07896: if (jj_3R_75())
07897: return true;
07898: Token xsp;
07899: while (true) {
07900: xsp = jj_scanpos;
07901: if (jj_3_11()) {
07902: jj_scanpos = xsp;
07903: break;
07904: }
07905: }
07906: return false;
07907: }
07908:
07909: final private boolean jj_3R_188() {
07910: Token xsp;
07911: xsp = jj_scanpos;
07912: if (jj_3R_225())
07913: jj_scanpos = xsp;
07914: if (jj_3R_86())
07915: return true;
07916: if (jj_3R_226())
07917: return true;
07918: xsp = jj_scanpos;
07919: if (jj_3R_227())
07920: jj_scanpos = xsp;
07921: xsp = jj_scanpos;
07922: if (jj_3R_228()) {
07923: jj_scanpos = xsp;
07924: if (jj_scan_token(81))
07925: return true;
07926: }
07927: return false;
07928: }
07929:
07930: final private boolean jj_3R_198() {
07931: if (jj_scan_token(ASSIGN))
07932: return true;
07933: if (jj_3R_75())
07934: return true;
07935: return false;
07936: }
07937:
07938: final private boolean jj_3R_224() {
07939: if (jj_scan_token(COMMA))
07940: return true;
07941: if (jj_3R_161())
07942: return true;
07943: return false;
07944: }
07945:
07946: final private boolean jj_3_47() {
07947: if (jj_scan_token(COMMA))
07948: return true;
07949: if (jj_3R_93())
07950: return true;
07951: return false;
07952: }
07953:
07954: final private boolean jj_3R_217() {
07955: if (jj_scan_token(LBRACKET))
07956: return true;
07957: if (jj_scan_token(RBRACKET))
07958: return true;
07959: return false;
07960: }
07961:
07962: final private boolean jj_3R_147() {
07963: if (jj_scan_token(LBRACE))
07964: return true;
07965: Token xsp;
07966: xsp = jj_scanpos;
07967: if (jj_3R_292())
07968: jj_scanpos = xsp;
07969: xsp = jj_scanpos;
07970: if (jj_scan_token(82))
07971: jj_scanpos = xsp;
07972: if (jj_scan_token(RBRACE))
07973: return true;
07974: return false;
07975: }
07976:
07977: final private boolean jj_3R_73() {
07978: if (jj_scan_token(LBRACKET))
07979: return true;
07980: if (jj_scan_token(RBRACKET))
07981: return true;
07982: return false;
07983: }
07984:
07985: final private boolean jj_3R_106() {
07986: if (jj_3R_56())
07987: return true;
07988: return false;
07989: }
07990:
07991: final private boolean jj_3R_105() {
07992: if (jj_3R_147())
07993: return true;
07994: return false;
07995: }
07996:
07997: final private boolean jj_3R_75() {
07998: Token xsp;
07999: xsp = jj_scanpos;
08000: if (jj_3R_105()) {
08001: jj_scanpos = xsp;
08002: if (jj_3R_106())
08003: return true;
08004: }
08005: return false;
08006: }
08007:
08008: final private boolean jj_3R_184() {
08009: if (jj_scan_token(IDENTIFIER))
08010: return true;
08011: Token xsp;
08012: while (true) {
08013: xsp = jj_scanpos;
08014: if (jj_3R_217()) {
08015: jj_scanpos = xsp;
08016: break;
08017: }
08018: }
08019: return false;
08020: }
08021:
08022: final private boolean jj_3R_160() {
08023: if (jj_scan_token(LBRACE))
08024: return true;
08025: if (jj_3R_93())
08026: return true;
08027: Token xsp;
08028: while (true) {
08029: xsp = jj_scanpos;
08030: if (jj_3_47()) {
08031: jj_scanpos = xsp;
08032: break;
08033: }
08034: }
08035: xsp = jj_scanpos;
08036: if (jj_scan_token(82))
08037: jj_scanpos = xsp;
08038: if (jj_scan_token(RBRACE))
08039: return true;
08040: return false;
08041: }
08042:
08043: final private boolean jj_3R_276() {
08044: if (jj_scan_token(COMMA))
08045: return true;
08046: if (jj_3R_275())
08047: return true;
08048: return false;
08049: }
08050:
08051: final private boolean jj_3R_161() {
08052: if (jj_3R_184())
08053: return true;
08054: Token xsp;
08055: xsp = jj_scanpos;
08056: if (jj_3R_198())
08057: jj_scanpos = xsp;
08058: return false;
08059: }
08060:
08061: final private boolean jj_3R_127() {
08062: if (jj_3R_101())
08063: return true;
08064: return false;
08065: }
08066:
08067: final private boolean jj_3_9() {
08068: if (jj_3R_72())
08069: return true;
08070: if (jj_scan_token(IDENTIFIER))
08071: return true;
08072: Token xsp;
08073: while (true) {
08074: xsp = jj_scanpos;
08075: if (jj_3R_73()) {
08076: jj_scanpos = xsp;
08077: break;
08078: }
08079: }
08080: xsp = jj_scanpos;
08081: if (jj_scan_token(82)) {
08082: jj_scanpos = xsp;
08083: if (jj_scan_token(85)) {
08084: jj_scanpos = xsp;
08085: if (jj_scan_token(81))
08086: return true;
08087: }
08088: }
08089: return false;
08090: }
08091:
08092: final private boolean jj_3R_126() {
08093: if (jj_3R_160())
08094: return true;
08095: return false;
08096: }
08097:
08098: final private boolean jj_3R_71() {
08099: if (jj_3R_97())
08100: return true;
08101: return false;
08102: }
08103:
08104: final private boolean jj_3R_93() {
08105: Token xsp;
08106: xsp = jj_scanpos;
08107: if (jj_3R_125()) {
08108: jj_scanpos = xsp;
08109: if (jj_3R_126()) {
08110: jj_scanpos = xsp;
08111: if (jj_3R_127())
08112: return true;
08113: }
08114: }
08115: return false;
08116: }
08117:
08118: final private boolean jj_3R_125() {
08119: if (jj_3R_102())
08120: return true;
08121: return false;
08122: }
08123:
08124: final private boolean jj_3_8() {
08125: Token xsp;
08126: xsp = jj_scanpos;
08127: if (jj_3R_71())
08128: jj_scanpos = xsp;
08129: if (jj_scan_token(IDENTIFIER))
08130: return true;
08131: if (jj_scan_token(LPAREN))
08132: return true;
08133: return false;
08134: }
08135:
08136: final private boolean jj_3R_187() {
08137: if (jj_3R_72())
08138: return true;
08139: if (jj_3R_161())
08140: return true;
08141: Token xsp;
08142: while (true) {
08143: xsp = jj_scanpos;
08144: if (jj_3R_224()) {
08145: jj_scanpos = xsp;
08146: break;
08147: }
08148: }
08149: if (jj_scan_token(SEMICOLON))
08150: return true;
08151: return false;
08152: }
08153:
08154: final private boolean jj_3R_275() {
08155: if (jj_scan_token(IDENTIFIER))
08156: return true;
08157: if (jj_scan_token(ASSIGN))
08158: return true;
08159: if (jj_3R_93())
08160: return true;
08161: return false;
08162: }
08163:
08164: final private boolean jj_3R_140() {
08165: if (jj_3R_188())
08166: return true;
08167: return false;
08168: }
08169:
08170: final private boolean jj_3R_139() {
08171: if (jj_3R_187())
08172: return true;
08173: return false;
08174: }
08175:
08176: final private boolean jj_3R_249() {
08177: if (jj_scan_token(BIT_AND))
08178: return true;
08179: if (jj_3R_149())
08180: return true;
08181: return false;
08182: }
08183:
08184: final private boolean jj_3R_138() {
08185: if (jj_3R_186())
08186: return true;
08187: return false;
08188: }
08189:
08190: final private boolean jj_3R_255() {
08191: if (jj_3R_275())
08192: return true;
08193: Token xsp;
08194: while (true) {
08195: xsp = jj_scanpos;
08196: if (jj_3R_276()) {
08197: jj_scanpos = xsp;
08198: break;
08199: }
08200: }
08201: return false;
08202: }
08203:
08204: final private boolean jj_3R_231() {
08205: if (jj_3R_255())
08206: return true;
08207: return false;
08208: }
08209:
08210: final private boolean jj_3R_137() {
08211: if (jj_3R_185())
08212: return true;
08213: return false;
08214: }
08215:
08216: final private boolean jj_3R_92() {
08217: if (jj_scan_token(IDENTIFIER))
08218: return true;
08219: if (jj_scan_token(ASSIGN))
08220: return true;
08221: return false;
08222: }
08223:
08224: final private boolean jj_3R_136() {
08225: if (jj_3R_130())
08226: return true;
08227: return false;
08228: }
08229:
08230: final private boolean jj_3R_192() {
08231: if (jj_scan_token(AT))
08232: return true;
08233: if (jj_3R_91())
08234: return true;
08235: if (jj_scan_token(LPAREN))
08236: return true;
08237: if (jj_3R_93())
08238: return true;
08239: if (jj_scan_token(RPAREN))
08240: return true;
08241: return false;
08242: }
08243:
08244: final private boolean jj_3R_286() {
08245: if (jj_3R_182())
08246: return true;
08247: return false;
08248: }
08249:
08250: final private boolean jj_3R_100() {
08251: if (jj_3R_50())
08252: return true;
08253: Token xsp;
08254: xsp = jj_scanpos;
08255: if (jj_3R_136()) {
08256: jj_scanpos = xsp;
08257: if (jj_3R_137()) {
08258: jj_scanpos = xsp;
08259: if (jj_3R_138()) {
08260: jj_scanpos = xsp;
08261: if (jj_3R_139()) {
08262: jj_scanpos = xsp;
08263: if (jj_3R_140())
08264: return true;
08265: }
08266: }
08267: }
08268: }
08269: return false;
08270: }
08271:
08272: final private boolean jj_3R_193() {
08273: if (jj_scan_token(AT))
08274: return true;
08275: if (jj_3R_91())
08276: return true;
08277: return false;
08278: }
08279:
08280: final private boolean jj_3_46() {
08281: if (jj_scan_token(AT))
08282: return true;
08283: if (jj_3R_91())
08284: return true;
08285: if (jj_scan_token(LPAREN))
08286: return true;
08287: return false;
08288: }
08289:
08290: final private boolean jj_3_10() {
08291: if (jj_3R_74())
08292: return true;
08293: return false;
08294: }
08295:
08296: final private boolean jj_3R_55() {
08297: Token xsp;
08298: xsp = jj_scanpos;
08299: if (jj_3_10()) {
08300: jj_scanpos = xsp;
08301: if (jj_3R_100()) {
08302: jj_scanpos = xsp;
08303: if (jj_scan_token(81))
08304: return true;
08305: }
08306: }
08307: return false;
08308: }
08309:
08310: final private boolean jj_3R_191() {
08311: if (jj_scan_token(AT))
08312: return true;
08313: if (jj_3R_91())
08314: return true;
08315: if (jj_scan_token(LPAREN))
08316: return true;
08317: Token xsp;
08318: xsp = jj_scanpos;
08319: if (jj_3R_231())
08320: jj_scanpos = xsp;
08321: if (jj_scan_token(RPAREN))
08322: return true;
08323: return false;
08324: }
08325:
08326: final private boolean jj_3_45() {
08327: if (jj_scan_token(AT))
08328: return true;
08329: if (jj_3R_91())
08330: return true;
08331: if (jj_scan_token(LPAREN))
08332: return true;
08333: Token xsp;
08334: xsp = jj_scanpos;
08335: if (jj_3R_92()) {
08336: jj_scanpos = xsp;
08337: if (jj_scan_token(76))
08338: return true;
08339: }
08340: return false;
08341: }
08342:
08343: final private boolean jj_3R_215() {
08344: if (jj_3R_55())
08345: return true;
08346: return false;
08347: }
08348:
08349: final private boolean jj_3R_132() {
08350: if (jj_scan_token(COMMA))
08351: return true;
08352: if (jj_3R_131())
08353: return true;
08354: return false;
08355: }
08356:
08357: final private boolean jj_3R_183() {
08358: if (jj_3R_216())
08359: return true;
08360: return false;
08361: }
08362:
08363: final private boolean jj_3R_285() {
08364: if (jj_3R_109())
08365: return true;
08366: return false;
08367: }
08368:
08369: final private boolean jj_3R_145() {
08370: if (jj_3R_193())
08371: return true;
08372: return false;
08373: }
08374:
08375: final private boolean jj_3R_182() {
08376: if (jj_scan_token(LBRACE))
08377: return true;
08378: Token xsp;
08379: while (true) {
08380: xsp = jj_scanpos;
08381: if (jj_3R_215()) {
08382: jj_scanpos = xsp;
08383: break;
08384: }
08385: }
08386: if (jj_scan_token(RBRACE))
08387: return true;
08388: return false;
08389: }
08390:
08391: final private boolean jj_3R_144() {
08392: if (jj_3R_192())
08393: return true;
08394: return false;
08395: }
08396:
08397: final private boolean jj_3R_113() {
08398: return false;
08399: }
08400:
08401: final private boolean jj_3R_102() {
08402: Token xsp;
08403: xsp = jj_scanpos;
08404: if (jj_3R_143()) {
08405: jj_scanpos = xsp;
08406: if (jj_3R_144()) {
08407: jj_scanpos = xsp;
08408: if (jj_3R_145())
08409: return true;
08410: }
08411: }
08412: return false;
08413: }
08414:
08415: final private boolean jj_3R_143() {
08416: if (jj_3R_191())
08417: return true;
08418: return false;
08419: }
08420:
08421: final private boolean jj_3R_216() {
08422: if (jj_scan_token(EXTENDS))
08423: return true;
08424: if (jj_3R_149())
08425: return true;
08426: Token xsp;
08427: while (true) {
08428: xsp = jj_scanpos;
08429: if (jj_3R_249()) {
08430: jj_scanpos = xsp;
08431: break;
08432: }
08433: }
08434: return false;
08435: }
08436:
08437: final private boolean jj_3R_131() {
08438: if (jj_scan_token(IDENTIFIER))
08439: return true;
08440: Token xsp;
08441: xsp = jj_scanpos;
08442: if (jj_3R_183())
08443: jj_scanpos = xsp;
08444: return false;
08445: }
08446:
08447: final private boolean jj_3R_114() {
08448: return false;
08449: }
08450:
08451: final private boolean jj_3_7() {
08452: if (jj_scan_token(COMMA))
08453: return true;
08454: if (jj_3R_70())
08455: return true;
08456: return false;
08457: }
08458:
08459: final private boolean jj_3R_80() {
08460: Token xsp;
08461: xsp = jj_scanpos;
08462: lookingAhead = true;
08463: jj_semLA = getToken(1).kind == GT
08464: && ((Token.GTToken) getToken(1)).realKind == RSIGNEDSHIFT;
08465: lookingAhead = false;
08466: if (!jj_semLA || jj_3R_113())
08467: return true;
08468: if (jj_scan_token(GT))
08469: return true;
08470: if (jj_scan_token(GT))
08471: return true;
08472: return false;
08473: }
08474:
08475: final private boolean jj_3R_97() {
08476: if (jj_scan_token(LT))
08477: return true;
08478: if (jj_3R_131())
08479: return true;
08480: Token xsp;
08481: while (true) {
08482: xsp = jj_scanpos;
08483: if (jj_3R_132()) {
08484: jj_scanpos = xsp;
08485: break;
08486: }
08487: }
08488: if (jj_scan_token(GT))
08489: return true;
08490: return false;
08491: }
08492:
08493: final private boolean jj_3R_272() {
08494: if (jj_3R_55())
08495: return true;
08496: return false;
08497: }
08498:
08499: final private boolean jj_3R_70() {
08500: if (jj_3R_50())
08501: return true;
08502: if (jj_scan_token(IDENTIFIER))
08503: return true;
08504: Token xsp;
08505: xsp = jj_scanpos;
08506: if (jj_3R_285())
08507: jj_scanpos = xsp;
08508: xsp = jj_scanpos;
08509: if (jj_3R_286())
08510: jj_scanpos = xsp;
08511: return false;
08512: }
08513:
08514: final private boolean jj_3R_81() {
08515: Token xsp;
08516: xsp = jj_scanpos;
08517: lookingAhead = true;
08518: jj_semLA = getToken(1).kind == GT
08519: && ((Token.GTToken) getToken(1)).realKind == RUNSIGNEDSHIFT;
08520: lookingAhead = false;
08521: if (!jj_semLA || jj_3R_114())
08522: return true;
08523: if (jj_scan_token(GT))
08524: return true;
08525: if (jj_scan_token(GT))
08526: return true;
08527: if (jj_scan_token(GT))
08528: return true;
08529: return false;
08530: }
08531:
08532: final private boolean jj_3R_251() {
08533: if (jj_scan_token(SEMICOLON))
08534: return true;
08535: Token xsp;
08536: while (true) {
08537: xsp = jj_scanpos;
08538: if (jj_3R_272()) {
08539: jj_scanpos = xsp;
08540: break;
08541: }
08542: }
08543: return false;
08544: }
08545:
08546: final private boolean jj_3R_250() {
08547: if (jj_3R_70())
08548: return true;
08549: Token xsp;
08550: while (true) {
08551: xsp = jj_scanpos;
08552: if (jj_3_7()) {
08553: jj_scanpos = xsp;
08554: break;
08555: }
08556: }
08557: return false;
08558: }
08559:
08560: final private boolean jj_3R_246() {
08561: if (jj_scan_token(FINALLY))
08562: return true;
08563: if (jj_3R_104())
08564: return true;
08565: return false;
08566: }
08567:
08568: final private boolean jj_3R_219() {
08569: if (jj_scan_token(LBRACE))
08570: return true;
08571: Token xsp;
08572: xsp = jj_scanpos;
08573: if (jj_3R_250())
08574: jj_scanpos = xsp;
08575: xsp = jj_scanpos;
08576: if (jj_scan_token(82))
08577: jj_scanpos = xsp;
08578: xsp = jj_scanpos;
08579: if (jj_3R_251())
08580: jj_scanpos = xsp;
08581: if (jj_scan_token(RBRACE))
08582: return true;
08583: return false;
08584: }
08585:
08586: final private boolean jj_3R_245() {
08587: if (jj_scan_token(CATCH))
08588: return true;
08589: if (jj_scan_token(LPAREN))
08590: return true;
08591: if (jj_3R_133())
08592: return true;
08593: if (jj_scan_token(RPAREN))
08594: return true;
08595: if (jj_3R_104())
08596: return true;
08597: return false;
08598: }
08599:
08600: final private boolean jj_3R_212() {
08601: if (jj_scan_token(TRY))
08602: return true;
08603: if (jj_3R_104())
08604: return true;
08605: Token xsp;
08606: while (true) {
08607: xsp = jj_scanpos;
08608: if (jj_3R_245()) {
08609: jj_scanpos = xsp;
08610: break;
08611: }
08612: }
08613: xsp = jj_scanpos;
08614: if (jj_3R_246())
08615: jj_scanpos = xsp;
08616: return false;
08617: }
08618:
08619: final private boolean jj_3R_218() {
08620: if (jj_3R_214())
08621: return true;
08622: return false;
08623: }
08624:
08625: final private boolean jj_3R_185() {
08626: if (jj_scan_token(ENUM))
08627: return true;
08628: if (jj_scan_token(IDENTIFIER))
08629: return true;
08630: Token xsp;
08631: xsp = jj_scanpos;
08632: if (jj_3R_218())
08633: jj_scanpos = xsp;
08634: if (jj_3R_219())
08635: return true;
08636: return false;
08637: }
08638:
08639: final private boolean jj_3R_211() {
08640: if (jj_scan_token(SYNCHRONIZED))
08641: return true;
08642: if (jj_scan_token(LPAREN))
08643: return true;
08644: if (jj_3R_56())
08645: return true;
08646: if (jj_scan_token(RPAREN))
08647: return true;
08648: if (jj_3R_104())
08649: return true;
08650: return false;
08651: }
08652:
08653: final private boolean jj_3R_244() {
08654: if (jj_3R_56())
08655: return true;
08656: return false;
08657: }
08658:
08659: final private boolean jj_3R_248() {
08660: if (jj_scan_token(COMMA))
08661: return true;
08662: if (jj_3R_149())
08663: return true;
08664: return false;
08665: }
08666:
08667: final private boolean jj_3R_214() {
08668: if (jj_scan_token(IMPLEMENTS))
08669: return true;
08670: if (jj_3R_149())
08671: return true;
08672: Token xsp;
08673: while (true) {
08674: xsp = jj_scanpos;
08675: if (jj_3R_248()) {
08676: jj_scanpos = xsp;
08677: break;
08678: }
08679: }
08680: return false;
08681: }
08682:
08683: final private boolean jj_3R_210() {
08684: if (jj_scan_token(THROW))
08685: return true;
08686: if (jj_3R_56())
08687: return true;
08688: if (jj_scan_token(SEMICOLON))
08689: return true;
08690: return false;
08691: }
08692:
08693: final private boolean jj_3R_271() {
08694: if (jj_3R_284())
08695: return true;
08696: return false;
08697: }
08698:
08699: final private boolean jj_3R_299() {
08700: if (jj_scan_token(COMMA))
08701: return true;
08702: if (jj_3R_201())
08703: return true;
08704: return false;
08705: }
08706:
08707: final private boolean jj_3R_209() {
08708: if (jj_scan_token(RETURN))
08709: return true;
08710: Token xsp;
08711: xsp = jj_scanpos;
08712: if (jj_3R_244())
08713: jj_scanpos = xsp;
08714: if (jj_scan_token(SEMICOLON))
08715: return true;
08716: return false;
08717: }
08718:
08719: final private boolean jj_3R_247() {
08720: if (jj_scan_token(COMMA))
08721: return true;
08722: if (jj_3R_149())
08723: return true;
08724: return false;
08725: }
08726:
08727: final private boolean jj_3R_213() {
08728: if (jj_scan_token(EXTENDS))
08729: return true;
08730: if (jj_3R_149())
08731: return true;
08732: Token xsp;
08733: while (true) {
08734: xsp = jj_scanpos;
08735: if (jj_3R_247()) {
08736: jj_scanpos = xsp;
08737: break;
08738: }
08739: }
08740: return false;
08741: }
08742:
08743: final private boolean jj_3R_208() {
08744: if (jj_scan_token(CONTINUE))
08745: return true;
08746: Token xsp;
08747: xsp = jj_scanpos;
08748: if (jj_scan_token(72))
08749: jj_scanpos = xsp;
08750: if (jj_scan_token(SEMICOLON))
08751: return true;
08752: return false;
08753: }
08754:
08755: final private boolean jj_3R_178() {
08756: if (jj_scan_token(INTERFACE))
08757: return true;
08758: return false;
08759: }
08760:
08761: final private boolean jj_3R_207() {
08762: if (jj_scan_token(BREAK))
08763: return true;
08764: Token xsp;
08765: xsp = jj_scanpos;
08766: if (jj_scan_token(72))
08767: jj_scanpos = xsp;
08768: if (jj_scan_token(SEMICOLON))
08769: return true;
08770: return false;
08771: }
08772:
08773: final private boolean jj_3R_181() {
08774: if (jj_3R_214())
08775: return true;
08776: return false;
08777: }
08778:
08779: final private boolean jj_3R_180() {
08780: if (jj_3R_213())
08781: return true;
08782: return false;
08783: }
08784:
08785: final private boolean jj_3R_179() {
08786: if (jj_3R_97())
08787: return true;
08788: return false;
08789: }
08790:
08791: final private boolean jj_3R_284() {
08792: if (jj_3R_296())
08793: return true;
08794: return false;
08795: }
08796:
08797: final private boolean jj_3R_270() {
08798: if (jj_3R_56())
08799: return true;
08800: return false;
08801: }
08802:
08803: final private boolean jj_3R_130() {
08804: Token xsp;
08805: xsp = jj_scanpos;
08806: if (jj_scan_token(16)) {
08807: jj_scanpos = xsp;
08808: if (jj_3R_178())
08809: return true;
08810: }
08811: if (jj_scan_token(IDENTIFIER))
08812: return true;
08813: xsp = jj_scanpos;
08814: if (jj_3R_179())
08815: jj_scanpos = xsp;
08816: xsp = jj_scanpos;
08817: if (jj_3R_180())
08818: jj_scanpos = xsp;
08819: xsp = jj_scanpos;
08820: if (jj_3R_181())
08821: jj_scanpos = xsp;
08822: if (jj_3R_182())
08823: return true;
08824: return false;
08825: }
08826:
08827: final private boolean jj_3_44() {
08828: if (jj_3R_50())
08829: return true;
08830: if (jj_3R_72())
08831: return true;
08832: if (jj_scan_token(IDENTIFIER))
08833: return true;
08834: return false;
08835: }
08836:
08837: final private boolean jj_3R_296() {
08838: if (jj_3R_201())
08839: return true;
08840: Token xsp;
08841: while (true) {
08842: xsp = jj_scanpos;
08843: if (jj_3R_299()) {
08844: jj_scanpos = xsp;
08845: break;
08846: }
08847: }
08848: return false;
08849: }
08850:
08851: final private boolean jj_3R_241() {
08852: if (jj_scan_token(ELSE))
08853: return true;
08854: if (jj_3R_129())
08855: return true;
08856: return false;
08857: }
08858:
08859: final private boolean jj_3R_295() {
08860: if (jj_3R_296())
08861: return true;
08862: return false;
08863: }
08864:
08865: final private boolean jj_3_43() {
08866: if (jj_3R_50())
08867: return true;
08868: if (jj_3R_72())
08869: return true;
08870: if (jj_scan_token(IDENTIFIER))
08871: return true;
08872: if (jj_scan_token(COLON))
08873: return true;
08874: return false;
08875: }
08876:
08877: final private boolean jj_3R_294() {
08878: if (jj_3R_128())
08879: return true;
08880: return false;
08881: }
08882:
08883: final private boolean jj_3R_283() {
08884: Token xsp;
08885: xsp = jj_scanpos;
08886: if (jj_3R_294()) {
08887: jj_scanpos = xsp;
08888: if (jj_3R_295())
08889: return true;
08890: }
08891: return false;
08892: }
08893:
08894: final private boolean jj_3R_269() {
08895: if (jj_3R_283())
08896: return true;
08897: return false;
08898: }
08899:
08900: final private boolean jj_3R_243() {
08901: Token xsp;
08902: xsp = jj_scanpos;
08903: if (jj_3R_269())
08904: jj_scanpos = xsp;
08905: if (jj_scan_token(SEMICOLON))
08906: return true;
08907: xsp = jj_scanpos;
08908: if (jj_3R_270())
08909: jj_scanpos = xsp;
08910: if (jj_scan_token(SEMICOLON))
08911: return true;
08912: xsp = jj_scanpos;
08913: if (jj_3R_271())
08914: jj_scanpos = xsp;
08915: return false;
08916: }
08917:
08918: final private boolean jj_3R_242() {
08919: if (jj_3R_50())
08920: return true;
08921: if (jj_3R_72())
08922: return true;
08923: if (jj_scan_token(IDENTIFIER))
08924: return true;
08925: if (jj_scan_token(COLON))
08926: return true;
08927: if (jj_3R_56())
08928: return true;
08929: return false;
08930: }
08931:
08932: final private boolean jj_3R_54() {
08933: if (jj_scan_token(THROWS))
08934: return true;
08935: if (jj_3R_99())
08936: return true;
08937: return false;
08938: }
08939:
08940: final private boolean jj_3R_206() {
08941: if (jj_scan_token(FOR))
08942: return true;
08943: if (jj_scan_token(LPAREN))
08944: return true;
08945: Token xsp;
08946: xsp = jj_scanpos;
08947: if (jj_3R_242()) {
08948: jj_scanpos = xsp;
08949: if (jj_3R_243())
08950: return true;
08951: }
08952: if (jj_scan_token(RPAREN))
08953: return true;
08954: if (jj_3R_129())
08955: return true;
08956: return false;
08957: }
08958:
08959: final private boolean jj_3R_69() {
08960: if (jj_3R_102())
08961: return true;
08962: return false;
08963: }
08964:
08965: final private boolean jj_3R_205() {
08966: if (jj_scan_token(DO))
08967: return true;
08968: if (jj_3R_129())
08969: return true;
08970: if (jj_scan_token(WHILE))
08971: return true;
08972: if (jj_scan_token(LPAREN))
08973: return true;
08974: if (jj_3R_56())
08975: return true;
08976: if (jj_scan_token(RPAREN))
08977: return true;
08978: if (jj_scan_token(SEMICOLON))
08979: return true;
08980: return false;
08981: }
08982:
08983: final private boolean jj_3R_68() {
08984: if (jj_scan_token(STRICTFP))
08985: return true;
08986: return false;
08987: }
08988:
08989: final private boolean jj_3R_67() {
08990: if (jj_scan_token(VOLATILE))
08991: return true;
08992: return false;
08993: }
08994:
08995: final private boolean jj_3R_66() {
08996: if (jj_scan_token(TRANSIENT))
08997: return true;
08998: return false;
08999: }
09000:
09001: final private boolean jj_3R_204() {
09002: if (jj_scan_token(WHILE))
09003: return true;
09004: if (jj_scan_token(LPAREN))
09005: return true;
09006: if (jj_3R_56())
09007: return true;
09008: if (jj_scan_token(RPAREN))
09009: return true;
09010: if (jj_3R_129())
09011: return true;
09012: return false;
09013: }
09014:
09015: final private boolean jj_3R_65() {
09016: if (jj_scan_token(NATIVE))
09017: return true;
09018: return false;
09019: }
09020:
09021: final private boolean jj_3R_64() {
09022: if (jj_scan_token(SYNCHRONIZED))
09023: return true;
09024: return false;
09025: }
09026:
09027: final private boolean jj_3R_63() {
09028: if (jj_scan_token(ABSTRACT))
09029: return true;
09030: return false;
09031: }
09032:
09033: final private boolean jj_3R_268() {
09034: if (jj_3R_49())
09035: return true;
09036: return false;
09037: }
09038:
09039: final private boolean jj_3R_203() {
09040: if (jj_scan_token(IF))
09041: return true;
09042: if (jj_scan_token(LPAREN))
09043: return true;
09044: if (jj_3R_56())
09045: return true;
09046: if (jj_scan_token(RPAREN))
09047: return true;
09048: if (jj_3R_129())
09049: return true;
09050: Token xsp;
09051: xsp = jj_scanpos;
09052: if (jj_3R_241())
09053: jj_scanpos = xsp;
09054: return false;
09055: }
09056:
09057: final private boolean jj_3R_62() {
09058: if (jj_scan_token(FINAL))
09059: return true;
09060: return false;
09061: }
09062:
09063: final private boolean jj_3R_61() {
09064: if (jj_scan_token(PRIVATE))
09065: return true;
09066: return false;
09067: }
09068:
09069: final private boolean jj_3R_162() {
09070: if (jj_scan_token(COMMA))
09071: return true;
09072: if (jj_3R_161())
09073: return true;
09074: return false;
09075: }
09076:
09077: final private boolean jj_3R_60() {
09078: if (jj_scan_token(PROTECTED))
09079: return true;
09080: return false;
09081: }
09082:
09083: final private boolean jj_3R_59() {
09084: if (jj_scan_token(STATIC))
09085: return true;
09086: return false;
09087: }
09088:
09089: final private boolean jj_3R_58() {
09090: if (jj_scan_token(PUBLIC))
09091: return true;
09092: return false;
09093: }
09094:
09095: final private boolean jj_3R_282() {
09096: if (jj_scan_token(_DEFAULT))
09097: return true;
09098: if (jj_scan_token(COLON))
09099: return true;
09100: return false;
09101: }
09102:
09103: final private boolean jj_3_6() {
09104: Token xsp;
09105: xsp = jj_scanpos;
09106: if (jj_3R_58()) {
09107: jj_scanpos = xsp;
09108: if (jj_3R_59()) {
09109: jj_scanpos = xsp;
09110: if (jj_3R_60()) {
09111: jj_scanpos = xsp;
09112: if (jj_3R_61()) {
09113: jj_scanpos = xsp;
09114: if (jj_3R_62()) {
09115: jj_scanpos = xsp;
09116: if (jj_3R_63()) {
09117: jj_scanpos = xsp;
09118: if (jj_3R_64()) {
09119: jj_scanpos = xsp;
09120: if (jj_3R_65()) {
09121: jj_scanpos = xsp;
09122: if (jj_3R_66()) {
09123: jj_scanpos = xsp;
09124: if (jj_3R_67()) {
09125: jj_scanpos = xsp;
09126: if (jj_3R_68()) {
09127: jj_scanpos = xsp;
09128: if (jj_3R_69())
09129: return true;
09130: }
09131: }
09132: }
09133: }
09134: }
09135: }
09136: }
09137: }
09138: }
09139: }
09140: }
09141: return false;
09142: }
09143:
09144: final private boolean jj_3R_281() {
09145: if (jj_scan_token(CASE))
09146: return true;
09147: if (jj_3R_56())
09148: return true;
09149: if (jj_scan_token(COLON))
09150: return true;
09151: return false;
09152: }
09153:
09154: final private boolean jj_3R_267() {
09155: Token xsp;
09156: xsp = jj_scanpos;
09157: if (jj_3R_281()) {
09158: jj_scanpos = xsp;
09159: if (jj_3R_282())
09160: return true;
09161: }
09162: return false;
09163: }
09164:
09165: final private boolean jj_3R_50() {
09166: Token xsp;
09167: while (true) {
09168: xsp = jj_scanpos;
09169: if (jj_3_6()) {
09170: jj_scanpos = xsp;
09171: break;
09172: }
09173: }
09174: return false;
09175: }
09176:
09177: final private boolean jj_3R_240() {
09178: if (jj_3R_267())
09179: return true;
09180: Token xsp;
09181: while (true) {
09182: xsp = jj_scanpos;
09183: if (jj_3R_268()) {
09184: jj_scanpos = xsp;
09185: break;
09186: }
09187: }
09188: return false;
09189: }
09190:
09191: final private boolean jj_3_42() {
09192: if (jj_3R_90())
09193: return true;
09194: if (jj_3R_79())
09195: return true;
09196: return false;
09197: }
09198:
09199: final private boolean jj_3R_202() {
09200: if (jj_scan_token(SWITCH))
09201: return true;
09202: if (jj_scan_token(LPAREN))
09203: return true;
09204: if (jj_3R_56())
09205: return true;
09206: if (jj_scan_token(RPAREN))
09207: return true;
09208: if (jj_scan_token(LBRACE))
09209: return true;
09210: Token xsp;
09211: while (true) {
09212: xsp = jj_scanpos;
09213: if (jj_3R_240()) {
09214: jj_scanpos = xsp;
09215: break;
09216: }
09217: }
09218: if (jj_scan_token(RBRACE))
09219: return true;
09220: return false;
09221: }
09222:
09223: final private boolean jj_3R_239() {
09224: if (jj_3R_266())
09225: return true;
09226: return false;
09227: }
09228:
09229: final private boolean jj_3R_57() {
09230: if (jj_3R_102())
09231: return true;
09232: return false;
09233: }
09234:
09235: final private boolean jj_3R_52() {
09236: if (jj_3R_86())
09237: return true;
09238: return false;
09239: }
09240:
09241: final private boolean jj_3R_238() {
09242: if (jj_3R_265())
09243: return true;
09244: return false;
09245: }
09246:
09247: final private boolean jj_3_5() {
09248: Token xsp;
09249: while (true) {
09250: xsp = jj_scanpos;
09251: if (jj_3R_57()) {
09252: jj_scanpos = xsp;
09253: break;
09254: }
09255: }
09256: if (jj_scan_token(PACKAGE))
09257: return true;
09258: return false;
09259: }
09260:
09261: final private boolean jj_3R_237() {
09262: if (jj_3R_264())
09263: return true;
09264: return false;
09265: }
09266:
09267: final private boolean jj_3R_201() {
09268: Token xsp;
09269: xsp = jj_scanpos;
09270: if (jj_3R_236()) {
09271: jj_scanpos = xsp;
09272: if (jj_3R_237()) {
09273: jj_scanpos = xsp;
09274: if (jj_3R_238()) {
09275: jj_scanpos = xsp;
09276: if (jj_3R_239())
09277: return true;
09278: }
09279: }
09280: }
09281: return false;
09282: }
09283:
09284: final private boolean jj_3R_236() {
09285: if (jj_3R_263())
09286: return true;
09287: return false;
09288: }
09289:
09290: final private boolean jj_3R_200() {
09291: if (jj_scan_token(SEMICOLON))
09292: return true;
09293: return false;
09294: }
09295:
09296: final private boolean jj_3_41() {
09297: if (jj_3R_50())
09298: return true;
09299: if (jj_3R_72())
09300: return true;
09301: if (jj_scan_token(IDENTIFIER))
09302: return true;
09303: return false;
09304: }
09305:
09306: final private boolean jj_3R_128() {
09307: if (jj_3R_50())
09308: return true;
09309: if (jj_3R_72())
09310: return true;
09311: if (jj_3R_161())
09312: return true;
09313: Token xsp;
09314: while (true) {
09315: xsp = jj_scanpos;
09316: if (jj_3R_162()) {
09317: jj_scanpos = xsp;
09318: break;
09319: }
09320: }
09321: return false;
09322: }
09323:
09324: final private boolean jj_3R_51() {
09325: if (jj_3R_97())
09326: return true;
09327: return false;
09328: }
09329:
09330: final private boolean jj_3R_235() {
09331: if (jj_scan_token(COLON))
09332: return true;
09333: if (jj_3R_56())
09334: return true;
09335: return false;
09336: }
09337:
09338: final private boolean jj_3R_96() {
09339: if (jj_3R_130())
09340: return true;
09341: return false;
09342: }
09343:
09344: final private boolean jj_3R_95() {
09345: if (jj_3R_129())
09346: return true;
09347: return false;
09348: }
09349:
09350: final private boolean jj_3_4() {
09351: if (jj_3R_56())
09352: return true;
09353: return false;
09354: }
09355:
09356: final private boolean jj_3R_94() {
09357: if (jj_3R_128())
09358: return true;
09359: if (jj_scan_token(SEMICOLON))
09360: return true;
09361: return false;
09362: }
09363:
09364: final private boolean jj_3R_49() {
09365: Token xsp;
09366: xsp = jj_scanpos;
09367: if (jj_3R_94()) {
09368: jj_scanpos = xsp;
09369: if (jj_3R_95()) {
09370: jj_scanpos = xsp;
09371: if (jj_3R_96())
09372: return true;
09373: }
09374: }
09375: return false;
09376: }
09377:
09378: final private boolean jj_3R_146() {
09379: if (jj_3R_49())
09380: return true;
09381: return false;
09382: }
09383:
09384: final private boolean jj_3_3() {
09385: if (jj_3R_55())
09386: return true;
09387: return false;
09388: }
09389:
09390: final private boolean jj_3R_104() {
09391: if (jj_scan_token(LBRACE))
09392: return true;
09393: Token xsp;
09394: while (true) {
09395: xsp = jj_scanpos;
09396: if (jj_3R_146()) {
09397: jj_scanpos = xsp;
09398: break;
09399: }
09400: }
09401: if (jj_scan_token(RBRACE))
09402: return true;
09403: return false;
09404: }
09405:
09406: final private boolean jj_3_2() {
09407: if (jj_3R_50())
09408: return true;
09409: Token xsp;
09410: xsp = jj_scanpos;
09411: if (jj_3R_51())
09412: jj_scanpos = xsp;
09413: xsp = jj_scanpos;
09414: if (jj_3R_52())
09415: jj_scanpos = xsp;
09416: if (jj_scan_token(IDENTIFIER))
09417: return true;
09418: if (jj_3R_53())
09419: return true;
09420: xsp = jj_scanpos;
09421: if (jj_3R_54())
09422: jj_scanpos = xsp;
09423: if (jj_scan_token(LBRACE))
09424: return true;
09425: return false;
09426: }
09427:
09428: final private boolean jj_3R_89() {
09429: if (jj_scan_token(IDENTIFIER))
09430: return true;
09431: if (jj_scan_token(COLON))
09432: return true;
09433: if (jj_3R_129())
09434: return true;
09435: return false;
09436: }
09437:
09438: final private boolean jj_3_1() {
09439: if (jj_3R_49())
09440: return true;
09441: return false;
09442: }
09443:
09444: final private boolean jj_3R_199() {
09445: if (jj_scan_token(ASSERT))
09446: return true;
09447: if (jj_3R_56())
09448: return true;
09449: Token xsp;
09450: xsp = jj_scanpos;
09451: if (jj_3R_235())
09452: jj_scanpos = xsp;
09453: if (jj_scan_token(SEMICOLON))
09454: return true;
09455: return false;
09456: }
09457:
09458: final private boolean jj_3R_177() {
09459: if (jj_3R_212())
09460: return true;
09461: return false;
09462: }
09463:
09464: final private boolean jj_3R_176() {
09465: if (jj_3R_211())
09466: return true;
09467: return false;
09468: }
09469:
09470: final private boolean jj_3_38() {
09471: if (jj_scan_token(LBRACKET))
09472: return true;
09473: if (jj_scan_token(RBRACKET))
09474: return true;
09475: return false;
09476: }
09477:
09478: final private boolean jj_3R_175() {
09479: if (jj_3R_210())
09480: return true;
09481: return false;
09482: }
09483:
09484: final private boolean jj_3R_174() {
09485: if (jj_3R_209())
09486: return true;
09487: return false;
09488: }
09489:
09490: final private boolean jj_3R_173() {
09491: if (jj_3R_208())
09492: return true;
09493: return false;
09494: }
09495:
09496: final private boolean jj_3R_172() {
09497: if (jj_3R_207())
09498: return true;
09499: return false;
09500: }
09501:
09502: final private boolean jj_3R_171() {
09503: if (jj_3R_206())
09504: return true;
09505: return false;
09506: }
09507:
09508: final private boolean jj_3R_170() {
09509: if (jj_3R_205())
09510: return true;
09511: return false;
09512: }
09513:
09514: final private boolean jj_3R_169() {
09515: if (jj_3R_204())
09516: return true;
09517: return false;
09518: }
09519:
09520: final private boolean jj_3R_168() {
09521: if (jj_3R_203())
09522: return true;
09523: return false;
09524: }
09525:
09526: final private boolean jj_3R_167() {
09527: if (jj_3R_202())
09528: return true;
09529: return false;
09530: }
09531:
09532: final private boolean jj_3R_166() {
09533: if (jj_3R_201())
09534: return true;
09535: if (jj_scan_token(SEMICOLON))
09536: return true;
09537: return false;
09538: }
09539:
09540: final private boolean jj_3R_165() {
09541: if (jj_3R_200())
09542: return true;
09543: return false;
09544: }
09545:
09546: final private boolean jj_3R_164() {
09547: if (jj_3R_104())
09548: return true;
09549: return false;
09550: }
09551:
09552: final private boolean jj_3R_163() {
09553: if (jj_3R_199())
09554: return true;
09555: return false;
09556: }
09557:
09558: final private boolean jj_3R_260() {
09559: if (jj_3R_78())
09560: return true;
09561: return false;
09562: }
09563:
09564: final private boolean jj_3_40() {
09565: if (jj_3R_89())
09566: return true;
09567: return false;
09568: }
09569:
09570: final private boolean jj_3R_129() {
09571: Token xsp;
09572: xsp = jj_scanpos;
09573: if (jj_3_40()) {
09574: jj_scanpos = xsp;
09575: if (jj_3R_163()) {
09576: jj_scanpos = xsp;
09577: if (jj_3R_164()) {
09578: jj_scanpos = xsp;
09579: if (jj_3R_165()) {
09580: jj_scanpos = xsp;
09581: if (jj_3R_166()) {
09582: jj_scanpos = xsp;
09583: if (jj_3R_167()) {
09584: jj_scanpos = xsp;
09585: if (jj_3R_168()) {
09586: jj_scanpos = xsp;
09587: if (jj_3R_169()) {
09588: jj_scanpos = xsp;
09589: if (jj_3R_170()) {
09590: jj_scanpos = xsp;
09591: if (jj_3R_171()) {
09592: jj_scanpos = xsp;
09593: if (jj_3R_172()) {
09594: jj_scanpos = xsp;
09595: if (jj_3R_173()) {
09596: jj_scanpos = xsp;
09597: if (jj_3R_174()) {
09598: jj_scanpos = xsp;
09599: if (jj_3R_175()) {
09600: jj_scanpos = xsp;
09601: if (jj_3R_176()) {
09602: jj_scanpos = xsp;
09603: if (jj_3R_177())
09604: return true;
09605: }
09606: }
09607: }
09608: }
09609: }
09610: }
09611: }
09612: }
09613: }
09614: }
09615: }
09616: }
09617: }
09618: }
09619: }
09620: return false;
09621: }
09622:
09623: final private boolean jj_3R_279() {
09624: if (jj_3R_182())
09625: return true;
09626: return false;
09627: }
09628:
09629: final private boolean jj_3R_291() {
09630: if (jj_scan_token(LBRACKET))
09631: return true;
09632: if (jj_scan_token(RBRACKET))
09633: return true;
09634: return false;
09635: }
09636:
09637: final private boolean jj_3R_278() {
09638: Token xsp;
09639: if (jj_3R_291())
09640: return true;
09641: while (true) {
09642: xsp = jj_scanpos;
09643: if (jj_3R_291()) {
09644: jj_scanpos = xsp;
09645: break;
09646: }
09647: }
09648: if (jj_3R_147())
09649: return true;
09650: return false;
09651: }
09652:
09653: final private boolean jj_3_37() {
09654: if (jj_scan_token(LBRACKET))
09655: return true;
09656: if (jj_3R_56())
09657: return true;
09658: if (jj_scan_token(RBRACKET))
09659: return true;
09660: return false;
09661: }
09662:
09663: final private boolean jj_3_39() {
09664: Token xsp;
09665: if (jj_3_37())
09666: return true;
09667: while (true) {
09668: xsp = jj_scanpos;
09669: if (jj_3_37()) {
09670: jj_scanpos = xsp;
09671: break;
09672: }
09673: }
09674: while (true) {
09675: xsp = jj_scanpos;
09676: if (jj_3_38()) {
09677: jj_scanpos = xsp;
09678: break;
09679: }
09680: }
09681: return false;
09682: }
09683:
09684: final private boolean jj_3R_259() {
09685: Token xsp;
09686: xsp = jj_scanpos;
09687: if (jj_3_39()) {
09688: jj_scanpos = xsp;
09689: if (jj_3R_278())
09690: return true;
09691: }
09692: return false;
09693: }
09694:
09695: final private boolean jj_3R_262() {
09696: if (jj_3R_109())
09697: return true;
09698: Token xsp;
09699: xsp = jj_scanpos;
09700: if (jj_3R_279())
09701: jj_scanpos = xsp;
09702: return false;
09703: }
09704:
09705: final private boolean jj_3R_232() {
09706: if (jj_scan_token(COMMA))
09707: return true;
09708: if (jj_3R_56())
09709: return true;
09710: return false;
09711: }
09712:
09713: final private boolean jj_3R_261() {
09714: if (jj_3R_259())
09715: return true;
09716: return false;
09717: }
09718:
09719: final private boolean jj_3R_123() {
09720: if (jj_scan_token(NEW))
09721: return true;
09722: if (jj_3R_149())
09723: return true;
09724: Token xsp;
09725: xsp = jj_scanpos;
09726: if (jj_3R_260())
09727: jj_scanpos = xsp;
09728: xsp = jj_scanpos;
09729: if (jj_3R_261()) {
09730: jj_scanpos = xsp;
09731: if (jj_3R_262())
09732: return true;
09733: }
09734: return false;
09735: }
09736:
09737: final private boolean jj_3R_87() {
09738: Token xsp;
09739: xsp = jj_scanpos;
09740: if (jj_3_36()) {
09741: jj_scanpos = xsp;
09742: if (jj_3R_123())
09743: return true;
09744: }
09745: return false;
09746: }
09747:
09748: final private boolean jj_3_36() {
09749: if (jj_scan_token(NEW))
09750: return true;
09751: if (jj_3R_83())
09752: return true;
09753: if (jj_3R_259())
09754: return true;
09755: return false;
09756: }
09757:
09758: final private boolean jj_3R_148() {
09759: if (jj_3R_195())
09760: return true;
09761: return false;
09762: }
09763:
09764: final private boolean jj_3R_195() {
09765: if (jj_3R_56())
09766: return true;
09767: Token xsp;
09768: while (true) {
09769: xsp = jj_scanpos;
09770: if (jj_3R_232()) {
09771: jj_scanpos = xsp;
09772: break;
09773: }
09774: }
09775: return false;
09776: }
09777:
09778: final private boolean jj_3R_109() {
09779: if (jj_scan_token(LPAREN))
09780: return true;
09781: Token xsp;
09782: xsp = jj_scanpos;
09783: if (jj_3R_148())
09784: jj_scanpos = xsp;
09785: if (jj_scan_token(RPAREN))
09786: return true;
09787: return false;
09788: }
09789:
09790: final private boolean jj_3R_258() {
09791: if (jj_scan_token(NULL))
09792: return true;
09793: return false;
09794: }
09795:
09796: final private boolean jj_3R_257() {
09797: Token xsp;
09798: xsp = jj_scanpos;
09799: if (jj_scan_token(56)) {
09800: jj_scanpos = xsp;
09801: if (jj_scan_token(25))
09802: return true;
09803: }
09804: return false;
09805: }
09806:
09807: final private boolean jj_3R_234() {
09808: if (jj_3R_258())
09809: return true;
09810: return false;
09811: }
09812:
09813: final private boolean jj_3R_233() {
09814: if (jj_3R_257())
09815: return true;
09816: return false;
09817: }
09818:
09819: final private boolean jj_3R_196() {
09820: Token xsp;
09821: xsp = jj_scanpos;
09822: if (jj_scan_token(61)) {
09823: jj_scanpos = xsp;
09824: if (jj_scan_token(65)) {
09825: jj_scanpos = xsp;
09826: if (jj_scan_token(70)) {
09827: jj_scanpos = xsp;
09828: if (jj_scan_token(71)) {
09829: jj_scanpos = xsp;
09830: if (jj_3R_233()) {
09831: jj_scanpos = xsp;
09832: if (jj_3R_234())
09833: return true;
09834: }
09835: }
09836: }
09837: }
09838: }
09839: return false;
09840: }
09841:
09842: final private boolean jj_3R_152() {
09843: if (jj_3R_196())
09844: return true;
09845: return false;
09846: }
09847:
09848: final private boolean jj_3R_121() {
09849: if (jj_3R_109())
09850: return true;
09851: return false;
09852: }
09853:
09854: final private boolean jj_3R_120() {
09855: if (jj_scan_token(DOT))
09856: return true;
09857: if (jj_scan_token(IDENTIFIER))
09858: return true;
09859: return false;
09860: }
09861:
09862: final private boolean jj_3_33() {
09863: if (jj_scan_token(DOT))
09864: return true;
09865: if (jj_scan_token(THIS))
09866: return true;
09867: return false;
09868: }
09869:
09870: final private boolean jj_3R_119() {
09871: if (jj_scan_token(LBRACKET))
09872: return true;
09873: if (jj_3R_56())
09874: return true;
09875: if (jj_scan_token(RBRACKET))
09876: return true;
09877: return false;
09878: }
09879:
09880: final private boolean jj_3_32() {
09881: if (jj_scan_token(DOT))
09882: return true;
09883: if (jj_scan_token(SUPER))
09884: return true;
09885: if (jj_scan_token(DOT))
09886: return true;
09887: return false;
09888: }
09889:
09890: final private boolean jj_3_35() {
09891: if (jj_3R_88())
09892: return true;
09893: return false;
09894: }
09895:
09896: final private boolean jj_3_34() {
09897: if (jj_scan_token(DOT))
09898: return true;
09899: if (jj_3R_87())
09900: return true;
09901: return false;
09902: }
09903:
09904: final private boolean jj_3R_118() {
09905: if (jj_scan_token(DOT))
09906: return true;
09907: if (jj_scan_token(THIS))
09908: return true;
09909: return false;
09910: }
09911:
09912: final private boolean jj_3_31() {
09913: if (jj_3R_86())
09914: return true;
09915: if (jj_scan_token(DOT))
09916: return true;
09917: if (jj_scan_token(CLASS))
09918: return true;
09919: return false;
09920: }
09921:
09922: final private boolean jj_3R_117() {
09923: if (jj_scan_token(DOT))
09924: return true;
09925: if (jj_scan_token(SUPER))
09926: return true;
09927: return false;
09928: }
09929:
09930: final private boolean jj_3R_84() {
09931: Token xsp;
09932: xsp = jj_scanpos;
09933: if (jj_3R_117()) {
09934: jj_scanpos = xsp;
09935: if (jj_3R_118()) {
09936: jj_scanpos = xsp;
09937: if (jj_3_34()) {
09938: jj_scanpos = xsp;
09939: if (jj_3_35()) {
09940: jj_scanpos = xsp;
09941: if (jj_3R_119()) {
09942: jj_scanpos = xsp;
09943: if (jj_3R_120()) {
09944: jj_scanpos = xsp;
09945: if (jj_3R_121())
09946: return true;
09947: }
09948: }
09949: }
09950: }
09951: }
09952: }
09953: return false;
09954: }
09955:
09956: final private boolean jj_3R_85() {
09957: if (jj_scan_token(IDENTIFIER))
09958: return true;
09959: if (jj_scan_token(DOT))
09960: return true;
09961: return false;
09962: }
09963:
09964: final private boolean jj_3R_159() {
09965: if (jj_3R_91())
09966: return true;
09967: return false;
09968: }
09969:
09970: final private boolean jj_3_30() {
09971: Token xsp;
09972: while (true) {
09973: xsp = jj_scanpos;
09974: if (jj_3R_85()) {
09975: jj_scanpos = xsp;
09976: break;
09977: }
09978: }
09979: if (jj_scan_token(THIS))
09980: return true;
09981: return false;
09982: }
09983:
09984: final private boolean jj_3R_158() {
09985: if (jj_3R_86())
09986: return true;
09987: if (jj_scan_token(DOT))
09988: return true;
09989: if (jj_scan_token(CLASS))
09990: return true;
09991: return false;
09992: }
09993:
09994: final private boolean jj_3R_157() {
09995: if (jj_3R_87())
09996: return true;
09997: return false;
09998: }
09999:
10000: final private boolean jj_3R_156() {
10001: if (jj_scan_token(LPAREN))
10002: return true;
10003: if (jj_3R_56())
10004: return true;
10005: if (jj_scan_token(RPAREN))
10006: return true;
10007: return false;
10008: }
10009:
10010: final private boolean jj_3_29() {
10011: if (jj_3R_84())
10012: return true;
10013: return false;
10014: }
10015:
10016: final private boolean jj_3R_155() {
10017: if (jj_scan_token(SUPER))
10018: return true;
10019: if (jj_scan_token(DOT))
10020: return true;
10021: if (jj_scan_token(IDENTIFIER))
10022: return true;
10023: return false;
10024: }
10025:
10026: final private boolean jj_3R_197() {
10027: if (jj_scan_token(IDENTIFIER))
10028: return true;
10029: if (jj_scan_token(DOT))
10030: return true;
10031: return false;
10032: }
10033:
10034: final private boolean jj_3R_154() {
10035: Token xsp;
10036: while (true) {
10037: xsp = jj_scanpos;
10038: if (jj_3R_197()) {
10039: jj_scanpos = xsp;
10040: break;
10041: }
10042: }
10043: if (jj_scan_token(THIS))
10044: return true;
10045: return false;
10046: }
10047:
10048: final private boolean jj_3R_124() {
10049: Token xsp;
10050: xsp = jj_scanpos;
10051: if (jj_3R_153()) {
10052: jj_scanpos = xsp;
10053: if (jj_3R_154()) {
10054: jj_scanpos = xsp;
10055: if (jj_3R_155()) {
10056: jj_scanpos = xsp;
10057: if (jj_3R_156()) {
10058: jj_scanpos = xsp;
10059: if (jj_3R_157()) {
10060: jj_scanpos = xsp;
10061: if (jj_3R_158()) {
10062: jj_scanpos = xsp;
10063: if (jj_3R_159())
10064: return true;
10065: }
10066: }
10067: }
10068: }
10069: }
10070: }
10071: return false;
10072: }
10073:
10074: final private boolean jj_3R_153() {
10075: if (jj_3R_196())
10076: return true;
10077: return false;
10078: }
10079:
10080: final private boolean jj_3R_88() {
10081: if (jj_scan_token(DOT))
10082: return true;
10083: if (jj_3R_78())
10084: return true;
10085: if (jj_scan_token(IDENTIFIER))
10086: return true;
10087: return false;
10088: }
10089:
10090: final private boolean jj_3R_280() {
10091: if (jj_3R_293())
10092: return true;
10093: return false;
10094: }
10095:
10096: final private boolean jj_3_28() {
10097: if (jj_scan_token(LPAREN))
10098: return true;
10099: if (jj_3R_83())
10100: return true;
10101: return false;
10102: }
10103:
10104: final private boolean jj_3R_90() {
10105: if (jj_3R_124())
10106: return true;
10107: Token xsp;
10108: while (true) {
10109: xsp = jj_scanpos;
10110: if (jj_3_29()) {
10111: jj_scanpos = xsp;
10112: break;
10113: }
10114: }
10115: return false;
10116: }
10117:
10118: final private boolean jj_3R_319() {
10119: if (jj_scan_token(LPAREN))
10120: return true;
10121: if (jj_3R_72())
10122: return true;
10123: if (jj_scan_token(RPAREN))
10124: return true;
10125: if (jj_3R_313())
10126: return true;
10127: return false;
10128: }
10129:
10130: final private boolean jj_3R_318() {
10131: if (jj_scan_token(LPAREN))
10132: return true;
10133: if (jj_3R_72())
10134: return true;
10135: if (jj_scan_token(RPAREN))
10136: return true;
10137: if (jj_3R_307())
10138: return true;
10139: return false;
10140: }
10141:
10142: final private boolean jj_3R_317() {
10143: Token xsp;
10144: xsp = jj_scanpos;
10145: if (jj_3R_318()) {
10146: jj_scanpos = xsp;
10147: if (jj_3R_319())
10148: return true;
10149: }
10150: return false;
10151: }
10152:
10153: final private boolean jj_3R_293() {
10154: Token xsp;
10155: xsp = jj_scanpos;
10156: if (jj_scan_token(97)) {
10157: jj_scanpos = xsp;
10158: if (jj_scan_token(98))
10159: return true;
10160: }
10161: return false;
10162: }
10163:
10164: final private boolean jj_3_27() {
10165: if (jj_scan_token(LPAREN))
10166: return true;
10167: if (jj_3R_72())
10168: return true;
10169: if (jj_scan_token(LBRACKET))
10170: return true;
10171: return false;
10172: }
10173:
10174: final private boolean jj_3R_266() {
10175: if (jj_3R_90())
10176: return true;
10177: Token xsp;
10178: xsp = jj_scanpos;
10179: if (jj_3R_280())
10180: jj_scanpos = xsp;
10181: return false;
10182: }
10183:
10184: final private boolean jj_3R_116() {
10185: if (jj_scan_token(LPAREN))
10186: return true;
10187: if (jj_3R_72())
10188: return true;
10189: if (jj_scan_token(RPAREN))
10190: return true;
10191: Token xsp;
10192: xsp = jj_scanpos;
10193: if (jj_scan_token(88)) {
10194: jj_scanpos = xsp;
10195: if (jj_scan_token(87)) {
10196: jj_scanpos = xsp;
10197: if (jj_scan_token(75)) {
10198: jj_scanpos = xsp;
10199: if (jj_scan_token(72)) {
10200: jj_scanpos = xsp;
10201: if (jj_scan_token(52)) {
10202: jj_scanpos = xsp;
10203: if (jj_scan_token(49)) {
10204: jj_scanpos = xsp;
10205: if (jj_scan_token(39)) {
10206: jj_scanpos = xsp;
10207: if (jj_3R_152())
10208: return true;
10209: }
10210: }
10211: }
10212: }
10213: }
10214: }
10215: }
10216: return false;
10217: }
10218:
10219: final private boolean jj_3R_115() {
10220: if (jj_scan_token(LPAREN))
10221: return true;
10222: if (jj_3R_72())
10223: return true;
10224: if (jj_scan_token(LBRACKET))
10225: return true;
10226: if (jj_scan_token(RBRACKET))
10227: return true;
10228: return false;
10229: }
10230:
10231: final private boolean jj_3R_82() {
10232: Token xsp;
10233: xsp = jj_scanpos;
10234: if (jj_3_26()) {
10235: jj_scanpos = xsp;
10236: if (jj_3R_115()) {
10237: jj_scanpos = xsp;
10238: if (jj_3R_116())
10239: return true;
10240: }
10241: }
10242: return false;
10243: }
10244:
10245: final private boolean jj_3_26() {
10246: if (jj_scan_token(LPAREN))
10247: return true;
10248: if (jj_3R_83())
10249: return true;
10250: return false;
10251: }
10252:
10253: final private boolean jj_3_25() {
10254: if (jj_3R_82())
10255: return true;
10256: return false;
10257: }
10258:
10259: final private boolean jj_3_24() {
10260: if (jj_3R_81())
10261: return true;
10262: return false;
10263: }
10264:
10265: final private boolean jj_3R_316() {
10266: if (jj_3R_266())
10267: return true;
10268: return false;
10269: }
10270:
10271: final private boolean jj_3R_315() {
10272: if (jj_3R_317())
10273: return true;
10274: return false;
10275: }
10276:
10277: final private boolean jj_3R_314() {
10278: Token xsp;
10279: xsp = jj_scanpos;
10280: if (jj_scan_token(88)) {
10281: jj_scanpos = xsp;
10282: if (jj_scan_token(87))
10283: return true;
10284: }
10285: if (jj_3R_307())
10286: return true;
10287: return false;
10288: }
10289:
10290: final private boolean jj_3R_313() {
10291: Token xsp;
10292: xsp = jj_scanpos;
10293: if (jj_3R_314()) {
10294: jj_scanpos = xsp;
10295: if (jj_3R_315()) {
10296: jj_scanpos = xsp;
10297: if (jj_3R_316())
10298: return true;
10299: }
10300: }
10301: return false;
10302: }
10303:
10304: final private boolean jj_3R_264() {
10305: if (jj_scan_token(DECR))
10306: return true;
10307: if (jj_3R_90())
10308: return true;
10309: return false;
10310: }
10311:
10312: final private boolean jj_3R_306() {
10313: Token xsp;
10314: xsp = jj_scanpos;
10315: if (jj_scan_token(99)) {
10316: jj_scanpos = xsp;
10317: if (jj_scan_token(100))
10318: return true;
10319: }
10320: if (jj_3R_305())
10321: return true;
10322: return false;
10323: }
10324:
10325: final private boolean jj_3R_308() {
10326: Token xsp;
10327: xsp = jj_scanpos;
10328: if (jj_scan_token(101)) {
10329: jj_scanpos = xsp;
10330: if (jj_scan_token(102)) {
10331: jj_scanpos = xsp;
10332: if (jj_scan_token(106))
10333: return true;
10334: }
10335: }
10336: if (jj_3R_307())
10337: return true;
10338: return false;
10339: }
10340:
10341: final private boolean jj_3_23() {
10342: if (jj_3R_80())
10343: return true;
10344: return false;
10345: }
10346:
10347: final private boolean jj_3R_263() {
10348: if (jj_scan_token(INCR))
10349: return true;
10350: if (jj_3R_90())
10351: return true;
10352: return false;
10353: }
10354:
10355: final private boolean jj_3R_312() {
10356: if (jj_3R_313())
10357: return true;
10358: return false;
10359: }
10360:
10361: final private boolean jj_3_22() {
10362: Token xsp;
10363: xsp = jj_scanpos;
10364: if (jj_scan_token(107)) {
10365: jj_scanpos = xsp;
10366: if (jj_3_23()) {
10367: jj_scanpos = xsp;
10368: if (jj_3_24())
10369: return true;
10370: }
10371: }
10372: if (jj_3R_304())
10373: return true;
10374: return false;
10375: }
10376:
10377: final private boolean jj_3R_311() {
10378: if (jj_3R_264())
10379: return true;
10380: return false;
10381: }
10382:
10383: final private boolean jj_3R_310() {
10384: if (jj_3R_263())
10385: return true;
10386: return false;
10387: }
10388:
10389: final private boolean jj_3R_309() {
10390: Token xsp;
10391: xsp = jj_scanpos;
10392: if (jj_scan_token(99)) {
10393: jj_scanpos = xsp;
10394: if (jj_scan_token(100))
10395: return true;
10396: }
10397: if (jj_3R_307())
10398: return true;
10399: return false;
10400: }
10401:
10402: final private boolean jj_3R_307() {
10403: Token xsp;
10404: xsp = jj_scanpos;
10405: if (jj_3R_309()) {
10406: jj_scanpos = xsp;
10407: if (jj_3R_310()) {
10408: jj_scanpos = xsp;
10409: if (jj_3R_311()) {
10410: jj_scanpos = xsp;
10411: if (jj_3R_312())
10412: return true;
10413: }
10414: }
10415: }
10416: return false;
10417: }
10418:
10419: final private boolean jj_3R_303() {
10420: Token xsp;
10421: xsp = jj_scanpos;
10422: if (jj_scan_token(86)) {
10423: jj_scanpos = xsp;
10424: if (jj_scan_token(122)) {
10425: jj_scanpos = xsp;
10426: if (jj_scan_token(92)) {
10427: jj_scanpos = xsp;
10428: if (jj_scan_token(93))
10429: return true;
10430: }
10431: }
10432: }
10433: if (jj_3R_302())
10434: return true;
10435: return false;
10436: }
10437:
10438: final private boolean jj_3R_301() {
10439: if (jj_scan_token(INSTANCEOF))
10440: return true;
10441: if (jj_3R_72())
10442: return true;
10443: return false;
10444: }
10445:
10446: final private boolean jj_3R_305() {
10447: if (jj_3R_307())
10448: return true;
10449: Token xsp;
10450: while (true) {
10451: xsp = jj_scanpos;
10452: if (jj_3R_308()) {
10453: jj_scanpos = xsp;
10454: break;
10455: }
10456: }
10457: return false;
10458: }
10459:
10460: final private boolean jj_3R_298() {
10461: Token xsp;
10462: xsp = jj_scanpos;
10463: if (jj_scan_token(91)) {
10464: jj_scanpos = xsp;
10465: if (jj_scan_token(94))
10466: return true;
10467: }
10468: if (jj_3R_297())
10469: return true;
10470: return false;
10471: }
10472:
10473: final private boolean jj_3R_304() {
10474: if (jj_3R_305())
10475: return true;
10476: Token xsp;
10477: while (true) {
10478: xsp = jj_scanpos;
10479: if (jj_3R_306()) {
10480: jj_scanpos = xsp;
10481: break;
10482: }
10483: }
10484: return false;
10485: }
10486:
10487: final private boolean jj_3R_302() {
10488: if (jj_3R_304())
10489: return true;
10490: Token xsp;
10491: while (true) {
10492: xsp = jj_scanpos;
10493: if (jj_3_22()) {
10494: jj_scanpos = xsp;
10495: break;
10496: }
10497: }
10498: return false;
10499: }
10500:
10501: final private boolean jj_3R_288() {
10502: if (jj_scan_token(BIT_AND))
10503: return true;
10504: if (jj_3R_287())
10505: return true;
10506: return false;
10507: }
10508:
10509: final private boolean jj_3R_300() {
10510: if (jj_3R_302())
10511: return true;
10512: Token xsp;
10513: while (true) {
10514: xsp = jj_scanpos;
10515: if (jj_3R_303()) {
10516: jj_scanpos = xsp;
10517: break;
10518: }
10519: }
10520: return false;
10521: }
10522:
10523: final private boolean jj_3R_254() {
10524: if (jj_scan_token(BIT_OR))
10525: return true;
10526: if (jj_3R_253())
10527: return true;
10528: return false;
10529: }
10530:
10531: final private boolean jj_3R_297() {
10532: if (jj_3R_300())
10533: return true;
10534: Token xsp;
10535: xsp = jj_scanpos;
10536: if (jj_3R_301())
10537: jj_scanpos = xsp;
10538: return false;
10539: }
10540:
10541: final private boolean jj_3R_274() {
10542: if (jj_scan_token(XOR))
10543: return true;
10544: if (jj_3R_273())
10545: return true;
10546: return false;
10547: }
10548:
10549: final private boolean jj_3R_230() {
10550: if (jj_scan_token(SC_AND))
10551: return true;
10552: if (jj_3R_229())
10553: return true;
10554: return false;
10555: }
10556:
10557: final private boolean jj_3R_287() {
10558: if (jj_3R_297())
10559: return true;
10560: Token xsp;
10561: while (true) {
10562: xsp = jj_scanpos;
10563: if (jj_3R_298()) {
10564: jj_scanpos = xsp;
10565: break;
10566: }
10567: }
10568: return false;
10569: }
10570:
10571: final private boolean jj_3R_190() {
10572: if (jj_scan_token(SC_OR))
10573: return true;
10574: if (jj_3R_189())
10575: return true;
10576: return false;
10577: }
10578:
10579: final private boolean jj_3R_273() {
10580: if (jj_3R_287())
10581: return true;
10582: Token xsp;
10583: while (true) {
10584: xsp = jj_scanpos;
10585: if (jj_3R_288()) {
10586: jj_scanpos = xsp;
10587: break;
10588: }
10589: }
10590: return false;
10591: }
10592:
10593: final private boolean jj_3R_142() {
10594: if (jj_scan_token(HOOK))
10595: return true;
10596: if (jj_3R_56())
10597: return true;
10598: if (jj_scan_token(COLON))
10599: return true;
10600: if (jj_3R_56())
10601: return true;
10602: return false;
10603: }
10604:
10605: final private boolean jj_3R_253() {
10606: if (jj_3R_273())
10607: return true;
10608: Token xsp;
10609: while (true) {
10610: xsp = jj_scanpos;
10611: if (jj_3R_274()) {
10612: jj_scanpos = xsp;
10613: break;
10614: }
10615: }
10616: return false;
10617: }
10618:
10619: final private boolean jj_3R_229() {
10620: if (jj_3R_253())
10621: return true;
10622: Token xsp;
10623: while (true) {
10624: xsp = jj_scanpos;
10625: if (jj_3R_254()) {
10626: jj_scanpos = xsp;
10627: break;
10628: }
10629: }
10630: return false;
10631: }
10632:
10633: final private boolean jj_3R_189() {
10634: if (jj_3R_229())
10635: return true;
10636: Token xsp;
10637: while (true) {
10638: xsp = jj_scanpos;
10639: if (jj_3R_230()) {
10640: jj_scanpos = xsp;
10641: break;
10642: }
10643: }
10644: return false;
10645: }
10646:
10647: final private boolean jj_3R_141() {
10648: if (jj_3R_189())
10649: return true;
10650: Token xsp;
10651: while (true) {
10652: xsp = jj_scanpos;
10653: if (jj_3R_190()) {
10654: jj_scanpos = xsp;
10655: break;
10656: }
10657: }
10658: return false;
10659: }
10660:
10661: final private boolean jj_3R_101() {
10662: if (jj_3R_141())
10663: return true;
10664: Token xsp;
10665: xsp = jj_scanpos;
10666: if (jj_3R_142())
10667: jj_scanpos = xsp;
10668: return false;
10669: }
10670:
10671: final private boolean jj_3R_265() {
10672: if (jj_3R_90())
10673: return true;
10674: if (jj_3R_79())
10675: return true;
10676: if (jj_3R_56())
10677: return true;
10678: return false;
10679: }
10680:
10681: final private boolean jj_3R_79() {
10682: Token xsp;
10683: xsp = jj_scanpos;
10684: if (jj_scan_token(85)) {
10685: jj_scanpos = xsp;
10686: if (jj_scan_token(110)) {
10687: jj_scanpos = xsp;
10688: if (jj_scan_token(111)) {
10689: jj_scanpos = xsp;
10690: if (jj_scan_token(115)) {
10691: jj_scanpos = xsp;
10692: if (jj_scan_token(108)) {
10693: jj_scanpos = xsp;
10694: if (jj_scan_token(109)) {
10695: jj_scanpos = xsp;
10696: if (jj_scan_token(116)) {
10697: jj_scanpos = xsp;
10698: if (jj_scan_token(117)) {
10699: jj_scanpos = xsp;
10700: if (jj_scan_token(118)) {
10701: jj_scanpos = xsp;
10702: if (jj_scan_token(112)) {
10703: jj_scanpos = xsp;
10704: if (jj_scan_token(114)) {
10705: jj_scanpos = xsp;
10706: if (jj_scan_token(113))
10707: return true;
10708: }
10709: }
10710: }
10711: }
10712: }
10713: }
10714: }
10715: }
10716: }
10717: }
10718: }
10719: return false;
10720: }
10721:
10722: final private boolean jj_3_21() {
10723: if (jj_3R_79())
10724: return true;
10725: if (jj_3R_56())
10726: return true;
10727: return false;
10728: }
10729:
10730: public JavaParserTokenManager token_source;
10731: JavaCharStream jj_input_stream;
10732: public Token token, jj_nt;
10733: private int jj_ntk;
10734: private Token jj_scanpos, jj_lastpos;
10735: private int jj_la;
10736: public boolean lookingAhead = false;
10737: private boolean jj_semLA;
10738:
10739: public JavaParser(java.io.InputStream stream) {
10740: this (stream, null);
10741: }
10742:
10743: public JavaParser(java.io.InputStream stream, String encoding) {
10744: try {
10745: jj_input_stream = new JavaCharStream(stream, encoding, 1, 1);
10746: } catch (java.io.UnsupportedEncodingException e) {
10747: throw new RuntimeException(e);
10748: }
10749: token_source = new JavaParserTokenManager(jj_input_stream);
10750: token = new Token();
10751: jj_ntk = -1;
10752: }
10753:
10754: public void ReInit(java.io.InputStream stream) {
10755: ReInit(stream, null);
10756: }
10757:
10758: public void ReInit(java.io.InputStream stream, String encoding) {
10759: try {
10760: jj_input_stream.ReInit(stream, encoding, 1, 1);
10761: } catch (java.io.UnsupportedEncodingException e) {
10762: throw new RuntimeException(e);
10763: }
10764: token_source.ReInit(jj_input_stream);
10765: token = new Token();
10766: jj_ntk = -1;
10767: jjtree.reset();
10768: }
10769:
10770: public JavaParser(java.io.Reader stream) {
10771: jj_input_stream = new JavaCharStream(stream, 1, 1);
10772: token_source = new JavaParserTokenManager(jj_input_stream);
10773: token = new Token();
10774: jj_ntk = -1;
10775: }
10776:
10777: public void ReInit(java.io.Reader stream) {
10778: jj_input_stream.ReInit(stream, 1, 1);
10779: token_source.ReInit(jj_input_stream);
10780: token = new Token();
10781: jj_ntk = -1;
10782: jjtree.reset();
10783: }
10784:
10785: public JavaParser(JavaParserTokenManager tm) {
10786: token_source = tm;
10787: token = new Token();
10788: jj_ntk = -1;
10789: }
10790:
10791: public void ReInit(JavaParserTokenManager tm) {
10792: token_source = tm;
10793: token = new Token();
10794: jj_ntk = -1;
10795: jjtree.reset();
10796: }
10797:
10798: final private Token jj_consume_token(int kind)
10799: throws ParseException {
10800: Token oldToken;
10801: if ((oldToken = token).next != null)
10802: token = token.next;
10803: else
10804: token = token.next = token_source.getNextToken();
10805: jj_ntk = -1;
10806: if (token.kind == kind) {
10807: return token;
10808: }
10809: token = oldToken;
10810: throw generateParseException();
10811: }
10812:
10813: static private final class LookaheadSuccess extends java.lang.Error {
10814: }
10815:
10816: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
10817:
10818: final private boolean jj_scan_token(int kind) {
10819: if (jj_scanpos == jj_lastpos) {
10820: jj_la--;
10821: if (jj_scanpos.next == null) {
10822: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
10823: .getNextToken();
10824: } else {
10825: jj_lastpos = jj_scanpos = jj_scanpos.next;
10826: }
10827: } else {
10828: jj_scanpos = jj_scanpos.next;
10829: }
10830: if (jj_scanpos.kind != kind)
10831: return true;
10832: if (jj_la == 0 && jj_scanpos == jj_lastpos)
10833: throw jj_ls;
10834: return false;
10835: }
10836:
10837: final public Token getNextToken() {
10838: if (token.next != null)
10839: token = token.next;
10840: else
10841: token = token.next = token_source.getNextToken();
10842: jj_ntk = -1;
10843: return token;
10844: }
10845:
10846: final public Token getToken(int index) {
10847: Token t = lookingAhead ? jj_scanpos : token;
10848: for (int i = 0; i < index; i++) {
10849: if (t.next != null)
10850: t = t.next;
10851: else
10852: t = t.next = token_source.getNextToken();
10853: }
10854: return t;
10855: }
10856:
10857: final private int jj_ntk() {
10858: if ((jj_nt = token.next) == null)
10859: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
10860: else
10861: return (jj_ntk = jj_nt.kind);
10862: }
10863:
10864: public ParseException generateParseException() {
10865: Token errortok = token.next;
10866: int line = errortok.beginLine, column = errortok.beginColumn;
10867: String mess = (errortok.kind == 0) ? tokenImage[0]
10868: : errortok.image;
10869: return new ParseException(
10870: "Unable to parse Java code near token: " + mess, line,
10871: column);
10872: }
10873:
10874: final public void enable_tracing() {
10875: }
10876:
10877: final public void disable_tracing() {
10878: }
10879:
10880: }
|