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