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