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