0001: /* Generated By:JJTree&JavaCC: Do not edit this line. Parser.java */
0002: package de.gulden.util.javasource.jjt;
0003:
0004: import de.gulden.util.javasource.SourceParser;
0005: import java.io.*;
0006:
0007: public class Parser/*@bgen(jjtree)*/implements ParserTreeConstants,
0008: ParserConstants {/*@bgen(jjtree)*/
0009: protected JJTParserState jjtree = new JJTParserState();
0010:
0011: /**
0012: * Parses Java source code.
0013: * This method is reentrant.
0014: * @param source may describe a source file path, zip-entry etc.
0015: */
0016: public static Node parse(java.io.InputStream in, String source)
0017: throws ParseException {
0018: Node node;
0019: Parser parser = new Parser(in, source);
0020: parser.CompilationUnit();
0021: node = parser.jjtree.rootNode();
0022: //showTree(node,System.out);
0023: return node;
0024: }
0025:
0026: //-----------------------------
0027:
0028: protected String source;
0029:
0030: protected Parser(InputStream in, String source) {
0031: this (in);
0032: this .source = source;
0033: }
0034:
0035: public static void showTree(Node node, PrintStream out) {
0036: showTree(node, out, 0);
0037: }
0038:
0039: private static void showTree(Node node, PrintStream out, int depth) {
0040: out.println(SourceParser.repeat(" ", depth) + node.toString());
0041: for (int i = 0; i < node.jjtGetNumChildren(); i++) {
0042: Node n = node.jjtGetChild(i);
0043: showTree(n, out, depth + 1);
0044: }
0045: }
0046:
0047: public void jjtreeOpenNodeScope(Node n) {
0048: n.setTextImage(jj_input_stream.text_image);
0049: n.setStartToken(getToken(1));
0050: n.setSource(source);
0051: }
0052:
0053: public void jjtreeCloseNodeScope(Node n) {
0054: n.setEndToken(getToken(1));
0055: }
0056:
0057: /*****************************************
0058: * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
0059: *****************************************/
0060:
0061: /*
0062: * Program structuring syntax follows.
0063: */
0064: final public void CompilationUnit() throws ParseException {
0065: /*@bgen(jjtree) #_SOURCE( true) */
0066: SimpleNode jjtn000 = new SimpleNode(JJT_SOURCE);
0067: boolean jjtc000 = true;
0068: jjtree.openNodeScope(jjtn000);
0069: jjtreeOpenNodeScope(jjtn000);
0070: try {
0071: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0072: case PACKAGE:
0073: PackageDeclaration();
0074: break;
0075: default:
0076: jj_la1[0] = jj_gen;
0077: ;
0078: }
0079: label_1: while (true) {
0080: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0081: case IMPORT:
0082: ;
0083: break;
0084: default:
0085: jj_la1[1] = jj_gen;
0086: break label_1;
0087: }
0088: ImportDeclaration();
0089: }
0090: label_2: while (true) {
0091: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0092: case ABSTRACT:
0093: case CLASS:
0094: case FINAL:
0095: case INTERFACE:
0096: case PUBLIC:
0097: case STRICTFP:
0098: case SEMICOLON:
0099: ;
0100: break;
0101: default:
0102: jj_la1[2] = jj_gen;
0103: break label_2;
0104: }
0105: TypeDeclaration();
0106: }
0107: jj_consume_token(0);
0108: } catch (Throwable jjte000) {
0109: if (jjtc000) {
0110: jjtree.clearNodeScope(jjtn000);
0111: jjtc000 = false;
0112: } else {
0113: jjtree.popNode();
0114: }
0115: if (jjte000 instanceof RuntimeException) {
0116: {
0117: if (true)
0118: throw (RuntimeException) jjte000;
0119: }
0120: }
0121: if (jjte000 instanceof ParseException) {
0122: {
0123: if (true)
0124: throw (ParseException) jjte000;
0125: }
0126: }
0127: {
0128: if (true)
0129: throw (Error) jjte000;
0130: }
0131: } finally {
0132: if (jjtc000) {
0133: jjtree.closeNodeScope(jjtn000, true);
0134: jjtreeCloseNodeScope(jjtn000);
0135: }
0136: }
0137: }
0138:
0139: final public void PackageDeclaration() throws ParseException {
0140: /*@bgen(jjtree) #_PACKAGE( true) */
0141: SimpleNode jjtn000 = new SimpleNode(JJT_PACKAGE);
0142: boolean jjtc000 = true;
0143: jjtree.openNodeScope(jjtn000);
0144: jjtreeOpenNodeScope(jjtn000);
0145: try {
0146: jj_consume_token(PACKAGE);
0147: Name();
0148: jj_consume_token(SEMICOLON);
0149: } catch (Throwable jjte000) {
0150: if (jjtc000) {
0151: jjtree.clearNodeScope(jjtn000);
0152: jjtc000 = false;
0153: } else {
0154: jjtree.popNode();
0155: }
0156: if (jjte000 instanceof RuntimeException) {
0157: {
0158: if (true)
0159: throw (RuntimeException) jjte000;
0160: }
0161: }
0162: if (jjte000 instanceof ParseException) {
0163: {
0164: if (true)
0165: throw (ParseException) jjte000;
0166: }
0167: }
0168: {
0169: if (true)
0170: throw (Error) jjte000;
0171: }
0172: } finally {
0173: if (jjtc000) {
0174: jjtree.closeNodeScope(jjtn000, true);
0175: jjtreeCloseNodeScope(jjtn000);
0176: }
0177: }
0178: }
0179:
0180: final public void ImportDeclaration() throws ParseException {
0181: /*@bgen(jjtree) #_IMPORT( true) */
0182: SimpleNode jjtn000 = new SimpleNode(JJT_IMPORT);
0183: boolean jjtc000 = true;
0184: jjtree.openNodeScope(jjtn000);
0185: jjtreeOpenNodeScope(jjtn000);
0186: try {
0187: jj_consume_token(IMPORT);
0188: Name();
0189: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0190: case DOT:
0191: jj_consume_token(DOT);
0192: SimpleNode jjtn001 = new SimpleNode(JJT_PACKAGEIMPORT);
0193: boolean jjtc001 = true;
0194: jjtree.openNodeScope(jjtn001);
0195: jjtreeOpenNodeScope(jjtn001);
0196: try {
0197: jj_consume_token(STAR);
0198: } finally {
0199: if (jjtc001) {
0200: jjtree.closeNodeScope(jjtn001, true);
0201: jjtreeCloseNodeScope(jjtn001);
0202: }
0203: }
0204: break;
0205: default:
0206: jj_la1[3] = jj_gen;
0207: ;
0208: }
0209: jj_consume_token(SEMICOLON);
0210: } catch (Throwable jjte000) {
0211: if (jjtc000) {
0212: jjtree.clearNodeScope(jjtn000);
0213: jjtc000 = false;
0214: } else {
0215: jjtree.popNode();
0216: }
0217: if (jjte000 instanceof RuntimeException) {
0218: {
0219: if (true)
0220: throw (RuntimeException) jjte000;
0221: }
0222: }
0223: if (jjte000 instanceof ParseException) {
0224: {
0225: if (true)
0226: throw (ParseException) jjte000;
0227: }
0228: }
0229: {
0230: if (true)
0231: throw (Error) jjte000;
0232: }
0233: } finally {
0234: if (jjtc000) {
0235: jjtree.closeNodeScope(jjtn000, true);
0236: jjtreeCloseNodeScope(jjtn000);
0237: }
0238: }
0239: }
0240:
0241: final public void TypeDeclaration() throws ParseException {
0242: if (jj_2_1(2147483647)) {
0243: ClassDeclaration();
0244: } else {
0245: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0246: case ABSTRACT:
0247: case INTERFACE:
0248: case PUBLIC:
0249: InterfaceDeclaration();
0250: break;
0251: case SEMICOLON:
0252: jj_consume_token(SEMICOLON);
0253: break;
0254: default:
0255: jj_la1[4] = jj_gen;
0256: jj_consume_token(-1);
0257: throw new ParseException();
0258: }
0259: }
0260: }
0261:
0262: /*
0263: * Declaration syntax follows.
0264: */
0265: final public void ClassDeclaration() throws ParseException {
0266: /*@bgen(jjtree) #_CLASS( true) */
0267: SimpleNode jjtn000 = new SimpleNode(JJT_CLASS);
0268: boolean jjtc000 = true;
0269: jjtree.openNodeScope(jjtn000);
0270: jjtreeOpenNodeScope(jjtn000);
0271: try {
0272: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
0273: boolean jjtc001 = true;
0274: jjtree.openNodeScope(jjtn001);
0275: jjtreeOpenNodeScope(jjtn001);
0276: try {
0277: label_3: while (true) {
0278: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0279: case ABSTRACT:
0280: case FINAL:
0281: case PUBLIC:
0282: case STRICTFP:
0283: ;
0284: break;
0285: default:
0286: jj_la1[5] = jj_gen;
0287: break label_3;
0288: }
0289: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0290: case ABSTRACT:
0291: _ABSTRACT();
0292: break;
0293: case FINAL:
0294: _FINAL();
0295: break;
0296: case STRICTFP:
0297: _STRICTFP();
0298: break;
0299: case PUBLIC:
0300: _PUBLIC();
0301: break;
0302: default:
0303: jj_la1[6] = jj_gen;
0304: jj_consume_token(-1);
0305: throw new ParseException();
0306: }
0307: }
0308: } catch (Throwable jjte001) {
0309: if (jjtc001) {
0310: jjtree.clearNodeScope(jjtn001);
0311: jjtc001 = false;
0312: } else {
0313: jjtree.popNode();
0314: }
0315: if (jjte001 instanceof RuntimeException) {
0316: {
0317: if (true)
0318: throw (RuntimeException) jjte001;
0319: }
0320: }
0321: if (jjte001 instanceof ParseException) {
0322: {
0323: if (true)
0324: throw (ParseException) jjte001;
0325: }
0326: }
0327: {
0328: if (true)
0329: throw (Error) jjte001;
0330: }
0331: } finally {
0332: if (jjtc001) {
0333: jjtree.closeNodeScope(jjtn001, true);
0334: jjtreeCloseNodeScope(jjtn001);
0335: }
0336: }
0337: UnmodifiedClassDeclaration();
0338: } catch (Throwable jjte000) {
0339: if (jjtc000) {
0340: jjtree.clearNodeScope(jjtn000);
0341: jjtc000 = false;
0342: } else {
0343: jjtree.popNode();
0344: }
0345: if (jjte000 instanceof RuntimeException) {
0346: {
0347: if (true)
0348: throw (RuntimeException) jjte000;
0349: }
0350: }
0351: if (jjte000 instanceof ParseException) {
0352: {
0353: if (true)
0354: throw (ParseException) jjte000;
0355: }
0356: }
0357: {
0358: if (true)
0359: throw (Error) jjte000;
0360: }
0361: } finally {
0362: if (jjtc000) {
0363: jjtree.closeNodeScope(jjtn000, true);
0364: jjtreeCloseNodeScope(jjtn000);
0365: }
0366: }
0367: }
0368:
0369: final public void UnmodifiedClassDeclaration()
0370: throws ParseException {
0371: jj_consume_token(CLASS);
0372: SimpleNode jjtn001 = new SimpleNode(JJT_NAME);
0373: boolean jjtc001 = true;
0374: jjtree.openNodeScope(jjtn001);
0375: jjtreeOpenNodeScope(jjtn001);
0376: try {
0377: _IDENTIFIER();
0378: } catch (Throwable jjte001) {
0379: if (jjtc001) {
0380: jjtree.clearNodeScope(jjtn001);
0381: jjtc001 = false;
0382: } else {
0383: jjtree.popNode();
0384: }
0385: if (jjte001 instanceof RuntimeException) {
0386: {
0387: if (true)
0388: throw (RuntimeException) jjte001;
0389: }
0390: }
0391: if (jjte001 instanceof ParseException) {
0392: {
0393: if (true)
0394: throw (ParseException) jjte001;
0395: }
0396: }
0397: {
0398: if (true)
0399: throw (Error) jjte001;
0400: }
0401: } finally {
0402: if (jjtc001) {
0403: jjtree.closeNodeScope(jjtn001, true);
0404: jjtreeCloseNodeScope(jjtn001);
0405: }
0406: }
0407: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0408: case EXTENDS:
0409: jj_consume_token(EXTENDS);
0410: SimpleNode jjtn002 = new SimpleNode(JJT_SUPERCLASS);
0411: boolean jjtc002 = true;
0412: jjtree.openNodeScope(jjtn002);
0413: jjtreeOpenNodeScope(jjtn002);
0414: try {
0415: Name();
0416: } catch (Throwable jjte002) {
0417: if (jjtc002) {
0418: jjtree.clearNodeScope(jjtn002);
0419: jjtc002 = false;
0420: } else {
0421: jjtree.popNode();
0422: }
0423: if (jjte002 instanceof RuntimeException) {
0424: {
0425: if (true)
0426: throw (RuntimeException) jjte002;
0427: }
0428: }
0429: if (jjte002 instanceof ParseException) {
0430: {
0431: if (true)
0432: throw (ParseException) jjte002;
0433: }
0434: }
0435: {
0436: if (true)
0437: throw (Error) jjte002;
0438: }
0439: } finally {
0440: if (jjtc002) {
0441: jjtree.closeNodeScope(jjtn002, true);
0442: jjtreeCloseNodeScope(jjtn002);
0443: }
0444: }
0445: break;
0446: default:
0447: jj_la1[7] = jj_gen;
0448: ;
0449: }
0450: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0451: case IMPLEMENTS:
0452: jj_consume_token(IMPLEMENTS);
0453: _INTERFACELIST();
0454: break;
0455: default:
0456: jj_la1[8] = jj_gen;
0457: ;
0458: }
0459: ClassBody();
0460: }
0461:
0462: final public void ClassBody() throws ParseException {
0463: jj_consume_token(LBRACE);
0464: label_4: while (true) {
0465: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0466: case ABSTRACT:
0467: case BOOLEAN:
0468: case BYTE:
0469: case CHAR:
0470: case CLASS:
0471: case DOUBLE:
0472: case FINAL:
0473: case FLOAT:
0474: case INT:
0475: case INTERFACE:
0476: case LONG:
0477: case NATIVE:
0478: case PRIVATE:
0479: case PROTECTED:
0480: case PUBLIC:
0481: case SHORT:
0482: case STATIC:
0483: case STRICTFP:
0484: case SYNCHRONIZED:
0485: case TRANSIENT:
0486: case VOID:
0487: case VOLATILE:
0488: case IDENTIFIER:
0489: case LBRACE:
0490: ;
0491: break;
0492: default:
0493: jj_la1[9] = jj_gen;
0494: break label_4;
0495: }
0496: ClassBodyDeclaration();
0497: }
0498: jj_consume_token(RBRACE);
0499: }
0500:
0501: final public void NestedClassDeclaration() throws ParseException {
0502: /*@bgen(jjtree) #_INNERCLASS( true) */
0503: SimpleNode jjtn000 = new SimpleNode(JJT_INNERCLASS);
0504: boolean jjtc000 = true;
0505: jjtree.openNodeScope(jjtn000);
0506: jjtreeOpenNodeScope(jjtn000);
0507: try {
0508: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
0509: boolean jjtc001 = true;
0510: jjtree.openNodeScope(jjtn001);
0511: jjtreeOpenNodeScope(jjtn001);
0512: try {
0513: label_5: while (true) {
0514: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0515: case ABSTRACT:
0516: case FINAL:
0517: case PRIVATE:
0518: case PROTECTED:
0519: case PUBLIC:
0520: case STATIC:
0521: case STRICTFP:
0522: ;
0523: break;
0524: default:
0525: jj_la1[10] = jj_gen;
0526: break label_5;
0527: }
0528: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0529: case STATIC:
0530: _STATIC();
0531: break;
0532: case ABSTRACT:
0533: _ABSTRACT();
0534: break;
0535: case FINAL:
0536: _FINAL();
0537: break;
0538: case STRICTFP:
0539: _STRICTFP();
0540: break;
0541: case PUBLIC:
0542: _PUBLIC();
0543: break;
0544: case PROTECTED:
0545: _PROTECTED();
0546: break;
0547: case PRIVATE:
0548: _PRIVATE();
0549: break;
0550: default:
0551: jj_la1[11] = jj_gen;
0552: jj_consume_token(-1);
0553: throw new ParseException();
0554: }
0555: }
0556: } catch (Throwable jjte001) {
0557: if (jjtc001) {
0558: jjtree.clearNodeScope(jjtn001);
0559: jjtc001 = false;
0560: } else {
0561: jjtree.popNode();
0562: }
0563: if (jjte001 instanceof RuntimeException) {
0564: {
0565: if (true)
0566: throw (RuntimeException) jjte001;
0567: }
0568: }
0569: if (jjte001 instanceof ParseException) {
0570: {
0571: if (true)
0572: throw (ParseException) jjte001;
0573: }
0574: }
0575: {
0576: if (true)
0577: throw (Error) jjte001;
0578: }
0579: } finally {
0580: if (jjtc001) {
0581: jjtree.closeNodeScope(jjtn001, true);
0582: jjtreeCloseNodeScope(jjtn001);
0583: }
0584: }
0585: UnmodifiedClassDeclaration();
0586: } catch (Throwable jjte000) {
0587: if (jjtc000) {
0588: jjtree.clearNodeScope(jjtn000);
0589: jjtc000 = false;
0590: } else {
0591: jjtree.popNode();
0592: }
0593: if (jjte000 instanceof RuntimeException) {
0594: {
0595: if (true)
0596: throw (RuntimeException) jjte000;
0597: }
0598: }
0599: if (jjte000 instanceof ParseException) {
0600: {
0601: if (true)
0602: throw (ParseException) jjte000;
0603: }
0604: }
0605: {
0606: if (true)
0607: throw (Error) jjte000;
0608: }
0609: } finally {
0610: if (jjtc000) {
0611: jjtree.closeNodeScope(jjtn000, true);
0612: jjtreeCloseNodeScope(jjtn000);
0613: }
0614: }
0615: }
0616:
0617: final public void ClassBodyDeclaration() throws ParseException {
0618: if (jj_2_2(2)) {
0619: Initializer();
0620: label_6: while (true) {
0621: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0622: case SEMICOLON:
0623: ;
0624: break;
0625: default:
0626: jj_la1[12] = jj_gen;
0627: break label_6;
0628: }
0629: jj_consume_token(SEMICOLON);
0630: }
0631: } else if (jj_2_3(2147483647)) {
0632: NestedClassDeclaration();
0633: label_7: while (true) {
0634: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0635: case SEMICOLON:
0636: ;
0637: break;
0638: default:
0639: jj_la1[13] = jj_gen;
0640: break label_7;
0641: }
0642: jj_consume_token(SEMICOLON);
0643: }
0644: } else if (jj_2_4(2147483647)) {
0645: NestedInterfaceDeclaration();
0646: label_8: while (true) {
0647: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0648: case SEMICOLON:
0649: ;
0650: break;
0651: default:
0652: jj_la1[14] = jj_gen;
0653: break label_8;
0654: }
0655: jj_consume_token(SEMICOLON);
0656: }
0657: } else if (jj_2_5(2147483647)) {
0658: ConstructorDeclaration();
0659: label_9: while (true) {
0660: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0661: case SEMICOLON:
0662: ;
0663: break;
0664: default:
0665: jj_la1[15] = jj_gen;
0666: break label_9;
0667: }
0668: jj_consume_token(SEMICOLON);
0669: }
0670: } else if (jj_2_6(2147483647)) {
0671: MethodDeclaration();
0672: label_10: while (true) {
0673: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0674: case SEMICOLON:
0675: ;
0676: break;
0677: default:
0678: jj_la1[16] = jj_gen;
0679: break label_10;
0680: }
0681: jj_consume_token(SEMICOLON);
0682: }
0683: } else {
0684: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0685: case BOOLEAN:
0686: case BYTE:
0687: case CHAR:
0688: case DOUBLE:
0689: case FINAL:
0690: case FLOAT:
0691: case INT:
0692: case LONG:
0693: case PRIVATE:
0694: case PROTECTED:
0695: case PUBLIC:
0696: case SHORT:
0697: case STATIC:
0698: case STRICTFP:
0699: case TRANSIENT:
0700: case VOLATILE:
0701: case IDENTIFIER:
0702: FieldDeclaration();
0703: label_11: while (true) {
0704: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0705: case SEMICOLON:
0706: ;
0707: break;
0708: default:
0709: jj_la1[17] = jj_gen;
0710: break label_11;
0711: }
0712: jj_consume_token(SEMICOLON);
0713: }
0714: break;
0715: default:
0716: jj_la1[18] = jj_gen;
0717: jj_consume_token(-1);
0718: throw new ParseException();
0719: }
0720: }
0721: }
0722:
0723: // This production is to determine lookahead only.
0724: final public void MethodDeclarationLookahead()
0725: throws ParseException {
0726: label_12: while (true) {
0727: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0728: case ABSTRACT:
0729: case FINAL:
0730: case NATIVE:
0731: case PRIVATE:
0732: case PROTECTED:
0733: case PUBLIC:
0734: case STATIC:
0735: case STRICTFP:
0736: case SYNCHRONIZED:
0737: ;
0738: break;
0739: default:
0740: jj_la1[19] = jj_gen;
0741: break label_12;
0742: }
0743: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0744: case PUBLIC:
0745: jj_consume_token(PUBLIC);
0746: break;
0747: case PROTECTED:
0748: jj_consume_token(PROTECTED);
0749: break;
0750: case PRIVATE:
0751: jj_consume_token(PRIVATE);
0752: break;
0753: case STATIC:
0754: jj_consume_token(STATIC);
0755: break;
0756: case ABSTRACT:
0757: jj_consume_token(ABSTRACT);
0758: break;
0759: case FINAL:
0760: jj_consume_token(FINAL);
0761: break;
0762: case STRICTFP:
0763: jj_consume_token(STRICTFP);
0764: break;
0765: case NATIVE:
0766: jj_consume_token(NATIVE);
0767: break;
0768: case SYNCHRONIZED:
0769: jj_consume_token(SYNCHRONIZED);
0770: break;
0771: default:
0772: jj_la1[20] = jj_gen;
0773: jj_consume_token(-1);
0774: throw new ParseException();
0775: }
0776: }
0777: ResultType();
0778: jj_consume_token(IDENTIFIER);
0779: jj_consume_token(LPAREN);
0780: }
0781:
0782: final public void InterfaceDeclaration() throws ParseException {
0783: /*@bgen(jjtree) #_INTERFACE( true) */
0784: SimpleNode jjtn000 = new SimpleNode(JJT_INTERFACE);
0785: boolean jjtc000 = true;
0786: jjtree.openNodeScope(jjtn000);
0787: jjtreeOpenNodeScope(jjtn000);
0788: try {
0789: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
0790: boolean jjtc001 = true;
0791: jjtree.openNodeScope(jjtn001);
0792: jjtreeOpenNodeScope(jjtn001);
0793: try {
0794: label_13: while (true) {
0795: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0796: case ABSTRACT:
0797: case PUBLIC:
0798: ;
0799: break;
0800: default:
0801: jj_la1[21] = jj_gen;
0802: break label_13;
0803: }
0804: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0805: case ABSTRACT:
0806: _ABSTRACT();
0807: break;
0808: case PUBLIC:
0809: _PUBLIC();
0810: break;
0811: default:
0812: jj_la1[22] = jj_gen;
0813: jj_consume_token(-1);
0814: throw new ParseException();
0815: }
0816: }
0817: } catch (Throwable jjte001) {
0818: if (jjtc001) {
0819: jjtree.clearNodeScope(jjtn001);
0820: jjtc001 = false;
0821: } else {
0822: jjtree.popNode();
0823: }
0824: if (jjte001 instanceof RuntimeException) {
0825: {
0826: if (true)
0827: throw (RuntimeException) jjte001;
0828: }
0829: }
0830: if (jjte001 instanceof ParseException) {
0831: {
0832: if (true)
0833: throw (ParseException) jjte001;
0834: }
0835: }
0836: {
0837: if (true)
0838: throw (Error) jjte001;
0839: }
0840: } finally {
0841: if (jjtc001) {
0842: jjtree.closeNodeScope(jjtn001, true);
0843: jjtreeCloseNodeScope(jjtn001);
0844: }
0845: }
0846: UnmodifiedInterfaceDeclaration();
0847: } catch (Throwable jjte000) {
0848: if (jjtc000) {
0849: jjtree.clearNodeScope(jjtn000);
0850: jjtc000 = false;
0851: } else {
0852: jjtree.popNode();
0853: }
0854: if (jjte000 instanceof RuntimeException) {
0855: {
0856: if (true)
0857: throw (RuntimeException) jjte000;
0858: }
0859: }
0860: if (jjte000 instanceof ParseException) {
0861: {
0862: if (true)
0863: throw (ParseException) jjte000;
0864: }
0865: }
0866: {
0867: if (true)
0868: throw (Error) jjte000;
0869: }
0870: } finally {
0871: if (jjtc000) {
0872: jjtree.closeNodeScope(jjtn000, true);
0873: jjtreeCloseNodeScope(jjtn000);
0874: }
0875: }
0876: }
0877:
0878: final public void NestedInterfaceDeclaration()
0879: throws ParseException {
0880: /*@bgen(jjtree) #_INNERINTERFACE( true) */
0881: SimpleNode jjtn000 = new SimpleNode(JJT_INNERINTERFACE);
0882: boolean jjtc000 = true;
0883: jjtree.openNodeScope(jjtn000);
0884: jjtreeOpenNodeScope(jjtn000);
0885: try {
0886: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
0887: boolean jjtc001 = true;
0888: jjtree.openNodeScope(jjtn001);
0889: jjtreeOpenNodeScope(jjtn001);
0890: try {
0891: label_14: while (true) {
0892: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0893: case ABSTRACT:
0894: case FINAL:
0895: case PRIVATE:
0896: case PROTECTED:
0897: case PUBLIC:
0898: case STATIC:
0899: ;
0900: break;
0901: default:
0902: jj_la1[23] = jj_gen;
0903: break label_14;
0904: }
0905: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0906: case STATIC:
0907: _STATIC();
0908: break;
0909: case ABSTRACT:
0910: _ABSTRACT();
0911: break;
0912: case FINAL:
0913: _FINAL();
0914: break;
0915: case PUBLIC:
0916: _PUBLIC();
0917: break;
0918: case PROTECTED:
0919: _PROTECTED();
0920: break;
0921: case PRIVATE:
0922: _PRIVATE();
0923: break;
0924: default:
0925: jj_la1[24] = jj_gen;
0926: jj_consume_token(-1);
0927: throw new ParseException();
0928: }
0929: }
0930: } catch (Throwable jjte001) {
0931: if (jjtc001) {
0932: jjtree.clearNodeScope(jjtn001);
0933: jjtc001 = false;
0934: } else {
0935: jjtree.popNode();
0936: }
0937: if (jjte001 instanceof RuntimeException) {
0938: {
0939: if (true)
0940: throw (RuntimeException) jjte001;
0941: }
0942: }
0943: if (jjte001 instanceof ParseException) {
0944: {
0945: if (true)
0946: throw (ParseException) jjte001;
0947: }
0948: }
0949: {
0950: if (true)
0951: throw (Error) jjte001;
0952: }
0953: } finally {
0954: if (jjtc001) {
0955: jjtree.closeNodeScope(jjtn001, true);
0956: jjtreeCloseNodeScope(jjtn001);
0957: }
0958: }
0959: UnmodifiedInterfaceDeclaration();
0960: } catch (Throwable jjte000) {
0961: if (jjtc000) {
0962: jjtree.clearNodeScope(jjtn000);
0963: jjtc000 = false;
0964: } else {
0965: jjtree.popNode();
0966: }
0967: if (jjte000 instanceof RuntimeException) {
0968: {
0969: if (true)
0970: throw (RuntimeException) jjte000;
0971: }
0972: }
0973: if (jjte000 instanceof ParseException) {
0974: {
0975: if (true)
0976: throw (ParseException) jjte000;
0977: }
0978: }
0979: {
0980: if (true)
0981: throw (Error) jjte000;
0982: }
0983: } finally {
0984: if (jjtc000) {
0985: jjtree.closeNodeScope(jjtn000, true);
0986: jjtreeCloseNodeScope(jjtn000);
0987: }
0988: }
0989: }
0990:
0991: final public void UnmodifiedInterfaceDeclaration()
0992: throws ParseException {
0993: jj_consume_token(INTERFACE);
0994: SimpleNode jjtn001 = new SimpleNode(JJT_NAME);
0995: boolean jjtc001 = true;
0996: jjtree.openNodeScope(jjtn001);
0997: jjtreeOpenNodeScope(jjtn001);
0998: try {
0999: _IDENTIFIER();
1000: } catch (Throwable jjte001) {
1001: if (jjtc001) {
1002: jjtree.clearNodeScope(jjtn001);
1003: jjtc001 = false;
1004: } else {
1005: jjtree.popNode();
1006: }
1007: if (jjte001 instanceof RuntimeException) {
1008: {
1009: if (true)
1010: throw (RuntimeException) jjte001;
1011: }
1012: }
1013: if (jjte001 instanceof ParseException) {
1014: {
1015: if (true)
1016: throw (ParseException) jjte001;
1017: }
1018: }
1019: {
1020: if (true)
1021: throw (Error) jjte001;
1022: }
1023: } finally {
1024: if (jjtc001) {
1025: jjtree.closeNodeScope(jjtn001, true);
1026: jjtreeCloseNodeScope(jjtn001);
1027: }
1028: }
1029: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1030: case EXTENDS:
1031: jj_consume_token(EXTENDS);
1032: _INTERFACELIST();
1033: break;
1034: default:
1035: jj_la1[25] = jj_gen;
1036: ;
1037: }
1038: jj_consume_token(LBRACE);
1039: label_15: while (true) {
1040: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1041: case ABSTRACT:
1042: case BOOLEAN:
1043: case BYTE:
1044: case CHAR:
1045: case CLASS:
1046: case DOUBLE:
1047: case FINAL:
1048: case FLOAT:
1049: case INT:
1050: case INTERFACE:
1051: case LONG:
1052: case NATIVE:
1053: case PRIVATE:
1054: case PROTECTED:
1055: case PUBLIC:
1056: case SHORT:
1057: case STATIC:
1058: case STRICTFP:
1059: case SYNCHRONIZED:
1060: case TRANSIENT:
1061: case VOID:
1062: case VOLATILE:
1063: case IDENTIFIER:
1064: ;
1065: break;
1066: default:
1067: jj_la1[26] = jj_gen;
1068: break label_15;
1069: }
1070: InterfaceMemberDeclaration();
1071: }
1072: jj_consume_token(RBRACE);
1073: }
1074:
1075: final public void InterfaceMemberDeclaration()
1076: throws ParseException {
1077: if (jj_2_7(2147483647)) {
1078: NestedClassDeclaration();
1079: label_16: while (true) {
1080: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1081: case SEMICOLON:
1082: ;
1083: break;
1084: default:
1085: jj_la1[27] = jj_gen;
1086: break label_16;
1087: }
1088: jj_consume_token(SEMICOLON);
1089: }
1090: } else if (jj_2_8(2147483647)) {
1091: NestedInterfaceDeclaration();
1092: label_17: while (true) {
1093: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1094: case SEMICOLON:
1095: ;
1096: break;
1097: default:
1098: jj_la1[28] = jj_gen;
1099: break label_17;
1100: }
1101: jj_consume_token(SEMICOLON);
1102: }
1103: } else if (jj_2_9(2147483647)) {
1104: MethodDeclaration();
1105: label_18: while (true) {
1106: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1107: case SEMICOLON:
1108: ;
1109: break;
1110: default:
1111: jj_la1[29] = jj_gen;
1112: break label_18;
1113: }
1114: jj_consume_token(SEMICOLON);
1115: }
1116: } else {
1117: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1118: case BOOLEAN:
1119: case BYTE:
1120: case CHAR:
1121: case DOUBLE:
1122: case FINAL:
1123: case FLOAT:
1124: case INT:
1125: case LONG:
1126: case PRIVATE:
1127: case PROTECTED:
1128: case PUBLIC:
1129: case SHORT:
1130: case STATIC:
1131: case STRICTFP:
1132: case TRANSIENT:
1133: case VOLATILE:
1134: case IDENTIFIER:
1135: FieldDeclaration();
1136: label_19: while (true) {
1137: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1138: case SEMICOLON:
1139: ;
1140: break;
1141: default:
1142: jj_la1[30] = jj_gen;
1143: break label_19;
1144: }
1145: jj_consume_token(SEMICOLON);
1146: }
1147: break;
1148: default:
1149: jj_la1[31] = jj_gen;
1150: jj_consume_token(-1);
1151: throw new ParseException();
1152: }
1153: }
1154: }
1155:
1156: final public void FieldDeclaration() throws ParseException {
1157: /*@bgen(jjtree) #_FIELD( true) */
1158: SimpleNode jjtn000 = new SimpleNode(JJT_FIELD);
1159: boolean jjtc000 = true;
1160: jjtree.openNodeScope(jjtn000);
1161: jjtreeOpenNodeScope(jjtn000);
1162: try {
1163: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
1164: boolean jjtc001 = true;
1165: jjtree.openNodeScope(jjtn001);
1166: jjtreeOpenNodeScope(jjtn001);
1167: try {
1168: label_20: while (true) {
1169: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1170: case FINAL:
1171: case PRIVATE:
1172: case PROTECTED:
1173: case PUBLIC:
1174: case STATIC:
1175: case STRICTFP:
1176: case TRANSIENT:
1177: case VOLATILE:
1178: ;
1179: break;
1180: default:
1181: jj_la1[32] = jj_gen;
1182: break label_20;
1183: }
1184: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1185: case PUBLIC:
1186: _PUBLIC();
1187: break;
1188: case PROTECTED:
1189: _PROTECTED();
1190: break;
1191: case PRIVATE:
1192: _PRIVATE();
1193: break;
1194: case STATIC:
1195: _STATIC();
1196: break;
1197: case FINAL:
1198: _FINAL();
1199: break;
1200: case TRANSIENT:
1201: _TRANSIENT();
1202: break;
1203: case VOLATILE:
1204: _VOLATILE();
1205: break;
1206: case STRICTFP:
1207: _STRICTFP();
1208: break;
1209: default:
1210: jj_la1[33] = jj_gen;
1211: jj_consume_token(-1);
1212: throw new ParseException();
1213: }
1214: }
1215: } catch (Throwable jjte001) {
1216: if (jjtc001) {
1217: jjtree.clearNodeScope(jjtn001);
1218: jjtc001 = false;
1219: } else {
1220: jjtree.popNode();
1221: }
1222: if (jjte001 instanceof RuntimeException) {
1223: {
1224: if (true)
1225: throw (RuntimeException) jjte001;
1226: }
1227: }
1228: if (jjte001 instanceof ParseException) {
1229: {
1230: if (true)
1231: throw (ParseException) jjte001;
1232: }
1233: }
1234: {
1235: if (true)
1236: throw (Error) jjte001;
1237: }
1238: } finally {
1239: if (jjtc001) {
1240: jjtree.closeNodeScope(jjtn001, true);
1241: jjtreeCloseNodeScope(jjtn001);
1242: }
1243: }
1244: Type();
1245: VariableDeclarator();
1246: label_21: while (true) {
1247: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1248: case COMMA:
1249: ;
1250: break;
1251: default:
1252: jj_la1[34] = jj_gen;
1253: break label_21;
1254: }
1255: jj_consume_token(COMMA);
1256: VariableDeclarator();
1257: }
1258: jj_consume_token(SEMICOLON);
1259: } catch (Throwable jjte000) {
1260: if (jjtc000) {
1261: jjtree.clearNodeScope(jjtn000);
1262: jjtc000 = false;
1263: } else {
1264: jjtree.popNode();
1265: }
1266: if (jjte000 instanceof RuntimeException) {
1267: {
1268: if (true)
1269: throw (RuntimeException) jjte000;
1270: }
1271: }
1272: if (jjte000 instanceof ParseException) {
1273: {
1274: if (true)
1275: throw (ParseException) jjte000;
1276: }
1277: }
1278: {
1279: if (true)
1280: throw (Error) jjte000;
1281: }
1282: } finally {
1283: if (jjtc000) {
1284: jjtree.closeNodeScope(jjtn000, true);
1285: jjtreeCloseNodeScope(jjtn000);
1286: }
1287: }
1288: }
1289:
1290: final public void VariableDeclarator() throws ParseException {
1291: /*@bgen(jjtree) #_FIELDVAR( true) */
1292: SimpleNode jjtn000 = new SimpleNode(JJT_FIELDVAR);
1293: boolean jjtc000 = true;
1294: jjtree.openNodeScope(jjtn000);
1295: jjtreeOpenNodeScope(jjtn000);
1296: try {
1297: VariableDeclaratorId();
1298: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1299: case ASSIGN:
1300: jj_consume_token(ASSIGN);
1301: SimpleNode jjtn001 = new SimpleNode(JJT_CODE);
1302: boolean jjtc001 = true;
1303: jjtree.openNodeScope(jjtn001);
1304: jjtreeOpenNodeScope(jjtn001);
1305: try {
1306: VariableInitializer();
1307: } catch (Throwable jjte001) {
1308: if (jjtc001) {
1309: jjtree.clearNodeScope(jjtn001);
1310: jjtc001 = false;
1311: } else {
1312: jjtree.popNode();
1313: }
1314: if (jjte001 instanceof RuntimeException) {
1315: {
1316: if (true)
1317: throw (RuntimeException) jjte001;
1318: }
1319: }
1320: if (jjte001 instanceof ParseException) {
1321: {
1322: if (true)
1323: throw (ParseException) jjte001;
1324: }
1325: }
1326: {
1327: if (true)
1328: throw (Error) jjte001;
1329: }
1330: } finally {
1331: if (jjtc001) {
1332: jjtree.closeNodeScope(jjtn001, true);
1333: jjtreeCloseNodeScope(jjtn001);
1334: }
1335: }
1336: break;
1337: default:
1338: jj_la1[35] = jj_gen;
1339: ;
1340: }
1341: } catch (Throwable jjte000) {
1342: if (jjtc000) {
1343: jjtree.clearNodeScope(jjtn000);
1344: jjtc000 = false;
1345: } else {
1346: jjtree.popNode();
1347: }
1348: if (jjte000 instanceof RuntimeException) {
1349: {
1350: if (true)
1351: throw (RuntimeException) jjte000;
1352: }
1353: }
1354: if (jjte000 instanceof ParseException) {
1355: {
1356: if (true)
1357: throw (ParseException) jjte000;
1358: }
1359: }
1360: {
1361: if (true)
1362: throw (Error) jjte000;
1363: }
1364: } finally {
1365: if (jjtc000) {
1366: jjtree.closeNodeScope(jjtn000, true);
1367: jjtreeCloseNodeScope(jjtn000);
1368: }
1369: }
1370: }
1371:
1372: final public void VariableDeclaratorId() throws ParseException {
1373: SimpleNode jjtn001 = new SimpleNode(JJT_NAME);
1374: boolean jjtc001 = true;
1375: jjtree.openNodeScope(jjtn001);
1376: jjtreeOpenNodeScope(jjtn001);
1377: try {
1378: _IDENTIFIER();
1379: } catch (Throwable jjte001) {
1380: if (jjtc001) {
1381: jjtree.clearNodeScope(jjtn001);
1382: jjtc001 = false;
1383: } else {
1384: jjtree.popNode();
1385: }
1386: if (jjte001 instanceof RuntimeException) {
1387: {
1388: if (true)
1389: throw (RuntimeException) jjte001;
1390: }
1391: }
1392: if (jjte001 instanceof ParseException) {
1393: {
1394: if (true)
1395: throw (ParseException) jjte001;
1396: }
1397: }
1398: {
1399: if (true)
1400: throw (Error) jjte001;
1401: }
1402: } finally {
1403: if (jjtc001) {
1404: jjtree.closeNodeScope(jjtn001, true);
1405: jjtreeCloseNodeScope(jjtn001);
1406: }
1407: }
1408: _ARRAYDECLARATOR();
1409: }
1410:
1411: final public void VariableInitializer() throws ParseException {
1412: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1413: case LBRACE:
1414: ArrayInitializer();
1415: break;
1416: case BOOLEAN:
1417: case BYTE:
1418: case CHAR:
1419: case DOUBLE:
1420: case FALSE:
1421: case FLOAT:
1422: case INT:
1423: case LONG:
1424: case NEW:
1425: case NULL:
1426: case SHORT:
1427: case SUPER:
1428: case THIS:
1429: case TRUE:
1430: case VOID:
1431: case INTEGER_LITERAL:
1432: case FLOATING_POINT_LITERAL:
1433: case CHARACTER_LITERAL:
1434: case STRING_LITERAL:
1435: case IDENTIFIER:
1436: case LPAREN:
1437: case BANG:
1438: case TILDE:
1439: case INCR:
1440: case DECR:
1441: case PLUS:
1442: case MINUS:
1443: Expression();
1444: break;
1445: default:
1446: jj_la1[36] = jj_gen;
1447: jj_consume_token(-1);
1448: throw new ParseException();
1449: }
1450: }
1451:
1452: final public void ArrayInitializer() throws ParseException {
1453: jj_consume_token(LBRACE);
1454: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1455: case BOOLEAN:
1456: case BYTE:
1457: case CHAR:
1458: case DOUBLE:
1459: case FALSE:
1460: case FLOAT:
1461: case INT:
1462: case LONG:
1463: case NEW:
1464: case NULL:
1465: case SHORT:
1466: case SUPER:
1467: case THIS:
1468: case TRUE:
1469: case VOID:
1470: case INTEGER_LITERAL:
1471: case FLOATING_POINT_LITERAL:
1472: case CHARACTER_LITERAL:
1473: case STRING_LITERAL:
1474: case IDENTIFIER:
1475: case LPAREN:
1476: case LBRACE:
1477: case BANG:
1478: case TILDE:
1479: case INCR:
1480: case DECR:
1481: case PLUS:
1482: case MINUS:
1483: VariableInitializer();
1484: label_22: while (true) {
1485: if (jj_2_10(2)) {
1486: ;
1487: } else {
1488: break label_22;
1489: }
1490: jj_consume_token(COMMA);
1491: VariableInitializer();
1492: }
1493: break;
1494: default:
1495: jj_la1[37] = jj_gen;
1496: ;
1497: }
1498: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1499: case COMMA:
1500: jj_consume_token(COMMA);
1501: break;
1502: default:
1503: jj_la1[38] = jj_gen;
1504: ;
1505: }
1506: jj_consume_token(RBRACE);
1507: }
1508:
1509: final public void MethodDeclaration() throws ParseException {
1510: /*@bgen(jjtree) #_METHOD( true) */
1511: SimpleNode jjtn000 = new SimpleNode(JJT_METHOD);
1512: boolean jjtc000 = true;
1513: jjtree.openNodeScope(jjtn000);
1514: jjtreeOpenNodeScope(jjtn000);
1515: try {
1516: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
1517: boolean jjtc001 = true;
1518: jjtree.openNodeScope(jjtn001);
1519: jjtreeOpenNodeScope(jjtn001);
1520: try {
1521: label_23: while (true) {
1522: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1523: case ABSTRACT:
1524: case FINAL:
1525: case NATIVE:
1526: case PRIVATE:
1527: case PROTECTED:
1528: case PUBLIC:
1529: case STATIC:
1530: case STRICTFP:
1531: case SYNCHRONIZED:
1532: ;
1533: break;
1534: default:
1535: jj_la1[39] = jj_gen;
1536: break label_23;
1537: }
1538: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1539: case PUBLIC:
1540: _PUBLIC();
1541: break;
1542: case PROTECTED:
1543: _PROTECTED();
1544: break;
1545: case PRIVATE:
1546: _PRIVATE();
1547: break;
1548: case STATIC:
1549: _STATIC();
1550: break;
1551: case ABSTRACT:
1552: _ABSTRACT();
1553: break;
1554: case FINAL:
1555: _FINAL();
1556: break;
1557: case STRICTFP:
1558: _STRICTFP();
1559: break;
1560: case NATIVE:
1561: _NATIVE();
1562: break;
1563: case SYNCHRONIZED:
1564: _SYNCHRONIZED();
1565: break;
1566: default:
1567: jj_la1[40] = jj_gen;
1568: jj_consume_token(-1);
1569: throw new ParseException();
1570: }
1571: }
1572: } catch (Throwable jjte001) {
1573: if (jjtc001) {
1574: jjtree.clearNodeScope(jjtn001);
1575: jjtc001 = false;
1576: } else {
1577: jjtree.popNode();
1578: }
1579: if (jjte001 instanceof RuntimeException) {
1580: {
1581: if (true)
1582: throw (RuntimeException) jjte001;
1583: }
1584: }
1585: if (jjte001 instanceof ParseException) {
1586: {
1587: if (true)
1588: throw (ParseException) jjte001;
1589: }
1590: }
1591: {
1592: if (true)
1593: throw (Error) jjte001;
1594: }
1595: } finally {
1596: if (jjtc001) {
1597: jjtree.closeNodeScope(jjtn001, true);
1598: jjtreeCloseNodeScope(jjtn001);
1599: }
1600: }
1601: ResultType();
1602: MethodDeclarator();
1603: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1604: case THROWS:
1605: jj_consume_token(THROWS);
1606: SimpleNode jjtn002 = new SimpleNode(JJT_THROWS);
1607: boolean jjtc002 = true;
1608: jjtree.openNodeScope(jjtn002);
1609: jjtreeOpenNodeScope(jjtn002);
1610: try {
1611: NameList();
1612: } catch (Throwable jjte002) {
1613: if (jjtc002) {
1614: jjtree.clearNodeScope(jjtn002);
1615: jjtc002 = false;
1616: } else {
1617: jjtree.popNode();
1618: }
1619: if (jjte002 instanceof RuntimeException) {
1620: {
1621: if (true)
1622: throw (RuntimeException) jjte002;
1623: }
1624: }
1625: if (jjte002 instanceof ParseException) {
1626: {
1627: if (true)
1628: throw (ParseException) jjte002;
1629: }
1630: }
1631: {
1632: if (true)
1633: throw (Error) jjte002;
1634: }
1635: } finally {
1636: if (jjtc002) {
1637: jjtree.closeNodeScope(jjtn002, true);
1638: jjtreeCloseNodeScope(jjtn002);
1639: }
1640: }
1641: break;
1642: default:
1643: jj_la1[41] = jj_gen;
1644: ;
1645: }
1646: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1647: case LBRACE:
1648: SimpleNode jjtn003 = new SimpleNode(JJT_CODE);
1649: boolean jjtc003 = true;
1650: jjtree.openNodeScope(jjtn003);
1651: jjtreeOpenNodeScope(jjtn003);
1652: try {
1653: Block();
1654: } catch (Throwable jjte003) {
1655: if (jjtc003) {
1656: jjtree.clearNodeScope(jjtn003);
1657: jjtc003 = false;
1658: } else {
1659: jjtree.popNode();
1660: }
1661: if (jjte003 instanceof RuntimeException) {
1662: {
1663: if (true)
1664: throw (RuntimeException) jjte003;
1665: }
1666: }
1667: if (jjte003 instanceof ParseException) {
1668: {
1669: if (true)
1670: throw (ParseException) jjte003;
1671: }
1672: }
1673: {
1674: if (true)
1675: throw (Error) jjte003;
1676: }
1677: } finally {
1678: if (jjtc003) {
1679: jjtree.closeNodeScope(jjtn003, true);
1680: jjtreeCloseNodeScope(jjtn003);
1681: }
1682: }
1683: break;
1684: case SEMICOLON:
1685: jj_consume_token(SEMICOLON);
1686: break;
1687: default:
1688: jj_la1[42] = jj_gen;
1689: jj_consume_token(-1);
1690: throw new ParseException();
1691: }
1692: } catch (Throwable jjte000) {
1693: if (jjtc000) {
1694: jjtree.clearNodeScope(jjtn000);
1695: jjtc000 = false;
1696: } else {
1697: jjtree.popNode();
1698: }
1699: if (jjte000 instanceof RuntimeException) {
1700: {
1701: if (true)
1702: throw (RuntimeException) jjte000;
1703: }
1704: }
1705: if (jjte000 instanceof ParseException) {
1706: {
1707: if (true)
1708: throw (ParseException) jjte000;
1709: }
1710: }
1711: {
1712: if (true)
1713: throw (Error) jjte000;
1714: }
1715: } finally {
1716: if (jjtc000) {
1717: jjtree.closeNodeScope(jjtn000, true);
1718: jjtreeCloseNodeScope(jjtn000);
1719: }
1720: }
1721: }
1722:
1723: final public void MethodDeclarator() throws ParseException {
1724: SimpleNode jjtn001 = new SimpleNode(JJT_NAME);
1725: boolean jjtc001 = true;
1726: jjtree.openNodeScope(jjtn001);
1727: jjtreeOpenNodeScope(jjtn001);
1728: try {
1729: _IDENTIFIER();
1730: } catch (Throwable jjte001) {
1731: if (jjtc001) {
1732: jjtree.clearNodeScope(jjtn001);
1733: jjtc001 = false;
1734: } else {
1735: jjtree.popNode();
1736: }
1737: if (jjte001 instanceof RuntimeException) {
1738: {
1739: if (true)
1740: throw (RuntimeException) jjte001;
1741: }
1742: }
1743: if (jjte001 instanceof ParseException) {
1744: {
1745: if (true)
1746: throw (ParseException) jjte001;
1747: }
1748: }
1749: {
1750: if (true)
1751: throw (Error) jjte001;
1752: }
1753: } finally {
1754: if (jjtc001) {
1755: jjtree.closeNodeScope(jjtn001, true);
1756: jjtreeCloseNodeScope(jjtn001);
1757: }
1758: }
1759: FormalParameters();
1760: _ARRAYDECLARATOR();
1761: }
1762:
1763: final public void FormalParameters() throws ParseException {
1764: jj_consume_token(LPAREN);
1765: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1766: case BOOLEAN:
1767: case BYTE:
1768: case CHAR:
1769: case DOUBLE:
1770: case FINAL:
1771: case FLOAT:
1772: case INT:
1773: case LONG:
1774: case SHORT:
1775: case IDENTIFIER:
1776: FormalParameter();
1777: label_24: while (true) {
1778: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1779: case COMMA:
1780: ;
1781: break;
1782: default:
1783: jj_la1[43] = jj_gen;
1784: break label_24;
1785: }
1786: jj_consume_token(COMMA);
1787: FormalParameter();
1788: }
1789: break;
1790: default:
1791: jj_la1[44] = jj_gen;
1792: ;
1793: }
1794: jj_consume_token(RPAREN);
1795: }
1796:
1797: final public void FormalParameter() throws ParseException {
1798: /*@bgen(jjtree) #_PARAMETER( true) */
1799: SimpleNode jjtn000 = new SimpleNode(JJT_PARAMETER);
1800: boolean jjtc000 = true;
1801: jjtree.openNodeScope(jjtn000);
1802: jjtreeOpenNodeScope(jjtn000);
1803: try {
1804: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1805: case FINAL:
1806: SimpleNode jjtn001 = new SimpleNode(JJT_FINAL);
1807: boolean jjtc001 = true;
1808: jjtree.openNodeScope(jjtn001);
1809: jjtreeOpenNodeScope(jjtn001);
1810: try {
1811: jj_consume_token(FINAL);
1812: } finally {
1813: if (jjtc001) {
1814: jjtree.closeNodeScope(jjtn001, true);
1815: jjtreeCloseNodeScope(jjtn001);
1816: }
1817: }
1818: break;
1819: default:
1820: jj_la1[45] = jj_gen;
1821: ;
1822: }
1823: Type();
1824: VariableDeclaratorId();
1825: } catch (Throwable jjte000) {
1826: if (jjtc000) {
1827: jjtree.clearNodeScope(jjtn000);
1828: jjtc000 = false;
1829: } else {
1830: jjtree.popNode();
1831: }
1832: if (jjte000 instanceof RuntimeException) {
1833: {
1834: if (true)
1835: throw (RuntimeException) jjte000;
1836: }
1837: }
1838: if (jjte000 instanceof ParseException) {
1839: {
1840: if (true)
1841: throw (ParseException) jjte000;
1842: }
1843: }
1844: {
1845: if (true)
1846: throw (Error) jjte000;
1847: }
1848: } finally {
1849: if (jjtc000) {
1850: jjtree.closeNodeScope(jjtn000, true);
1851: jjtreeCloseNodeScope(jjtn000);
1852: }
1853: }
1854: }
1855:
1856: final public void ConstructorDeclaration() throws ParseException {
1857: /*@bgen(jjtree) #_CONSTRUCTOR( true) */
1858: SimpleNode jjtn000 = new SimpleNode(JJT_CONSTRUCTOR);
1859: boolean jjtc000 = true;
1860: jjtree.openNodeScope(jjtn000);
1861: jjtreeOpenNodeScope(jjtn000);
1862: try {
1863: SimpleNode jjtn001 = new SimpleNode(JJT_MODIFIER);
1864: boolean jjtc001 = true;
1865: jjtree.openNodeScope(jjtn001);
1866: jjtreeOpenNodeScope(jjtn001);
1867: try {
1868: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1869: case PRIVATE:
1870: case PROTECTED:
1871: case PUBLIC:
1872: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1873: case PUBLIC:
1874: _PUBLIC();
1875: break;
1876: case PROTECTED:
1877: _PROTECTED();
1878: break;
1879: case PRIVATE:
1880: _PRIVATE();
1881: break;
1882: default:
1883: jj_la1[46] = jj_gen;
1884: jj_consume_token(-1);
1885: throw new ParseException();
1886: }
1887: break;
1888: default:
1889: jj_la1[47] = jj_gen;
1890: ;
1891: }
1892: } catch (Throwable jjte001) {
1893: if (jjtc001) {
1894: jjtree.clearNodeScope(jjtn001);
1895: jjtc001 = false;
1896: } else {
1897: jjtree.popNode();
1898: }
1899: if (jjte001 instanceof RuntimeException) {
1900: {
1901: if (true)
1902: throw (RuntimeException) jjte001;
1903: }
1904: }
1905: if (jjte001 instanceof ParseException) {
1906: {
1907: if (true)
1908: throw (ParseException) jjte001;
1909: }
1910: }
1911: {
1912: if (true)
1913: throw (Error) jjte001;
1914: }
1915: } finally {
1916: if (jjtc001) {
1917: jjtree.closeNodeScope(jjtn001, true);
1918: jjtreeCloseNodeScope(jjtn001);
1919: }
1920: }
1921: SimpleNode jjtn002 = new SimpleNode(JJT_NAME);
1922: boolean jjtc002 = true;
1923: jjtree.openNodeScope(jjtn002);
1924: jjtreeOpenNodeScope(jjtn002);
1925: try {
1926: _IDENTIFIER();
1927: } catch (Throwable jjte002) {
1928: if (jjtc002) {
1929: jjtree.clearNodeScope(jjtn002);
1930: jjtc002 = false;
1931: } else {
1932: jjtree.popNode();
1933: }
1934: if (jjte002 instanceof RuntimeException) {
1935: {
1936: if (true)
1937: throw (RuntimeException) jjte002;
1938: }
1939: }
1940: if (jjte002 instanceof ParseException) {
1941: {
1942: if (true)
1943: throw (ParseException) jjte002;
1944: }
1945: }
1946: {
1947: if (true)
1948: throw (Error) jjte002;
1949: }
1950: } finally {
1951: if (jjtc002) {
1952: jjtree.closeNodeScope(jjtn002, true);
1953: jjtreeCloseNodeScope(jjtn002);
1954: }
1955: }
1956: FormalParameters();
1957: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1958: case THROWS:
1959: jj_consume_token(THROWS);
1960: SimpleNode jjtn003 = new SimpleNode(JJT_THROWS);
1961: boolean jjtc003 = true;
1962: jjtree.openNodeScope(jjtn003);
1963: jjtreeOpenNodeScope(jjtn003);
1964: try {
1965: NameList();
1966: } catch (Throwable jjte003) {
1967: if (jjtc003) {
1968: jjtree.clearNodeScope(jjtn003);
1969: jjtc003 = false;
1970: } else {
1971: jjtree.popNode();
1972: }
1973: if (jjte003 instanceof RuntimeException) {
1974: {
1975: if (true)
1976: throw (RuntimeException) jjte003;
1977: }
1978: }
1979: if (jjte003 instanceof ParseException) {
1980: {
1981: if (true)
1982: throw (ParseException) jjte003;
1983: }
1984: }
1985: {
1986: if (true)
1987: throw (Error) jjte003;
1988: }
1989: } finally {
1990: if (jjtc003) {
1991: jjtree.closeNodeScope(jjtn003, true);
1992: jjtreeCloseNodeScope(jjtn003);
1993: }
1994: }
1995: break;
1996: default:
1997: jj_la1[48] = jj_gen;
1998: ;
1999: }
2000: SimpleNode jjtn004 = new SimpleNode(JJT_CODE);
2001: boolean jjtc004 = true;
2002: jjtree.openNodeScope(jjtn004);
2003: jjtreeOpenNodeScope(jjtn004);
2004: try {
2005: jj_consume_token(LBRACE);
2006: if (jj_2_11(2147483647)) {
2007: ExplicitConstructorInvocation();
2008: } else {
2009: ;
2010: }
2011: label_25: while (true) {
2012: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2013: case ASSERT:
2014: case BOOLEAN:
2015: case BREAK:
2016: case BYTE:
2017: case CHAR:
2018: case CLASS:
2019: case CONTINUE:
2020: case DO:
2021: case DOUBLE:
2022: case FALSE:
2023: case FINAL:
2024: case FLOAT:
2025: case FOR:
2026: case IF:
2027: case INT:
2028: case INTERFACE:
2029: case LONG:
2030: case NEW:
2031: case NULL:
2032: case RETURN:
2033: case SHORT:
2034: case SUPER:
2035: case SWITCH:
2036: case SYNCHRONIZED:
2037: case THIS:
2038: case THROW:
2039: case TRUE:
2040: case TRY:
2041: case VOID:
2042: case WHILE:
2043: case INTEGER_LITERAL:
2044: case FLOATING_POINT_LITERAL:
2045: case CHARACTER_LITERAL:
2046: case STRING_LITERAL:
2047: case IDENTIFIER:
2048: case LPAREN:
2049: case LBRACE:
2050: case SEMICOLON:
2051: case INCR:
2052: case DECR:
2053: ;
2054: break;
2055: default:
2056: jj_la1[49] = jj_gen;
2057: break label_25;
2058: }
2059: BlockStatement();
2060: }
2061: jj_consume_token(RBRACE);
2062: } catch (Throwable jjte004) {
2063: if (jjtc004) {
2064: jjtree.clearNodeScope(jjtn004);
2065: jjtc004 = false;
2066: } else {
2067: jjtree.popNode();
2068: }
2069: if (jjte004 instanceof RuntimeException) {
2070: {
2071: if (true)
2072: throw (RuntimeException) jjte004;
2073: }
2074: }
2075: if (jjte004 instanceof ParseException) {
2076: {
2077: if (true)
2078: throw (ParseException) jjte004;
2079: }
2080: }
2081: {
2082: if (true)
2083: throw (Error) jjte004;
2084: }
2085: } finally {
2086: if (jjtc004) {
2087: jjtree.closeNodeScope(jjtn004, true);
2088: jjtreeCloseNodeScope(jjtn004);
2089: }
2090: }
2091: } catch (Throwable jjte000) {
2092: if (jjtc000) {
2093: jjtree.clearNodeScope(jjtn000);
2094: jjtc000 = false;
2095: } else {
2096: jjtree.popNode();
2097: }
2098: if (jjte000 instanceof RuntimeException) {
2099: {
2100: if (true)
2101: throw (RuntimeException) jjte000;
2102: }
2103: }
2104: if (jjte000 instanceof ParseException) {
2105: {
2106: if (true)
2107: throw (ParseException) jjte000;
2108: }
2109: }
2110: {
2111: if (true)
2112: throw (Error) jjte000;
2113: }
2114: } finally {
2115: if (jjtc000) {
2116: jjtree.closeNodeScope(jjtn000, true);
2117: jjtreeCloseNodeScope(jjtn000);
2118: }
2119: }
2120: }
2121:
2122: final public void ExplicitConstructorInvocation()
2123: throws ParseException {
2124: if (jj_2_13(2147483647)) {
2125: jj_consume_token(THIS);
2126: Arguments();
2127: jj_consume_token(SEMICOLON);
2128: } else {
2129: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2130: case BOOLEAN:
2131: case BYTE:
2132: case CHAR:
2133: case DOUBLE:
2134: case FALSE:
2135: case FLOAT:
2136: case INT:
2137: case LONG:
2138: case NEW:
2139: case NULL:
2140: case SHORT:
2141: case SUPER:
2142: case THIS:
2143: case TRUE:
2144: case VOID:
2145: case INTEGER_LITERAL:
2146: case FLOATING_POINT_LITERAL:
2147: case CHARACTER_LITERAL:
2148: case STRING_LITERAL:
2149: case IDENTIFIER:
2150: case LPAREN:
2151: if (jj_2_12(2)) {
2152: PrimaryExpression();
2153: jj_consume_token(DOT);
2154: } else {
2155: ;
2156: }
2157: jj_consume_token(SUPER);
2158: Arguments();
2159: jj_consume_token(SEMICOLON);
2160: break;
2161: default:
2162: jj_la1[50] = jj_gen;
2163: jj_consume_token(-1);
2164: throw new ParseException();
2165: }
2166: }
2167: }
2168:
2169: final public void Initializer() throws ParseException {
2170: /*@bgen(jjtree) #_INITIALIZER( true) */
2171: SimpleNode jjtn000 = new SimpleNode(JJT_INITIALIZER);
2172: boolean jjtc000 = true;
2173: jjtree.openNodeScope(jjtn000);
2174: jjtreeOpenNodeScope(jjtn000);
2175: try {
2176: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2177: case STATIC:
2178: SimpleNode jjtn001 = new SimpleNode(JJT_STATIC);
2179: boolean jjtc001 = true;
2180: jjtree.openNodeScope(jjtn001);
2181: jjtreeOpenNodeScope(jjtn001);
2182: try {
2183: jj_consume_token(STATIC);
2184: } finally {
2185: if (jjtc001) {
2186: jjtree.closeNodeScope(jjtn001, true);
2187: jjtreeCloseNodeScope(jjtn001);
2188: }
2189: }
2190: break;
2191: default:
2192: jj_la1[51] = jj_gen;
2193: ;
2194: }
2195: SimpleNode jjtn002 = new SimpleNode(JJT_CODE);
2196: boolean jjtc002 = true;
2197: jjtree.openNodeScope(jjtn002);
2198: jjtreeOpenNodeScope(jjtn002);
2199: try {
2200: Block();
2201: } catch (Throwable jjte002) {
2202: if (jjtc002) {
2203: jjtree.clearNodeScope(jjtn002);
2204: jjtc002 = false;
2205: } else {
2206: jjtree.popNode();
2207: }
2208: if (jjte002 instanceof RuntimeException) {
2209: {
2210: if (true)
2211: throw (RuntimeException) jjte002;
2212: }
2213: }
2214: if (jjte002 instanceof ParseException) {
2215: {
2216: if (true)
2217: throw (ParseException) jjte002;
2218: }
2219: }
2220: {
2221: if (true)
2222: throw (Error) jjte002;
2223: }
2224: } finally {
2225: if (jjtc002) {
2226: jjtree.closeNodeScope(jjtn002, true);
2227: jjtreeCloseNodeScope(jjtn002);
2228: }
2229: }
2230: } catch (Throwable jjte000) {
2231: if (jjtc000) {
2232: jjtree.clearNodeScope(jjtn000);
2233: jjtc000 = false;
2234: } else {
2235: jjtree.popNode();
2236: }
2237: if (jjte000 instanceof RuntimeException) {
2238: {
2239: if (true)
2240: throw (RuntimeException) jjte000;
2241: }
2242: }
2243: if (jjte000 instanceof ParseException) {
2244: {
2245: if (true)
2246: throw (ParseException) jjte000;
2247: }
2248: }
2249: {
2250: if (true)
2251: throw (Error) jjte000;
2252: }
2253: } finally {
2254: if (jjtc000) {
2255: jjtree.closeNodeScope(jjtn000, true);
2256: jjtreeCloseNodeScope(jjtn000);
2257: }
2258: }
2259: }
2260:
2261: /*
2262: * Type, name and expression syntax follows.
2263: */
2264: final public void Type() throws ParseException {
2265: /*@bgen(jjtree) #_TYPE( true) */
2266: SimpleNode jjtn000 = new SimpleNode(JJT_TYPE);
2267: boolean jjtc000 = true;
2268: jjtree.openNodeScope(jjtn000);
2269: jjtreeOpenNodeScope(jjtn000);
2270: try {
2271: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2272: case BOOLEAN:
2273: case BYTE:
2274: case CHAR:
2275: case DOUBLE:
2276: case FLOAT:
2277: case INT:
2278: case LONG:
2279: case SHORT:
2280: PrimitiveType();
2281: break;
2282: case IDENTIFIER:
2283: Name();
2284: break;
2285: default:
2286: jj_la1[52] = jj_gen;
2287: jj_consume_token(-1);
2288: throw new ParseException();
2289: }
2290: _ARRAYDECLARATOR();
2291: } catch (Throwable jjte000) {
2292: if (jjtc000) {
2293: jjtree.clearNodeScope(jjtn000);
2294: jjtc000 = false;
2295: } else {
2296: jjtree.popNode();
2297: }
2298: if (jjte000 instanceof RuntimeException) {
2299: {
2300: if (true)
2301: throw (RuntimeException) jjte000;
2302: }
2303: }
2304: if (jjte000 instanceof ParseException) {
2305: {
2306: if (true)
2307: throw (ParseException) jjte000;
2308: }
2309: }
2310: {
2311: if (true)
2312: throw (Error) jjte000;
2313: }
2314: } finally {
2315: if (jjtc000) {
2316: jjtree.closeNodeScope(jjtn000, true);
2317: jjtreeCloseNodeScope(jjtn000);
2318: }
2319: }
2320: }
2321:
2322: final public void PrimitiveType() throws ParseException {
2323: /*@bgen(jjtree) #_NAME( true) */
2324: SimpleNode jjtn000 = new SimpleNode(JJT_NAME);
2325: boolean jjtc000 = true;
2326: jjtree.openNodeScope(jjtn000);
2327: jjtreeOpenNodeScope(jjtn000);
2328: try {
2329: _PRIMITIVE();
2330: } catch (Throwable jjte000) {
2331: if (jjtc000) {
2332: jjtree.clearNodeScope(jjtn000);
2333: jjtc000 = false;
2334: } else {
2335: jjtree.popNode();
2336: }
2337: if (jjte000 instanceof RuntimeException) {
2338: {
2339: if (true)
2340: throw (RuntimeException) jjte000;
2341: }
2342: }
2343: if (jjte000 instanceof ParseException) {
2344: {
2345: if (true)
2346: throw (ParseException) jjte000;
2347: }
2348: }
2349: {
2350: if (true)
2351: throw (Error) jjte000;
2352: }
2353: } finally {
2354: if (jjtc000) {
2355: jjtree.closeNodeScope(jjtn000, true);
2356: jjtreeCloseNodeScope(jjtn000);
2357: }
2358: }
2359: }
2360:
2361: final public void _PRIMITIVE() throws ParseException {
2362: /*@bgen(jjtree) #_PRIMITIVE( true) */
2363: SimpleNode jjtn000 = new SimpleNode(JJT_PRIMITIVE);
2364: boolean jjtc000 = true;
2365: jjtree.openNodeScope(jjtn000);
2366: jjtreeOpenNodeScope(jjtn000);
2367: Token t;
2368: try {
2369: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2370: case BOOLEAN:
2371: t = jj_consume_token(BOOLEAN);
2372: jjtree.closeNodeScope(jjtn000, true);
2373: jjtc000 = false;
2374: jjtreeCloseNodeScope(jjtn000);
2375: jjtn000.setValue(t.toString());
2376: break;
2377: case CHAR:
2378: t = jj_consume_token(CHAR);
2379: jjtree.closeNodeScope(jjtn000, true);
2380: jjtc000 = false;
2381: jjtreeCloseNodeScope(jjtn000);
2382: jjtn000.setValue(t.toString());
2383: break;
2384: case BYTE:
2385: t = jj_consume_token(BYTE);
2386: jjtree.closeNodeScope(jjtn000, true);
2387: jjtc000 = false;
2388: jjtreeCloseNodeScope(jjtn000);
2389: jjtn000.setValue(t.toString());
2390: break;
2391: case SHORT:
2392: t = jj_consume_token(SHORT);
2393: jjtree.closeNodeScope(jjtn000, true);
2394: jjtc000 = false;
2395: jjtreeCloseNodeScope(jjtn000);
2396: jjtn000.setValue(t.toString());
2397: break;
2398: case INT:
2399: t = jj_consume_token(INT);
2400: jjtree.closeNodeScope(jjtn000, true);
2401: jjtc000 = false;
2402: jjtreeCloseNodeScope(jjtn000);
2403: jjtn000.setValue(t.toString());
2404: break;
2405: case LONG:
2406: t = jj_consume_token(LONG);
2407: jjtree.closeNodeScope(jjtn000, true);
2408: jjtc000 = false;
2409: jjtreeCloseNodeScope(jjtn000);
2410: jjtn000.setValue(t.toString());
2411: break;
2412: case FLOAT:
2413: t = jj_consume_token(FLOAT);
2414: jjtree.closeNodeScope(jjtn000, true);
2415: jjtc000 = false;
2416: jjtreeCloseNodeScope(jjtn000);
2417: jjtn000.setValue(t.toString());
2418: break;
2419: case DOUBLE:
2420: t = jj_consume_token(DOUBLE);
2421: jjtree.closeNodeScope(jjtn000, true);
2422: jjtc000 = false;
2423: jjtreeCloseNodeScope(jjtn000);
2424: jjtn000.setValue(t.toString());
2425: break;
2426: default:
2427: jj_la1[53] = jj_gen;
2428: jj_consume_token(-1);
2429: throw new ParseException();
2430: }
2431: } finally {
2432: if (jjtc000) {
2433: jjtree.closeNodeScope(jjtn000, true);
2434: jjtreeCloseNodeScope(jjtn000);
2435: }
2436: }
2437: }
2438:
2439: final public void ResultType() throws ParseException {
2440: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2441: case VOID:
2442: SimpleNode jjtn001 = new SimpleNode(JJT_TYPE);
2443: boolean jjtc001 = true;
2444: jjtree.openNodeScope(jjtn001);
2445: jjtreeOpenNodeScope(jjtn001);
2446: try {
2447: jj_consume_token(VOID);
2448: } finally {
2449: if (jjtc001) {
2450: jjtree.closeNodeScope(jjtn001, true);
2451: jjtreeCloseNodeScope(jjtn001);
2452: }
2453: }
2454: break;
2455: case BOOLEAN:
2456: case BYTE:
2457: case CHAR:
2458: case DOUBLE:
2459: case FLOAT:
2460: case INT:
2461: case LONG:
2462: case SHORT:
2463: case IDENTIFIER:
2464: Type();
2465: break;
2466: default:
2467: jj_la1[54] = jj_gen;
2468: jj_consume_token(-1);
2469: throw new ParseException();
2470: }
2471: }
2472:
2473: final public void Name() throws ParseException {
2474: /*@bgen(jjtree) #_NAME( true) */
2475: SimpleNode jjtn000 = new SimpleNode(JJT_NAME);
2476: boolean jjtc000 = true;
2477: jjtree.openNodeScope(jjtn000);
2478: jjtreeOpenNodeScope(jjtn000);
2479: try {
2480: _IDENTIFIER();
2481: label_26: while (true) {
2482: if (jj_2_14(2)) {
2483: ;
2484: } else {
2485: break label_26;
2486: }
2487: _DOT();
2488: _IDENTIFIER();
2489: }
2490: } catch (Throwable jjte000) {
2491: if (jjtc000) {
2492: jjtree.clearNodeScope(jjtn000);
2493: jjtc000 = false;
2494: } else {
2495: jjtree.popNode();
2496: }
2497: if (jjte000 instanceof RuntimeException) {
2498: {
2499: if (true)
2500: throw (RuntimeException) jjte000;
2501: }
2502: }
2503: if (jjte000 instanceof ParseException) {
2504: {
2505: if (true)
2506: throw (ParseException) jjte000;
2507: }
2508: }
2509: {
2510: if (true)
2511: throw (Error) jjte000;
2512: }
2513: } finally {
2514: if (jjtc000) {
2515: jjtree.closeNodeScope(jjtn000, true);
2516: jjtreeCloseNodeScope(jjtn000);
2517: }
2518: }
2519: }
2520:
2521: final public void NameList() throws ParseException {
2522: Name();
2523: label_27: while (true) {
2524: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2525: case COMMA:
2526: ;
2527: break;
2528: default:
2529: jj_la1[55] = jj_gen;
2530: break label_27;
2531: }
2532: jj_consume_token(COMMA);
2533: Name();
2534: }
2535: }
2536:
2537: final public void _INTERFACELIST() throws ParseException {
2538: SimpleNode jjtn001 = new SimpleNode(JJT_IMPLEMENTS);
2539: boolean jjtc001 = true;
2540: jjtree.openNodeScope(jjtn001);
2541: jjtreeOpenNodeScope(jjtn001);
2542: try {
2543: Name();
2544: } catch (Throwable jjte001) {
2545: if (jjtc001) {
2546: jjtree.clearNodeScope(jjtn001);
2547: jjtc001 = false;
2548: } else {
2549: jjtree.popNode();
2550: }
2551: if (jjte001 instanceof RuntimeException) {
2552: {
2553: if (true)
2554: throw (RuntimeException) jjte001;
2555: }
2556: }
2557: if (jjte001 instanceof ParseException) {
2558: {
2559: if (true)
2560: throw (ParseException) jjte001;
2561: }
2562: }
2563: {
2564: if (true)
2565: throw (Error) jjte001;
2566: }
2567: } finally {
2568: if (jjtc001) {
2569: jjtree.closeNodeScope(jjtn001, true);
2570: jjtreeCloseNodeScope(jjtn001);
2571: }
2572: }
2573: label_28: while (true) {
2574: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2575: case COMMA:
2576: ;
2577: break;
2578: default:
2579: jj_la1[56] = jj_gen;
2580: break label_28;
2581: }
2582: jj_consume_token(COMMA);
2583: SimpleNode jjtn002 = new SimpleNode(JJT_IMPLEMENTS);
2584: boolean jjtc002 = true;
2585: jjtree.openNodeScope(jjtn002);
2586: jjtreeOpenNodeScope(jjtn002);
2587: try {
2588: Name();
2589: } catch (Throwable jjte002) {
2590: if (jjtc002) {
2591: jjtree.clearNodeScope(jjtn002);
2592: jjtc002 = false;
2593: } else {
2594: jjtree.popNode();
2595: }
2596: if (jjte002 instanceof RuntimeException) {
2597: {
2598: if (true)
2599: throw (RuntimeException) jjte002;
2600: }
2601: }
2602: if (jjte002 instanceof ParseException) {
2603: {
2604: if (true)
2605: throw (ParseException) jjte002;
2606: }
2607: }
2608: {
2609: if (true)
2610: throw (Error) jjte002;
2611: }
2612: } finally {
2613: if (jjtc002) {
2614: jjtree.closeNodeScope(jjtn002, true);
2615: jjtreeCloseNodeScope(jjtn002);
2616: }
2617: }
2618: }
2619: }
2620:
2621: final public void _ARRAYDECLARATOR() throws ParseException {
2622: label_29: while (true) {
2623: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2624: case LBRACKET:
2625: ;
2626: break;
2627: default:
2628: jj_la1[57] = jj_gen;
2629: break label_29;
2630: }
2631: SimpleNode jjtn001 = new SimpleNode(JJT_ISARRAY);
2632: boolean jjtc001 = true;
2633: jjtree.openNodeScope(jjtn001);
2634: jjtreeOpenNodeScope(jjtn001);
2635: try {
2636: jj_consume_token(LBRACKET);
2637: jj_consume_token(RBRACKET);
2638: } finally {
2639: if (jjtc001) {
2640: jjtree.closeNodeScope(jjtn001, true);
2641: jjtreeCloseNodeScope(jjtn001);
2642: }
2643: }
2644: }
2645: }
2646:
2647: final public void _IDENTIFIER() throws ParseException {
2648: /*@bgen(jjtree) _IDENTIFIER */
2649: SimpleNode jjtn000 = new SimpleNode(JJT_IDENTIFIER);
2650: boolean jjtc000 = true;
2651: jjtree.openNodeScope(jjtn000);
2652: jjtreeOpenNodeScope(jjtn000);
2653: Token t;
2654: try {
2655: t = jj_consume_token(IDENTIFIER);
2656: jjtree.closeNodeScope(jjtn000, true);
2657: jjtc000 = false;
2658: jjtreeCloseNodeScope(jjtn000);
2659: jjtn000.setValue(t.toString());
2660: } finally {
2661: if (jjtc000) {
2662: jjtree.closeNodeScope(jjtn000, true);
2663: jjtreeCloseNodeScope(jjtn000);
2664: }
2665: }
2666: }
2667:
2668: final public void _DOT() throws ParseException {
2669: /*@bgen(jjtree) _DOT */
2670: SimpleNode jjtn000 = new SimpleNode(JJT_DOT);
2671: boolean jjtc000 = true;
2672: jjtree.openNodeScope(jjtn000);
2673: jjtreeOpenNodeScope(jjtn000);
2674: try {
2675: jj_consume_token(DOT);
2676: } finally {
2677: if (jjtc000) {
2678: jjtree.closeNodeScope(jjtn000, true);
2679: jjtreeCloseNodeScope(jjtn000);
2680: }
2681: }
2682: }
2683:
2684: final public void _PUBLIC() throws ParseException {
2685: /*@bgen(jjtree) _PUBLIC */
2686: SimpleNode jjtn000 = new SimpleNode(JJT_PUBLIC);
2687: boolean jjtc000 = true;
2688: jjtree.openNodeScope(jjtn000);
2689: jjtreeOpenNodeScope(jjtn000);
2690: try {
2691: jj_consume_token(PUBLIC);
2692: } finally {
2693: if (jjtc000) {
2694: jjtree.closeNodeScope(jjtn000, true);
2695: jjtreeCloseNodeScope(jjtn000);
2696: }
2697: }
2698: }
2699:
2700: final public void _PROTECTED() throws ParseException {
2701: /*@bgen(jjtree) _PROTECTED */
2702: SimpleNode jjtn000 = new SimpleNode(JJT_PROTECTED);
2703: boolean jjtc000 = true;
2704: jjtree.openNodeScope(jjtn000);
2705: jjtreeOpenNodeScope(jjtn000);
2706: try {
2707: jj_consume_token(PROTECTED);
2708: } finally {
2709: if (jjtc000) {
2710: jjtree.closeNodeScope(jjtn000, true);
2711: jjtreeCloseNodeScope(jjtn000);
2712: }
2713: }
2714: }
2715:
2716: final public void _PRIVATE() throws ParseException {
2717: /*@bgen(jjtree) _PRIVATE */
2718: SimpleNode jjtn000 = new SimpleNode(JJT_PRIVATE);
2719: boolean jjtc000 = true;
2720: jjtree.openNodeScope(jjtn000);
2721: jjtreeOpenNodeScope(jjtn000);
2722: try {
2723: jj_consume_token(PRIVATE);
2724: } finally {
2725: if (jjtc000) {
2726: jjtree.closeNodeScope(jjtn000, true);
2727: jjtreeCloseNodeScope(jjtn000);
2728: }
2729: }
2730: }
2731:
2732: final public void _STATIC() throws ParseException {
2733: /*@bgen(jjtree) _STATIC */
2734: SimpleNode jjtn000 = new SimpleNode(JJT_STATIC);
2735: boolean jjtc000 = true;
2736: jjtree.openNodeScope(jjtn000);
2737: jjtreeOpenNodeScope(jjtn000);
2738: try {
2739: jj_consume_token(STATIC);
2740: } finally {
2741: if (jjtc000) {
2742: jjtree.closeNodeScope(jjtn000, true);
2743: jjtreeCloseNodeScope(jjtn000);
2744: }
2745: }
2746: }
2747:
2748: final public void _ABSTRACT() throws ParseException {
2749: /*@bgen(jjtree) _ABSTRACT */
2750: SimpleNode jjtn000 = new SimpleNode(JJT_ABSTRACT);
2751: boolean jjtc000 = true;
2752: jjtree.openNodeScope(jjtn000);
2753: jjtreeOpenNodeScope(jjtn000);
2754: try {
2755: jj_consume_token(ABSTRACT);
2756: } finally {
2757: if (jjtc000) {
2758: jjtree.closeNodeScope(jjtn000, true);
2759: jjtreeCloseNodeScope(jjtn000);
2760: }
2761: }
2762: }
2763:
2764: final public void _SYNCHRONIZED() throws ParseException {
2765: /*@bgen(jjtree) _SYNCHRONIZED */
2766: SimpleNode jjtn000 = new SimpleNode(JJT_SYNCHRONIZED);
2767: boolean jjtc000 = true;
2768: jjtree.openNodeScope(jjtn000);
2769: jjtreeOpenNodeScope(jjtn000);
2770: try {
2771: jj_consume_token(SYNCHRONIZED);
2772: } finally {
2773: if (jjtc000) {
2774: jjtree.closeNodeScope(jjtn000, true);
2775: jjtreeCloseNodeScope(jjtn000);
2776: }
2777: }
2778: }
2779:
2780: final public void _FINAL() throws ParseException {
2781: /*@bgen(jjtree) _FINAL */
2782: SimpleNode jjtn000 = new SimpleNode(JJT_FINAL);
2783: boolean jjtc000 = true;
2784: jjtree.openNodeScope(jjtn000);
2785: jjtreeOpenNodeScope(jjtn000);
2786: try {
2787: jj_consume_token(FINAL);
2788: } finally {
2789: if (jjtc000) {
2790: jjtree.closeNodeScope(jjtn000, true);
2791: jjtreeCloseNodeScope(jjtn000);
2792: }
2793: }
2794: }
2795:
2796: final public void _TRANSIENT() throws ParseException {
2797: /*@bgen(jjtree) _TRANSIENT */
2798: SimpleNode jjtn000 = new SimpleNode(JJT_TRANSIENT);
2799: boolean jjtc000 = true;
2800: jjtree.openNodeScope(jjtn000);
2801: jjtreeOpenNodeScope(jjtn000);
2802: try {
2803: jj_consume_token(TRANSIENT);
2804: } finally {
2805: if (jjtc000) {
2806: jjtree.closeNodeScope(jjtn000, true);
2807: jjtreeCloseNodeScope(jjtn000);
2808: }
2809: }
2810: }
2811:
2812: final public void _VOLATILE() throws ParseException {
2813: /*@bgen(jjtree) _VOLATILE */
2814: SimpleNode jjtn000 = new SimpleNode(JJT_VOLATILE);
2815: boolean jjtc000 = true;
2816: jjtree.openNodeScope(jjtn000);
2817: jjtreeOpenNodeScope(jjtn000);
2818: try {
2819: jj_consume_token(VOLATILE);
2820: } finally {
2821: if (jjtc000) {
2822: jjtree.closeNodeScope(jjtn000, true);
2823: jjtreeCloseNodeScope(jjtn000);
2824: }
2825: }
2826: }
2827:
2828: final public void _STRICTFP() throws ParseException {
2829: /*@bgen(jjtree) _STRICTFP */
2830: SimpleNode jjtn000 = new SimpleNode(JJT_STRICTFP);
2831: boolean jjtc000 = true;
2832: jjtree.openNodeScope(jjtn000);
2833: jjtreeOpenNodeScope(jjtn000);
2834: try {
2835: jj_consume_token(STRICTFP);
2836: } finally {
2837: if (jjtc000) {
2838: jjtree.closeNodeScope(jjtn000, true);
2839: jjtreeCloseNodeScope(jjtn000);
2840: }
2841: }
2842: }
2843:
2844: final public void _NATIVE() throws ParseException {
2845: /*@bgen(jjtree) _NATIVE */
2846: SimpleNode jjtn000 = new SimpleNode(JJT_NATIVE);
2847: boolean jjtc000 = true;
2848: jjtree.openNodeScope(jjtn000);
2849: jjtreeOpenNodeScope(jjtn000);
2850: try {
2851: jj_consume_token(NATIVE);
2852: } finally {
2853: if (jjtc000) {
2854: jjtree.closeNodeScope(jjtn000, true);
2855: jjtreeCloseNodeScope(jjtn000);
2856: }
2857: }
2858: }
2859:
2860: /*
2861: * Expression syntax follows.
2862: */
2863: final public void Expression() throws ParseException {
2864: ConditionalExpression();
2865: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2866: case ASSIGN:
2867: case PLUSASSIGN:
2868: case MINUSASSIGN:
2869: case STARASSIGN:
2870: case SLASHASSIGN:
2871: case ANDASSIGN:
2872: case ORASSIGN:
2873: case XORASSIGN:
2874: case REMASSIGN:
2875: case LSHIFTASSIGN:
2876: case RSIGNEDSHIFTASSIGN:
2877: case RUNSIGNEDSHIFTASSIGN:
2878: AssignmentOperator();
2879: Expression();
2880: break;
2881: default:
2882: jj_la1[58] = jj_gen;
2883: ;
2884: }
2885: }
2886:
2887: final public void AssignmentOperator() throws ParseException {
2888: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2889: case ASSIGN:
2890: jj_consume_token(ASSIGN);
2891: break;
2892: case STARASSIGN:
2893: jj_consume_token(STARASSIGN);
2894: break;
2895: case SLASHASSIGN:
2896: jj_consume_token(SLASHASSIGN);
2897: break;
2898: case REMASSIGN:
2899: jj_consume_token(REMASSIGN);
2900: break;
2901: case PLUSASSIGN:
2902: jj_consume_token(PLUSASSIGN);
2903: break;
2904: case MINUSASSIGN:
2905: jj_consume_token(MINUSASSIGN);
2906: break;
2907: case LSHIFTASSIGN:
2908: jj_consume_token(LSHIFTASSIGN);
2909: break;
2910: case RSIGNEDSHIFTASSIGN:
2911: jj_consume_token(RSIGNEDSHIFTASSIGN);
2912: break;
2913: case RUNSIGNEDSHIFTASSIGN:
2914: jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2915: break;
2916: case ANDASSIGN:
2917: jj_consume_token(ANDASSIGN);
2918: break;
2919: case XORASSIGN:
2920: jj_consume_token(XORASSIGN);
2921: break;
2922: case ORASSIGN:
2923: jj_consume_token(ORASSIGN);
2924: break;
2925: default:
2926: jj_la1[59] = jj_gen;
2927: jj_consume_token(-1);
2928: throw new ParseException();
2929: }
2930: }
2931:
2932: final public void ConditionalExpression() throws ParseException {
2933: ConditionalOrExpression();
2934: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2935: case HOOK:
2936: jj_consume_token(HOOK);
2937: Expression();
2938: jj_consume_token(COLON);
2939: ConditionalExpression();
2940: break;
2941: default:
2942: jj_la1[60] = jj_gen;
2943: ;
2944: }
2945: }
2946:
2947: final public void ConditionalOrExpression() throws ParseException {
2948: ConditionalAndExpression();
2949: label_30: while (true) {
2950: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2951: case SC_OR:
2952: ;
2953: break;
2954: default:
2955: jj_la1[61] = jj_gen;
2956: break label_30;
2957: }
2958: jj_consume_token(SC_OR);
2959: ConditionalAndExpression();
2960: }
2961: }
2962:
2963: final public void ConditionalAndExpression() throws ParseException {
2964: InclusiveOrExpression();
2965: label_31: while (true) {
2966: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2967: case SC_AND:
2968: ;
2969: break;
2970: default:
2971: jj_la1[62] = jj_gen;
2972: break label_31;
2973: }
2974: jj_consume_token(SC_AND);
2975: InclusiveOrExpression();
2976: }
2977: }
2978:
2979: final public void InclusiveOrExpression() throws ParseException {
2980: ExclusiveOrExpression();
2981: label_32: while (true) {
2982: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2983: case BIT_OR:
2984: ;
2985: break;
2986: default:
2987: jj_la1[63] = jj_gen;
2988: break label_32;
2989: }
2990: jj_consume_token(BIT_OR);
2991: ExclusiveOrExpression();
2992: }
2993: }
2994:
2995: final public void ExclusiveOrExpression() throws ParseException {
2996: AndExpression();
2997: label_33: while (true) {
2998: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2999: case XOR:
3000: ;
3001: break;
3002: default:
3003: jj_la1[64] = jj_gen;
3004: break label_33;
3005: }
3006: jj_consume_token(XOR);
3007: AndExpression();
3008: }
3009: }
3010:
3011: final public void AndExpression() throws ParseException {
3012: EqualityExpression();
3013: label_34: while (true) {
3014: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3015: case BIT_AND:
3016: ;
3017: break;
3018: default:
3019: jj_la1[65] = jj_gen;
3020: break label_34;
3021: }
3022: jj_consume_token(BIT_AND);
3023: EqualityExpression();
3024: }
3025: }
3026:
3027: final public void EqualityExpression() throws ParseException {
3028: InstanceOfExpression();
3029: label_35: while (true) {
3030: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3031: case EQ:
3032: case NE:
3033: ;
3034: break;
3035: default:
3036: jj_la1[66] = jj_gen;
3037: break label_35;
3038: }
3039: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3040: case EQ:
3041: jj_consume_token(EQ);
3042: break;
3043: case NE:
3044: jj_consume_token(NE);
3045: break;
3046: default:
3047: jj_la1[67] = jj_gen;
3048: jj_consume_token(-1);
3049: throw new ParseException();
3050: }
3051: InstanceOfExpression();
3052: }
3053: }
3054:
3055: final public void InstanceOfExpression() throws ParseException {
3056: RelationalExpression();
3057: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3058: case INSTANCEOF:
3059: jj_consume_token(INSTANCEOF);
3060: Type();
3061: break;
3062: default:
3063: jj_la1[68] = jj_gen;
3064: ;
3065: }
3066: }
3067:
3068: final public void RelationalExpression() throws ParseException {
3069: ShiftExpression();
3070: label_36: while (true) {
3071: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3072: case GT:
3073: case LT:
3074: case LE:
3075: case GE:
3076: ;
3077: break;
3078: default:
3079: jj_la1[69] = jj_gen;
3080: break label_36;
3081: }
3082: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3083: case LT:
3084: jj_consume_token(LT);
3085: break;
3086: case GT:
3087: jj_consume_token(GT);
3088: break;
3089: case LE:
3090: jj_consume_token(LE);
3091: break;
3092: case GE:
3093: jj_consume_token(GE);
3094: break;
3095: default:
3096: jj_la1[70] = jj_gen;
3097: jj_consume_token(-1);
3098: throw new ParseException();
3099: }
3100: ShiftExpression();
3101: }
3102: }
3103:
3104: final public void ShiftExpression() throws ParseException {
3105: AdditiveExpression();
3106: label_37: while (true) {
3107: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3108: case LSHIFT:
3109: case RSIGNEDSHIFT:
3110: case RUNSIGNEDSHIFT:
3111: ;
3112: break;
3113: default:
3114: jj_la1[71] = jj_gen;
3115: break label_37;
3116: }
3117: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3118: case LSHIFT:
3119: jj_consume_token(LSHIFT);
3120: break;
3121: case RSIGNEDSHIFT:
3122: jj_consume_token(RSIGNEDSHIFT);
3123: break;
3124: case RUNSIGNEDSHIFT:
3125: jj_consume_token(RUNSIGNEDSHIFT);
3126: break;
3127: default:
3128: jj_la1[72] = jj_gen;
3129: jj_consume_token(-1);
3130: throw new ParseException();
3131: }
3132: AdditiveExpression();
3133: }
3134: }
3135:
3136: final public void AdditiveExpression() throws ParseException {
3137: MultiplicativeExpression();
3138: label_38: while (true) {
3139: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3140: case PLUS:
3141: case MINUS:
3142: ;
3143: break;
3144: default:
3145: jj_la1[73] = jj_gen;
3146: break label_38;
3147: }
3148: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3149: case PLUS:
3150: jj_consume_token(PLUS);
3151: break;
3152: case MINUS:
3153: jj_consume_token(MINUS);
3154: break;
3155: default:
3156: jj_la1[74] = jj_gen;
3157: jj_consume_token(-1);
3158: throw new ParseException();
3159: }
3160: MultiplicativeExpression();
3161: }
3162: }
3163:
3164: final public void MultiplicativeExpression() throws ParseException {
3165: UnaryExpression();
3166: label_39: while (true) {
3167: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3168: case STAR:
3169: case SLASH:
3170: case REM:
3171: ;
3172: break;
3173: default:
3174: jj_la1[75] = jj_gen;
3175: break label_39;
3176: }
3177: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3178: case STAR:
3179: jj_consume_token(STAR);
3180: break;
3181: case SLASH:
3182: jj_consume_token(SLASH);
3183: break;
3184: case REM:
3185: jj_consume_token(REM);
3186: break;
3187: default:
3188: jj_la1[76] = jj_gen;
3189: jj_consume_token(-1);
3190: throw new ParseException();
3191: }
3192: UnaryExpression();
3193: }
3194: }
3195:
3196: final public void UnaryExpression() throws ParseException {
3197: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3198: case PLUS:
3199: case MINUS:
3200: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3201: case PLUS:
3202: jj_consume_token(PLUS);
3203: break;
3204: case MINUS:
3205: jj_consume_token(MINUS);
3206: break;
3207: default:
3208: jj_la1[77] = jj_gen;
3209: jj_consume_token(-1);
3210: throw new ParseException();
3211: }
3212: UnaryExpression();
3213: break;
3214: case INCR:
3215: PreIncrementExpression();
3216: break;
3217: case DECR:
3218: PreDecrementExpression();
3219: break;
3220: case BOOLEAN:
3221: case BYTE:
3222: case CHAR:
3223: case DOUBLE:
3224: case FALSE:
3225: case FLOAT:
3226: case INT:
3227: case LONG:
3228: case NEW:
3229: case NULL:
3230: case SHORT:
3231: case SUPER:
3232: case THIS:
3233: case TRUE:
3234: case VOID:
3235: case INTEGER_LITERAL:
3236: case FLOATING_POINT_LITERAL:
3237: case CHARACTER_LITERAL:
3238: case STRING_LITERAL:
3239: case IDENTIFIER:
3240: case LPAREN:
3241: case BANG:
3242: case TILDE:
3243: UnaryExpressionNotPlusMinus();
3244: break;
3245: default:
3246: jj_la1[78] = jj_gen;
3247: jj_consume_token(-1);
3248: throw new ParseException();
3249: }
3250: }
3251:
3252: final public void PreIncrementExpression() throws ParseException {
3253: jj_consume_token(INCR);
3254: PrimaryExpression();
3255: }
3256:
3257: final public void PreDecrementExpression() throws ParseException {
3258: jj_consume_token(DECR);
3259: PrimaryExpression();
3260: }
3261:
3262: final public void UnaryExpressionNotPlusMinus()
3263: throws ParseException {
3264: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3265: case BANG:
3266: case TILDE:
3267: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3268: case TILDE:
3269: jj_consume_token(TILDE);
3270: break;
3271: case BANG:
3272: jj_consume_token(BANG);
3273: break;
3274: default:
3275: jj_la1[79] = jj_gen;
3276: jj_consume_token(-1);
3277: throw new ParseException();
3278: }
3279: UnaryExpression();
3280: break;
3281: default:
3282: jj_la1[80] = jj_gen;
3283: if (jj_2_15(2147483647)) {
3284: CastExpression();
3285: } else {
3286: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3287: case BOOLEAN:
3288: case BYTE:
3289: case CHAR:
3290: case DOUBLE:
3291: case FALSE:
3292: case FLOAT:
3293: case INT:
3294: case LONG:
3295: case NEW:
3296: case NULL:
3297: case SHORT:
3298: case SUPER:
3299: case THIS:
3300: case TRUE:
3301: case VOID:
3302: case INTEGER_LITERAL:
3303: case FLOATING_POINT_LITERAL:
3304: case CHARACTER_LITERAL:
3305: case STRING_LITERAL:
3306: case IDENTIFIER:
3307: case LPAREN:
3308: PostfixExpression();
3309: break;
3310: default:
3311: jj_la1[81] = jj_gen;
3312: jj_consume_token(-1);
3313: throw new ParseException();
3314: }
3315: }
3316: }
3317: }
3318:
3319: // This production is to determine lookahead only. The LOOKAHEAD specifications
3320: // below are not used, but they are there just to indicate that we know about
3321: // this.
3322: final public void CastLookahead() throws ParseException {
3323: if (jj_2_16(2)) {
3324: jj_consume_token(LPAREN);
3325: PrimitiveType();
3326: } else if (jj_2_17(2147483647)) {
3327: jj_consume_token(LPAREN);
3328: Name();
3329: jj_consume_token(LBRACKET);
3330: jj_consume_token(RBRACKET);
3331: } else {
3332: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3333: case LPAREN:
3334: jj_consume_token(LPAREN);
3335: Name();
3336: jj_consume_token(RPAREN);
3337: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3338: case TILDE:
3339: jj_consume_token(TILDE);
3340: break;
3341: case BANG:
3342: jj_consume_token(BANG);
3343: break;
3344: case LPAREN:
3345: jj_consume_token(LPAREN);
3346: break;
3347: case IDENTIFIER:
3348: jj_consume_token(IDENTIFIER);
3349: break;
3350: case THIS:
3351: jj_consume_token(THIS);
3352: break;
3353: case SUPER:
3354: jj_consume_token(SUPER);
3355: break;
3356: case NEW:
3357: jj_consume_token(NEW);
3358: break;
3359: case FALSE:
3360: case NULL:
3361: case TRUE:
3362: case INTEGER_LITERAL:
3363: case FLOATING_POINT_LITERAL:
3364: case CHARACTER_LITERAL:
3365: case STRING_LITERAL:
3366: Literal();
3367: break;
3368: default:
3369: jj_la1[82] = jj_gen;
3370: jj_consume_token(-1);
3371: throw new ParseException();
3372: }
3373: break;
3374: default:
3375: jj_la1[83] = jj_gen;
3376: jj_consume_token(-1);
3377: throw new ParseException();
3378: }
3379: }
3380: }
3381:
3382: final public void PostfixExpression() throws ParseException {
3383: PrimaryExpression();
3384: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3385: case INCR:
3386: case DECR:
3387: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3388: case INCR:
3389: jj_consume_token(INCR);
3390: break;
3391: case DECR:
3392: jj_consume_token(DECR);
3393: break;
3394: default:
3395: jj_la1[84] = jj_gen;
3396: jj_consume_token(-1);
3397: throw new ParseException();
3398: }
3399: break;
3400: default:
3401: jj_la1[85] = jj_gen;
3402: ;
3403: }
3404: }
3405:
3406: final public void CastExpression() throws ParseException {
3407: if (jj_2_18(2147483647)) {
3408: jj_consume_token(LPAREN);
3409: Type();
3410: jj_consume_token(RPAREN);
3411: UnaryExpression();
3412: } else {
3413: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3414: case LPAREN:
3415: jj_consume_token(LPAREN);
3416: Type();
3417: jj_consume_token(RPAREN);
3418: UnaryExpressionNotPlusMinus();
3419: break;
3420: default:
3421: jj_la1[86] = jj_gen;
3422: jj_consume_token(-1);
3423: throw new ParseException();
3424: }
3425: }
3426: }
3427:
3428: final public void PrimaryExpression() throws ParseException {
3429: PrimaryPrefix();
3430: label_40: while (true) {
3431: if (jj_2_19(2)) {
3432: ;
3433: } else {
3434: break label_40;
3435: }
3436: PrimarySuffix();
3437: }
3438: }
3439:
3440: final public void PrimaryPrefix() throws ParseException {
3441: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3442: case FALSE:
3443: case NULL:
3444: case TRUE:
3445: case INTEGER_LITERAL:
3446: case FLOATING_POINT_LITERAL:
3447: case CHARACTER_LITERAL:
3448: case STRING_LITERAL:
3449: Literal();
3450: break;
3451: case THIS:
3452: jj_consume_token(THIS);
3453: break;
3454: case SUPER:
3455: jj_consume_token(SUPER);
3456: jj_consume_token(DOT);
3457: jj_consume_token(IDENTIFIER);
3458: break;
3459: case LPAREN:
3460: jj_consume_token(LPAREN);
3461: Expression();
3462: jj_consume_token(RPAREN);
3463: break;
3464: case NEW:
3465: AllocationExpression();
3466: break;
3467: default:
3468: jj_la1[87] = jj_gen;
3469: if (jj_2_20(2147483647)) {
3470: ResultType();
3471: jj_consume_token(DOT);
3472: jj_consume_token(CLASS);
3473: } else {
3474: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3475: case IDENTIFIER:
3476: Name();
3477: break;
3478: default:
3479: jj_la1[88] = jj_gen;
3480: jj_consume_token(-1);
3481: throw new ParseException();
3482: }
3483: }
3484: }
3485: }
3486:
3487: final public void PrimarySuffix() throws ParseException {
3488: if (jj_2_21(2)) {
3489: jj_consume_token(DOT);
3490: jj_consume_token(THIS);
3491: } else if (jj_2_22(2)) {
3492: jj_consume_token(DOT);
3493: AllocationExpression();
3494: } else {
3495: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3496: case LBRACKET:
3497: jj_consume_token(LBRACKET);
3498: Expression();
3499: jj_consume_token(RBRACKET);
3500: break;
3501: case DOT:
3502: jj_consume_token(DOT);
3503: jj_consume_token(IDENTIFIER);
3504: break;
3505: case LPAREN:
3506: Arguments();
3507: break;
3508: default:
3509: jj_la1[89] = jj_gen;
3510: jj_consume_token(-1);
3511: throw new ParseException();
3512: }
3513: }
3514: }
3515:
3516: final public void Literal() throws ParseException {
3517: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3518: case INTEGER_LITERAL:
3519: jj_consume_token(INTEGER_LITERAL);
3520: break;
3521: case FLOATING_POINT_LITERAL:
3522: jj_consume_token(FLOATING_POINT_LITERAL);
3523: break;
3524: case CHARACTER_LITERAL:
3525: jj_consume_token(CHARACTER_LITERAL);
3526: break;
3527: case STRING_LITERAL:
3528: jj_consume_token(STRING_LITERAL);
3529: break;
3530: case FALSE:
3531: case TRUE:
3532: BooleanLiteral();
3533: break;
3534: case NULL:
3535: NullLiteral();
3536: break;
3537: default:
3538: jj_la1[90] = jj_gen;
3539: jj_consume_token(-1);
3540: throw new ParseException();
3541: }
3542: }
3543:
3544: final public void BooleanLiteral() throws ParseException {
3545: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3546: case TRUE:
3547: jj_consume_token(TRUE);
3548: break;
3549: case FALSE:
3550: jj_consume_token(FALSE);
3551: break;
3552: default:
3553: jj_la1[91] = jj_gen;
3554: jj_consume_token(-1);
3555: throw new ParseException();
3556: }
3557: }
3558:
3559: final public void NullLiteral() throws ParseException {
3560: jj_consume_token(NULL);
3561: }
3562:
3563: final public void Arguments() throws ParseException {
3564: jj_consume_token(LPAREN);
3565: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3566: case BOOLEAN:
3567: case BYTE:
3568: case CHAR:
3569: case DOUBLE:
3570: case FALSE:
3571: case FLOAT:
3572: case INT:
3573: case LONG:
3574: case NEW:
3575: case NULL:
3576: case SHORT:
3577: case SUPER:
3578: case THIS:
3579: case TRUE:
3580: case VOID:
3581: case INTEGER_LITERAL:
3582: case FLOATING_POINT_LITERAL:
3583: case CHARACTER_LITERAL:
3584: case STRING_LITERAL:
3585: case IDENTIFIER:
3586: case LPAREN:
3587: case BANG:
3588: case TILDE:
3589: case INCR:
3590: case DECR:
3591: case PLUS:
3592: case MINUS:
3593: ArgumentList();
3594: break;
3595: default:
3596: jj_la1[92] = jj_gen;
3597: ;
3598: }
3599: jj_consume_token(RPAREN);
3600: }
3601:
3602: final public void ArgumentList() throws ParseException {
3603: Expression();
3604: label_41: while (true) {
3605: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3606: case COMMA:
3607: ;
3608: break;
3609: default:
3610: jj_la1[93] = jj_gen;
3611: break label_41;
3612: }
3613: jj_consume_token(COMMA);
3614: Expression();
3615: }
3616: }
3617:
3618: final public void AllocationExpression() throws ParseException {
3619: if (jj_2_23(2)) {
3620: jj_consume_token(NEW);
3621: PrimitiveType();
3622: ArrayDimsAndInits();
3623: } else {
3624: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3625: case NEW:
3626: jj_consume_token(NEW);
3627: Name();
3628: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3629: case LBRACKET:
3630: ArrayDimsAndInits();
3631: break;
3632: case LPAREN:
3633: Arguments();
3634: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3635: case LBRACE:
3636: ClassBody();
3637: break;
3638: default:
3639: jj_la1[94] = jj_gen;
3640: ;
3641: }
3642: break;
3643: default:
3644: jj_la1[95] = jj_gen;
3645: jj_consume_token(-1);
3646: throw new ParseException();
3647: }
3648: break;
3649: default:
3650: jj_la1[96] = jj_gen;
3651: jj_consume_token(-1);
3652: throw new ParseException();
3653: }
3654: }
3655: }
3656:
3657: /*
3658: * The third LOOKAHEAD specification below is to parse to PrimarySuffix
3659: * if there is an expression between the "[...]".
3660: */
3661: final public void ArrayDimsAndInits() throws ParseException {
3662: if (jj_2_26(2)) {
3663: label_42: while (true) {
3664: jj_consume_token(LBRACKET);
3665: Expression();
3666: jj_consume_token(RBRACKET);
3667: if (jj_2_24(2)) {
3668: ;
3669: } else {
3670: break label_42;
3671: }
3672: }
3673: label_43: while (true) {
3674: if (jj_2_25(2)) {
3675: ;
3676: } else {
3677: break label_43;
3678: }
3679: jj_consume_token(LBRACKET);
3680: jj_consume_token(RBRACKET);
3681: }
3682: } else {
3683: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3684: case LBRACKET:
3685: label_44: while (true) {
3686: jj_consume_token(LBRACKET);
3687: jj_consume_token(RBRACKET);
3688: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3689: case LBRACKET:
3690: ;
3691: break;
3692: default:
3693: jj_la1[97] = jj_gen;
3694: break label_44;
3695: }
3696: }
3697: ArrayInitializer();
3698: break;
3699: default:
3700: jj_la1[98] = jj_gen;
3701: jj_consume_token(-1);
3702: throw new ParseException();
3703: }
3704: }
3705: }
3706:
3707: /*
3708: * Statement syntax follows.
3709: */
3710: final public void Statement() throws ParseException {
3711: if (jj_2_27(2)) {
3712: LabeledStatement();
3713: } else {
3714: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3715: case ASSERT:
3716: AssertStatement();
3717: break;
3718: case LBRACE:
3719: Block();
3720: break;
3721: case SEMICOLON:
3722: EmptyStatement();
3723: break;
3724: case BOOLEAN:
3725: case BYTE:
3726: case CHAR:
3727: case DOUBLE:
3728: case FALSE:
3729: case FLOAT:
3730: case INT:
3731: case LONG:
3732: case NEW:
3733: case NULL:
3734: case SHORT:
3735: case SUPER:
3736: case THIS:
3737: case TRUE:
3738: case VOID:
3739: case INTEGER_LITERAL:
3740: case FLOATING_POINT_LITERAL:
3741: case CHARACTER_LITERAL:
3742: case STRING_LITERAL:
3743: case IDENTIFIER:
3744: case LPAREN:
3745: case INCR:
3746: case DECR:
3747: StatementExpression();
3748: jj_consume_token(SEMICOLON);
3749: break;
3750: case SWITCH:
3751: SwitchStatement();
3752: break;
3753: case IF:
3754: IfStatement();
3755: break;
3756: case WHILE:
3757: WhileStatement();
3758: break;
3759: case DO:
3760: DoStatement();
3761: break;
3762: case FOR:
3763: ForStatement();
3764: break;
3765: case BREAK:
3766: BreakStatement();
3767: break;
3768: case CONTINUE:
3769: ContinueStatement();
3770: break;
3771: case RETURN:
3772: ReturnStatement();
3773: break;
3774: case THROW:
3775: ThrowStatement();
3776: break;
3777: case SYNCHRONIZED:
3778: SynchronizedStatement();
3779: break;
3780: case TRY:
3781: TryStatement();
3782: break;
3783: default:
3784: jj_la1[99] = jj_gen;
3785: jj_consume_token(-1);
3786: throw new ParseException();
3787: }
3788: }
3789: }
3790:
3791: final public void AssertStatement() throws ParseException {
3792: jj_consume_token(ASSERT);
3793: Expression();
3794: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3795: case COLON:
3796: jj_consume_token(COLON);
3797: Expression();
3798: break;
3799: default:
3800: jj_la1[100] = jj_gen;
3801: ;
3802: }
3803: jj_consume_token(SEMICOLON);
3804: }
3805:
3806: final public void LabeledStatement() throws ParseException {
3807: jj_consume_token(IDENTIFIER);
3808: jj_consume_token(COLON);
3809: Statement();
3810: }
3811:
3812: final public void Block() throws ParseException {
3813: jj_consume_token(LBRACE);
3814: label_45: while (true) {
3815: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3816: case ASSERT:
3817: case BOOLEAN:
3818: case BREAK:
3819: case BYTE:
3820: case CHAR:
3821: case CLASS:
3822: case CONTINUE:
3823: case DO:
3824: case DOUBLE:
3825: case FALSE:
3826: case FINAL:
3827: case FLOAT:
3828: case FOR:
3829: case IF:
3830: case INT:
3831: case INTERFACE:
3832: case LONG:
3833: case NEW:
3834: case NULL:
3835: case RETURN:
3836: case SHORT:
3837: case SUPER:
3838: case SWITCH:
3839: case SYNCHRONIZED:
3840: case THIS:
3841: case THROW:
3842: case TRUE:
3843: case TRY:
3844: case VOID:
3845: case WHILE:
3846: case INTEGER_LITERAL:
3847: case FLOATING_POINT_LITERAL:
3848: case CHARACTER_LITERAL:
3849: case STRING_LITERAL:
3850: case IDENTIFIER:
3851: case LPAREN:
3852: case LBRACE:
3853: case SEMICOLON:
3854: case INCR:
3855: case DECR:
3856: ;
3857: break;
3858: default:
3859: jj_la1[101] = jj_gen;
3860: break label_45;
3861: }
3862: BlockStatement();
3863: }
3864: jj_consume_token(RBRACE);
3865: }
3866:
3867: /****************************
3868: void _CODE() #_CODE(true) :
3869: {}
3870: {
3871: "{" ( _RAW() | _CODE() )* "}"
3872: }
3873:
3874: void _RAW() #_RAW(true) :
3875: {
3876: Token t;
3877: }
3878: {
3879: <_PURE> { jjtThis.setValue(t.toString()); }
3880: }
3881: *************************/
3882: final public void BlockStatement() throws ParseException {
3883: if (jj_2_28(2147483647)) {
3884: LocalVariableDeclaration();
3885: jj_consume_token(SEMICOLON);
3886: } else {
3887: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3888: case ASSERT:
3889: case BOOLEAN:
3890: case BREAK:
3891: case BYTE:
3892: case CHAR:
3893: case CONTINUE:
3894: case DO:
3895: case DOUBLE:
3896: case FALSE:
3897: case FLOAT:
3898: case FOR:
3899: case IF:
3900: case INT:
3901: case LONG:
3902: case NEW:
3903: case NULL:
3904: case RETURN:
3905: case SHORT:
3906: case SUPER:
3907: case SWITCH:
3908: case SYNCHRONIZED:
3909: case THIS:
3910: case THROW:
3911: case TRUE:
3912: case TRY:
3913: case VOID:
3914: case WHILE:
3915: case INTEGER_LITERAL:
3916: case FLOATING_POINT_LITERAL:
3917: case CHARACTER_LITERAL:
3918: case STRING_LITERAL:
3919: case IDENTIFIER:
3920: case LPAREN:
3921: case LBRACE:
3922: case SEMICOLON:
3923: case INCR:
3924: case DECR:
3925: Statement();
3926: break;
3927: case CLASS:
3928: UnmodifiedClassDeclaration();
3929: break;
3930: case INTERFACE:
3931: UnmodifiedInterfaceDeclaration();
3932: break;
3933: default:
3934: jj_la1[102] = jj_gen;
3935: jj_consume_token(-1);
3936: throw new ParseException();
3937: }
3938: }
3939: }
3940:
3941: final public void LocalVariableDeclaration() throws ParseException {
3942: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3943: case FINAL:
3944: jj_consume_token(FINAL);
3945: break;
3946: default:
3947: jj_la1[103] = jj_gen;
3948: ;
3949: }
3950: Type();
3951: VariableDeclarator();
3952: label_46: while (true) {
3953: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3954: case COMMA:
3955: ;
3956: break;
3957: default:
3958: jj_la1[104] = jj_gen;
3959: break label_46;
3960: }
3961: jj_consume_token(COMMA);
3962: VariableDeclarator();
3963: }
3964: }
3965:
3966: final public void EmptyStatement() throws ParseException {
3967: jj_consume_token(SEMICOLON);
3968: }
3969:
3970: final public void StatementExpression() throws ParseException {
3971: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
3972: case INCR:
3973: PreIncrementExpression();
3974: break;
3975: case DECR:
3976: PreDecrementExpression();
3977: break;
3978: case BOOLEAN:
3979: case BYTE:
3980: case CHAR:
3981: case DOUBLE:
3982: case FALSE:
3983: case FLOAT:
3984: case INT:
3985: case LONG:
3986: case NEW:
3987: case NULL:
3988: case SHORT:
3989: case SUPER:
3990: case THIS:
3991: case TRUE:
3992: case VOID:
3993: case INTEGER_LITERAL:
3994: case FLOATING_POINT_LITERAL:
3995: case CHARACTER_LITERAL:
3996: case STRING_LITERAL:
3997: case IDENTIFIER:
3998: case LPAREN:
3999: PrimaryExpression();
4000: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4001: case ASSIGN:
4002: case INCR:
4003: case DECR:
4004: case PLUSASSIGN:
4005: case MINUSASSIGN:
4006: case STARASSIGN:
4007: case SLASHASSIGN:
4008: case ANDASSIGN:
4009: case ORASSIGN:
4010: case XORASSIGN:
4011: case REMASSIGN:
4012: case LSHIFTASSIGN:
4013: case RSIGNEDSHIFTASSIGN:
4014: case RUNSIGNEDSHIFTASSIGN:
4015: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4016: case INCR:
4017: jj_consume_token(INCR);
4018: break;
4019: case DECR:
4020: jj_consume_token(DECR);
4021: break;
4022: case ASSIGN:
4023: case PLUSASSIGN:
4024: case MINUSASSIGN:
4025: case STARASSIGN:
4026: case SLASHASSIGN:
4027: case ANDASSIGN:
4028: case ORASSIGN:
4029: case XORASSIGN:
4030: case REMASSIGN:
4031: case LSHIFTASSIGN:
4032: case RSIGNEDSHIFTASSIGN:
4033: case RUNSIGNEDSHIFTASSIGN:
4034: AssignmentOperator();
4035: Expression();
4036: break;
4037: default:
4038: jj_la1[105] = jj_gen;
4039: jj_consume_token(-1);
4040: throw new ParseException();
4041: }
4042: break;
4043: default:
4044: jj_la1[106] = jj_gen;
4045: ;
4046: }
4047: break;
4048: default:
4049: jj_la1[107] = jj_gen;
4050: jj_consume_token(-1);
4051: throw new ParseException();
4052: }
4053: }
4054:
4055: final public void SwitchStatement() throws ParseException {
4056: jj_consume_token(SWITCH);
4057: jj_consume_token(LPAREN);
4058: Expression();
4059: jj_consume_token(RPAREN);
4060: jj_consume_token(LBRACE);
4061: label_47: while (true) {
4062: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4063: case CASE:
4064: case _DEFAULT:
4065: ;
4066: break;
4067: default:
4068: jj_la1[108] = jj_gen;
4069: break label_47;
4070: }
4071: SwitchLabel();
4072: label_48: while (true) {
4073: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4074: case ASSERT:
4075: case BOOLEAN:
4076: case BREAK:
4077: case BYTE:
4078: case CHAR:
4079: case CLASS:
4080: case CONTINUE:
4081: case DO:
4082: case DOUBLE:
4083: case FALSE:
4084: case FINAL:
4085: case FLOAT:
4086: case FOR:
4087: case IF:
4088: case INT:
4089: case INTERFACE:
4090: case LONG:
4091: case NEW:
4092: case NULL:
4093: case RETURN:
4094: case SHORT:
4095: case SUPER:
4096: case SWITCH:
4097: case SYNCHRONIZED:
4098: case THIS:
4099: case THROW:
4100: case TRUE:
4101: case TRY:
4102: case VOID:
4103: case WHILE:
4104: case INTEGER_LITERAL:
4105: case FLOATING_POINT_LITERAL:
4106: case CHARACTER_LITERAL:
4107: case STRING_LITERAL:
4108: case IDENTIFIER:
4109: case LPAREN:
4110: case LBRACE:
4111: case SEMICOLON:
4112: case INCR:
4113: case DECR:
4114: ;
4115: break;
4116: default:
4117: jj_la1[109] = jj_gen;
4118: break label_48;
4119: }
4120: BlockStatement();
4121: }
4122: }
4123: jj_consume_token(RBRACE);
4124: }
4125:
4126: final public void SwitchLabel() throws ParseException {
4127: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4128: case CASE:
4129: jj_consume_token(CASE);
4130: Expression();
4131: jj_consume_token(COLON);
4132: break;
4133: case _DEFAULT:
4134: jj_consume_token(_DEFAULT);
4135: jj_consume_token(COLON);
4136: break;
4137: default:
4138: jj_la1[110] = jj_gen;
4139: jj_consume_token(-1);
4140: throw new ParseException();
4141: }
4142: }
4143:
4144: final public void IfStatement() throws ParseException {
4145: jj_consume_token(IF);
4146: jj_consume_token(LPAREN);
4147: Expression();
4148: jj_consume_token(RPAREN);
4149: Statement();
4150: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4151: case ELSE:
4152: jj_consume_token(ELSE);
4153: Statement();
4154: break;
4155: default:
4156: jj_la1[111] = jj_gen;
4157: ;
4158: }
4159: }
4160:
4161: final public void WhileStatement() throws ParseException {
4162: jj_consume_token(WHILE);
4163: jj_consume_token(LPAREN);
4164: Expression();
4165: jj_consume_token(RPAREN);
4166: Statement();
4167: }
4168:
4169: final public void DoStatement() throws ParseException {
4170: jj_consume_token(DO);
4171: Statement();
4172: jj_consume_token(WHILE);
4173: jj_consume_token(LPAREN);
4174: Expression();
4175: jj_consume_token(RPAREN);
4176: jj_consume_token(SEMICOLON);
4177: }
4178:
4179: final public void ForStatement() throws ParseException {
4180: jj_consume_token(FOR);
4181: jj_consume_token(LPAREN);
4182: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4183: case BOOLEAN:
4184: case BYTE:
4185: case CHAR:
4186: case DOUBLE:
4187: case FALSE:
4188: case FINAL:
4189: case FLOAT:
4190: case INT:
4191: case LONG:
4192: case NEW:
4193: case NULL:
4194: case SHORT:
4195: case SUPER:
4196: case THIS:
4197: case TRUE:
4198: case VOID:
4199: case INTEGER_LITERAL:
4200: case FLOATING_POINT_LITERAL:
4201: case CHARACTER_LITERAL:
4202: case STRING_LITERAL:
4203: case IDENTIFIER:
4204: case LPAREN:
4205: case INCR:
4206: case DECR:
4207: ForInit();
4208: break;
4209: default:
4210: jj_la1[112] = jj_gen;
4211: ;
4212: }
4213: jj_consume_token(SEMICOLON);
4214: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4215: case BOOLEAN:
4216: case BYTE:
4217: case CHAR:
4218: case DOUBLE:
4219: case FALSE:
4220: case FLOAT:
4221: case INT:
4222: case LONG:
4223: case NEW:
4224: case NULL:
4225: case SHORT:
4226: case SUPER:
4227: case THIS:
4228: case TRUE:
4229: case VOID:
4230: case INTEGER_LITERAL:
4231: case FLOATING_POINT_LITERAL:
4232: case CHARACTER_LITERAL:
4233: case STRING_LITERAL:
4234: case IDENTIFIER:
4235: case LPAREN:
4236: case BANG:
4237: case TILDE:
4238: case INCR:
4239: case DECR:
4240: case PLUS:
4241: case MINUS:
4242: Expression();
4243: break;
4244: default:
4245: jj_la1[113] = jj_gen;
4246: ;
4247: }
4248: jj_consume_token(SEMICOLON);
4249: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4250: case BOOLEAN:
4251: case BYTE:
4252: case CHAR:
4253: case DOUBLE:
4254: case FALSE:
4255: case FLOAT:
4256: case INT:
4257: case LONG:
4258: case NEW:
4259: case NULL:
4260: case SHORT:
4261: case SUPER:
4262: case THIS:
4263: case TRUE:
4264: case VOID:
4265: case INTEGER_LITERAL:
4266: case FLOATING_POINT_LITERAL:
4267: case CHARACTER_LITERAL:
4268: case STRING_LITERAL:
4269: case IDENTIFIER:
4270: case LPAREN:
4271: case INCR:
4272: case DECR:
4273: ForUpdate();
4274: break;
4275: default:
4276: jj_la1[114] = jj_gen;
4277: ;
4278: }
4279: jj_consume_token(RPAREN);
4280: Statement();
4281: }
4282:
4283: final public void ForInit() throws ParseException {
4284: if (jj_2_29(2147483647)) {
4285: LocalVariableDeclaration();
4286: } else {
4287: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4288: case BOOLEAN:
4289: case BYTE:
4290: case CHAR:
4291: case DOUBLE:
4292: case FALSE:
4293: case FLOAT:
4294: case INT:
4295: case LONG:
4296: case NEW:
4297: case NULL:
4298: case SHORT:
4299: case SUPER:
4300: case THIS:
4301: case TRUE:
4302: case VOID:
4303: case INTEGER_LITERAL:
4304: case FLOATING_POINT_LITERAL:
4305: case CHARACTER_LITERAL:
4306: case STRING_LITERAL:
4307: case IDENTIFIER:
4308: case LPAREN:
4309: case INCR:
4310: case DECR:
4311: StatementExpressionList();
4312: break;
4313: default:
4314: jj_la1[115] = jj_gen;
4315: jj_consume_token(-1);
4316: throw new ParseException();
4317: }
4318: }
4319: }
4320:
4321: final public void StatementExpressionList() throws ParseException {
4322: StatementExpression();
4323: label_49: while (true) {
4324: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4325: case COMMA:
4326: ;
4327: break;
4328: default:
4329: jj_la1[116] = jj_gen;
4330: break label_49;
4331: }
4332: jj_consume_token(COMMA);
4333: StatementExpression();
4334: }
4335: }
4336:
4337: final public void ForUpdate() throws ParseException {
4338: StatementExpressionList();
4339: }
4340:
4341: final public void BreakStatement() throws ParseException {
4342: jj_consume_token(BREAK);
4343: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4344: case IDENTIFIER:
4345: jj_consume_token(IDENTIFIER);
4346: break;
4347: default:
4348: jj_la1[117] = jj_gen;
4349: ;
4350: }
4351: jj_consume_token(SEMICOLON);
4352: }
4353:
4354: final public void ContinueStatement() throws ParseException {
4355: jj_consume_token(CONTINUE);
4356: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4357: case IDENTIFIER:
4358: jj_consume_token(IDENTIFIER);
4359: break;
4360: default:
4361: jj_la1[118] = jj_gen;
4362: ;
4363: }
4364: jj_consume_token(SEMICOLON);
4365: }
4366:
4367: final public void ReturnStatement() throws ParseException {
4368: jj_consume_token(RETURN);
4369: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4370: case BOOLEAN:
4371: case BYTE:
4372: case CHAR:
4373: case DOUBLE:
4374: case FALSE:
4375: case FLOAT:
4376: case INT:
4377: case LONG:
4378: case NEW:
4379: case NULL:
4380: case SHORT:
4381: case SUPER:
4382: case THIS:
4383: case TRUE:
4384: case VOID:
4385: case INTEGER_LITERAL:
4386: case FLOATING_POINT_LITERAL:
4387: case CHARACTER_LITERAL:
4388: case STRING_LITERAL:
4389: case IDENTIFIER:
4390: case LPAREN:
4391: case BANG:
4392: case TILDE:
4393: case INCR:
4394: case DECR:
4395: case PLUS:
4396: case MINUS:
4397: Expression();
4398: break;
4399: default:
4400: jj_la1[119] = jj_gen;
4401: ;
4402: }
4403: jj_consume_token(SEMICOLON);
4404: }
4405:
4406: final public void ThrowStatement() throws ParseException {
4407: jj_consume_token(THROW);
4408: Expression();
4409: jj_consume_token(SEMICOLON);
4410: }
4411:
4412: final public void SynchronizedStatement() throws ParseException {
4413: jj_consume_token(SYNCHRONIZED);
4414: jj_consume_token(LPAREN);
4415: Expression();
4416: jj_consume_token(RPAREN);
4417: Block();
4418: }
4419:
4420: final public void TryStatement() throws ParseException {
4421: jj_consume_token(TRY);
4422: Block();
4423: label_50: while (true) {
4424: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4425: case CATCH:
4426: ;
4427: break;
4428: default:
4429: jj_la1[120] = jj_gen;
4430: break label_50;
4431: }
4432: jj_consume_token(CATCH);
4433: jj_consume_token(LPAREN);
4434: FormalParameter();
4435: jj_consume_token(RPAREN);
4436: Block();
4437: }
4438: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
4439: case FINALLY:
4440: jj_consume_token(FINALLY);
4441: Block();
4442: break;
4443: default:
4444: jj_la1[121] = jj_gen;
4445: ;
4446: }
4447: }
4448:
4449: final private boolean jj_2_1(int xla) {
4450: jj_la = xla;
4451: jj_lastpos = jj_scanpos = token;
4452: try {
4453: return !jj_3_1();
4454: } catch (LookaheadSuccess ls) {
4455: return true;
4456: } finally {
4457: jj_save(0, xla);
4458: }
4459: }
4460:
4461: final private boolean jj_2_2(int xla) {
4462: jj_la = xla;
4463: jj_lastpos = jj_scanpos = token;
4464: try {
4465: return !jj_3_2();
4466: } catch (LookaheadSuccess ls) {
4467: return true;
4468: } finally {
4469: jj_save(1, xla);
4470: }
4471: }
4472:
4473: final private boolean jj_2_3(int xla) {
4474: jj_la = xla;
4475: jj_lastpos = jj_scanpos = token;
4476: try {
4477: return !jj_3_3();
4478: } catch (LookaheadSuccess ls) {
4479: return true;
4480: } finally {
4481: jj_save(2, xla);
4482: }
4483: }
4484:
4485: final private boolean jj_2_4(int xla) {
4486: jj_la = xla;
4487: jj_lastpos = jj_scanpos = token;
4488: try {
4489: return !jj_3_4();
4490: } catch (LookaheadSuccess ls) {
4491: return true;
4492: } finally {
4493: jj_save(3, xla);
4494: }
4495: }
4496:
4497: final private boolean jj_2_5(int xla) {
4498: jj_la = xla;
4499: jj_lastpos = jj_scanpos = token;
4500: try {
4501: return !jj_3_5();
4502: } catch (LookaheadSuccess ls) {
4503: return true;
4504: } finally {
4505: jj_save(4, xla);
4506: }
4507: }
4508:
4509: final private boolean jj_2_6(int xla) {
4510: jj_la = xla;
4511: jj_lastpos = jj_scanpos = token;
4512: try {
4513: return !jj_3_6();
4514: } catch (LookaheadSuccess ls) {
4515: return true;
4516: } finally {
4517: jj_save(5, xla);
4518: }
4519: }
4520:
4521: final private boolean jj_2_7(int xla) {
4522: jj_la = xla;
4523: jj_lastpos = jj_scanpos = token;
4524: try {
4525: return !jj_3_7();
4526: } catch (LookaheadSuccess ls) {
4527: return true;
4528: } finally {
4529: jj_save(6, xla);
4530: }
4531: }
4532:
4533: final private boolean jj_2_8(int xla) {
4534: jj_la = xla;
4535: jj_lastpos = jj_scanpos = token;
4536: try {
4537: return !jj_3_8();
4538: } catch (LookaheadSuccess ls) {
4539: return true;
4540: } finally {
4541: jj_save(7, xla);
4542: }
4543: }
4544:
4545: final private boolean jj_2_9(int xla) {
4546: jj_la = xla;
4547: jj_lastpos = jj_scanpos = token;
4548: try {
4549: return !jj_3_9();
4550: } catch (LookaheadSuccess ls) {
4551: return true;
4552: } finally {
4553: jj_save(8, xla);
4554: }
4555: }
4556:
4557: final private boolean jj_2_10(int xla) {
4558: jj_la = xla;
4559: jj_lastpos = jj_scanpos = token;
4560: try {
4561: return !jj_3_10();
4562: } catch (LookaheadSuccess ls) {
4563: return true;
4564: } finally {
4565: jj_save(9, xla);
4566: }
4567: }
4568:
4569: final private boolean jj_2_11(int xla) {
4570: jj_la = xla;
4571: jj_lastpos = jj_scanpos = token;
4572: try {
4573: return !jj_3_11();
4574: } catch (LookaheadSuccess ls) {
4575: return true;
4576: } finally {
4577: jj_save(10, xla);
4578: }
4579: }
4580:
4581: final private boolean jj_2_12(int xla) {
4582: jj_la = xla;
4583: jj_lastpos = jj_scanpos = token;
4584: try {
4585: return !jj_3_12();
4586: } catch (LookaheadSuccess ls) {
4587: return true;
4588: } finally {
4589: jj_save(11, xla);
4590: }
4591: }
4592:
4593: final private boolean jj_2_13(int xla) {
4594: jj_la = xla;
4595: jj_lastpos = jj_scanpos = token;
4596: try {
4597: return !jj_3_13();
4598: } catch (LookaheadSuccess ls) {
4599: return true;
4600: } finally {
4601: jj_save(12, xla);
4602: }
4603: }
4604:
4605: final private boolean jj_2_14(int xla) {
4606: jj_la = xla;
4607: jj_lastpos = jj_scanpos = token;
4608: try {
4609: return !jj_3_14();
4610: } catch (LookaheadSuccess ls) {
4611: return true;
4612: } finally {
4613: jj_save(13, xla);
4614: }
4615: }
4616:
4617: final private boolean jj_2_15(int xla) {
4618: jj_la = xla;
4619: jj_lastpos = jj_scanpos = token;
4620: try {
4621: return !jj_3_15();
4622: } catch (LookaheadSuccess ls) {
4623: return true;
4624: } finally {
4625: jj_save(14, xla);
4626: }
4627: }
4628:
4629: final private boolean jj_2_16(int xla) {
4630: jj_la = xla;
4631: jj_lastpos = jj_scanpos = token;
4632: try {
4633: return !jj_3_16();
4634: } catch (LookaheadSuccess ls) {
4635: return true;
4636: } finally {
4637: jj_save(15, xla);
4638: }
4639: }
4640:
4641: final private boolean jj_2_17(int xla) {
4642: jj_la = xla;
4643: jj_lastpos = jj_scanpos = token;
4644: try {
4645: return !jj_3_17();
4646: } catch (LookaheadSuccess ls) {
4647: return true;
4648: } finally {
4649: jj_save(16, xla);
4650: }
4651: }
4652:
4653: final private boolean jj_2_18(int xla) {
4654: jj_la = xla;
4655: jj_lastpos = jj_scanpos = token;
4656: try {
4657: return !jj_3_18();
4658: } catch (LookaheadSuccess ls) {
4659: return true;
4660: } finally {
4661: jj_save(17, xla);
4662: }
4663: }
4664:
4665: final private boolean jj_2_19(int xla) {
4666: jj_la = xla;
4667: jj_lastpos = jj_scanpos = token;
4668: try {
4669: return !jj_3_19();
4670: } catch (LookaheadSuccess ls) {
4671: return true;
4672: } finally {
4673: jj_save(18, xla);
4674: }
4675: }
4676:
4677: final private boolean jj_2_20(int xla) {
4678: jj_la = xla;
4679: jj_lastpos = jj_scanpos = token;
4680: try {
4681: return !jj_3_20();
4682: } catch (LookaheadSuccess ls) {
4683: return true;
4684: } finally {
4685: jj_save(19, xla);
4686: }
4687: }
4688:
4689: final private boolean jj_2_21(int xla) {
4690: jj_la = xla;
4691: jj_lastpos = jj_scanpos = token;
4692: try {
4693: return !jj_3_21();
4694: } catch (LookaheadSuccess ls) {
4695: return true;
4696: } finally {
4697: jj_save(20, xla);
4698: }
4699: }
4700:
4701: final private boolean jj_2_22(int xla) {
4702: jj_la = xla;
4703: jj_lastpos = jj_scanpos = token;
4704: try {
4705: return !jj_3_22();
4706: } catch (LookaheadSuccess ls) {
4707: return true;
4708: } finally {
4709: jj_save(21, xla);
4710: }
4711: }
4712:
4713: final private boolean jj_2_23(int xla) {
4714: jj_la = xla;
4715: jj_lastpos = jj_scanpos = token;
4716: try {
4717: return !jj_3_23();
4718: } catch (LookaheadSuccess ls) {
4719: return true;
4720: } finally {
4721: jj_save(22, xla);
4722: }
4723: }
4724:
4725: final private boolean jj_2_24(int xla) {
4726: jj_la = xla;
4727: jj_lastpos = jj_scanpos = token;
4728: try {
4729: return !jj_3_24();
4730: } catch (LookaheadSuccess ls) {
4731: return true;
4732: } finally {
4733: jj_save(23, xla);
4734: }
4735: }
4736:
4737: final private boolean jj_2_25(int xla) {
4738: jj_la = xla;
4739: jj_lastpos = jj_scanpos = token;
4740: try {
4741: return !jj_3_25();
4742: } catch (LookaheadSuccess ls) {
4743: return true;
4744: } finally {
4745: jj_save(24, xla);
4746: }
4747: }
4748:
4749: final private boolean jj_2_26(int xla) {
4750: jj_la = xla;
4751: jj_lastpos = jj_scanpos = token;
4752: try {
4753: return !jj_3_26();
4754: } catch (LookaheadSuccess ls) {
4755: return true;
4756: } finally {
4757: jj_save(25, xla);
4758: }
4759: }
4760:
4761: final private boolean jj_2_27(int xla) {
4762: jj_la = xla;
4763: jj_lastpos = jj_scanpos = token;
4764: try {
4765: return !jj_3_27();
4766: } catch (LookaheadSuccess ls) {
4767: return true;
4768: } finally {
4769: jj_save(26, xla);
4770: }
4771: }
4772:
4773: final private boolean jj_2_28(int xla) {
4774: jj_la = xla;
4775: jj_lastpos = jj_scanpos = token;
4776: try {
4777: return !jj_3_28();
4778: } catch (LookaheadSuccess ls) {
4779: return true;
4780: } finally {
4781: jj_save(27, xla);
4782: }
4783: }
4784:
4785: final private boolean jj_2_29(int xla) {
4786: jj_la = xla;
4787: jj_lastpos = jj_scanpos = token;
4788: try {
4789: return !jj_3_29();
4790: } catch (LookaheadSuccess ls) {
4791: return true;
4792: } finally {
4793: jj_save(28, xla);
4794: }
4795: }
4796:
4797: final private boolean jj_3R_275() {
4798: if (jj_scan_token(PRIVATE))
4799: return true;
4800: return false;
4801: }
4802:
4803: final private boolean jj_3R_274() {
4804: if (jj_scan_token(PROTECTED))
4805: return true;
4806: return false;
4807: }
4808:
4809: final private boolean jj_3R_273() {
4810: if (jj_scan_token(PUBLIC))
4811: return true;
4812: return false;
4813: }
4814:
4815: final private boolean jj_3R_64() {
4816: if (jj_scan_token(DOT))
4817: return true;
4818: return false;
4819: }
4820:
4821: final private boolean jj_3R_65() {
4822: if (jj_scan_token(IDENTIFIER))
4823: return true;
4824: return false;
4825: }
4826:
4827: final private boolean jj_3R_115() {
4828: if (jj_scan_token(LBRACKET))
4829: return true;
4830: if (jj_scan_token(RBRACKET))
4831: return true;
4832: return false;
4833: }
4834:
4835: final private boolean jj_3R_95() {
4836: Token xsp;
4837: while (true) {
4838: xsp = jj_scanpos;
4839: if (jj_3R_115()) {
4840: jj_scanpos = xsp;
4841: break;
4842: }
4843: }
4844: return false;
4845: }
4846:
4847: final private boolean jj_3R_287() {
4848: if (jj_scan_token(COMMA))
4849: return true;
4850: if (jj_3R_56())
4851: return true;
4852: return false;
4853: }
4854:
4855: final private boolean jj_3R_276() {
4856: if (jj_3R_56())
4857: return true;
4858: Token xsp;
4859: while (true) {
4860: xsp = jj_scanpos;
4861: if (jj_3R_287()) {
4862: jj_scanpos = xsp;
4863: break;
4864: }
4865: }
4866: return false;
4867: }
4868:
4869: final private boolean jj_3R_280() {
4870: if (jj_scan_token(COMMA))
4871: return true;
4872: if (jj_3R_56())
4873: return true;
4874: return false;
4875: }
4876:
4877: final private boolean jj_3R_245() {
4878: if (jj_3R_56())
4879: return true;
4880: Token xsp;
4881: while (true) {
4882: xsp = jj_scanpos;
4883: if (jj_3R_280()) {
4884: jj_scanpos = xsp;
4885: break;
4886: }
4887: }
4888: return false;
4889: }
4890:
4891: final private boolean jj_3_14() {
4892: if (jj_3R_64())
4893: return true;
4894: if (jj_3R_65())
4895: return true;
4896: return false;
4897: }
4898:
4899: final private boolean jj_3R_254() {
4900: if (jj_3R_282())
4901: return true;
4902: return false;
4903: }
4904:
4905: final private boolean jj_3R_56() {
4906: if (jj_3R_65())
4907: return true;
4908: Token xsp;
4909: while (true) {
4910: xsp = jj_scanpos;
4911: if (jj_3_14()) {
4912: jj_scanpos = xsp;
4913: break;
4914: }
4915: }
4916: return false;
4917: }
4918:
4919: final private boolean jj_3R_90() {
4920: if (jj_3R_73())
4921: return true;
4922: return false;
4923: }
4924:
4925: final private boolean jj_3R_253() {
4926: if (jj_3R_281())
4927: return true;
4928: return false;
4929: }
4930:
4931: final private boolean jj_3R_69() {
4932: Token xsp;
4933: xsp = jj_scanpos;
4934: if (jj_3R_89()) {
4935: jj_scanpos = xsp;
4936: if (jj_3R_90())
4937: return true;
4938: }
4939: return false;
4940: }
4941:
4942: final private boolean jj_3R_89() {
4943: if (jj_scan_token(VOID))
4944: return true;
4945: return false;
4946: }
4947:
4948: final private boolean jj_3R_113() {
4949: if (jj_scan_token(DOUBLE))
4950: return true;
4951: return false;
4952: }
4953:
4954: final private boolean jj_3R_112() {
4955: if (jj_scan_token(FLOAT))
4956: return true;
4957: return false;
4958: }
4959:
4960: final private boolean jj_3R_111() {
4961: if (jj_scan_token(LONG))
4962: return true;
4963: return false;
4964: }
4965:
4966: final private boolean jj_3R_110() {
4967: if (jj_scan_token(INT))
4968: return true;
4969: return false;
4970: }
4971:
4972: final private boolean jj_3R_252() {
4973: if (jj_3R_272())
4974: return true;
4975: return false;
4976: }
4977:
4978: final private boolean jj_3R_109() {
4979: if (jj_scan_token(SHORT))
4980: return true;
4981: return false;
4982: }
4983:
4984: final private boolean jj_3R_94() {
4985: if (jj_3R_56())
4986: return true;
4987: return false;
4988: }
4989:
4990: final private boolean jj_3R_108() {
4991: if (jj_scan_token(BYTE))
4992: return true;
4993: return false;
4994: }
4995:
4996: final private boolean jj_3R_107() {
4997: if (jj_scan_token(CHAR))
4998: return true;
4999: return false;
5000: }
5001:
5002: final private boolean jj_3R_106() {
5003: if (jj_scan_token(BOOLEAN))
5004: return true;
5005: return false;
5006: }
5007:
5008: final private boolean jj_3R_85() {
5009: Token xsp;
5010: xsp = jj_scanpos;
5011: if (jj_3R_106()) {
5012: jj_scanpos = xsp;
5013: if (jj_3R_107()) {
5014: jj_scanpos = xsp;
5015: if (jj_3R_108()) {
5016: jj_scanpos = xsp;
5017: if (jj_3R_109()) {
5018: jj_scanpos = xsp;
5019: if (jj_3R_110()) {
5020: jj_scanpos = xsp;
5021: if (jj_3R_111()) {
5022: jj_scanpos = xsp;
5023: if (jj_3R_112()) {
5024: jj_scanpos = xsp;
5025: if (jj_3R_113())
5026: return true;
5027: }
5028: }
5029: }
5030: }
5031: }
5032: }
5033: }
5034: return false;
5035: }
5036:
5037: final private boolean jj_3R_251() {
5038: if (jj_3R_271())
5039: return true;
5040: return false;
5041: }
5042:
5043: final private boolean jj_3R_67() {
5044: if (jj_3R_85())
5045: return true;
5046: return false;
5047: }
5048:
5049: final private boolean jj_3R_212() {
5050: if (jj_scan_token(THROWS))
5051: return true;
5052: if (jj_3R_245())
5053: return true;
5054: return false;
5055: }
5056:
5057: final private boolean jj_3R_262() {
5058: if (jj_3R_272())
5059: return true;
5060: return false;
5061: }
5062:
5063: final private boolean jj_3R_93() {
5064: if (jj_3R_67())
5065: return true;
5066: return false;
5067: }
5068:
5069: final private boolean jj_3R_73() {
5070: Token xsp;
5071: xsp = jj_scanpos;
5072: if (jj_3R_93()) {
5073: jj_scanpos = xsp;
5074: if (jj_3R_94())
5075: return true;
5076: }
5077: if (jj_3R_95())
5078: return true;
5079: return false;
5080: }
5081:
5082: final private boolean jj_3R_243() {
5083: if (jj_3R_275())
5084: return true;
5085: return false;
5086: }
5087:
5088: final private boolean jj_3R_250() {
5089: if (jj_3R_270())
5090: return true;
5091: return false;
5092: }
5093:
5094: final private boolean jj_3R_74() {
5095: if (jj_scan_token(STATIC))
5096: return true;
5097: return false;
5098: }
5099:
5100: final private boolean jj_3_13() {
5101: if (jj_scan_token(THIS))
5102: return true;
5103: if (jj_3R_63())
5104: return true;
5105: if (jj_scan_token(SEMICOLON))
5106: return true;
5107: return false;
5108: }
5109:
5110: final private boolean jj_3R_261() {
5111: if (jj_3R_284())
5112: return true;
5113: return false;
5114: }
5115:
5116: final private boolean jj_3R_52() {
5117: Token xsp;
5118: xsp = jj_scanpos;
5119: if (jj_3R_74())
5120: jj_scanpos = xsp;
5121: if (jj_3R_75())
5122: return true;
5123: return false;
5124: }
5125:
5126: final private boolean jj_3_11() {
5127: if (jj_3R_61())
5128: return true;
5129: return false;
5130: }
5131:
5132: final private boolean jj_3_12() {
5133: if (jj_3R_62())
5134: return true;
5135: if (jj_scan_token(DOT))
5136: return true;
5137: return false;
5138: }
5139:
5140: final private boolean jj_3R_249() {
5141: if (jj_3R_269())
5142: return true;
5143: return false;
5144: }
5145:
5146: final private boolean jj_3R_80() {
5147: Token xsp;
5148: xsp = jj_scanpos;
5149: if (jj_3_12())
5150: jj_scanpos = xsp;
5151: if (jj_scan_token(SUPER))
5152: return true;
5153: if (jj_3R_63())
5154: return true;
5155: if (jj_scan_token(SEMICOLON))
5156: return true;
5157: return false;
5158: }
5159:
5160: final private boolean jj_3R_242() {
5161: if (jj_3R_274())
5162: return true;
5163: return false;
5164: }
5165:
5166: final private boolean jj_3R_279() {
5167: if (jj_scan_token(COMMA))
5168: return true;
5169: if (jj_3R_278())
5170: return true;
5171: return false;
5172: }
5173:
5174: final private boolean jj_3R_61() {
5175: Token xsp;
5176: xsp = jj_scanpos;
5177: if (jj_3R_79()) {
5178: jj_scanpos = xsp;
5179: if (jj_3R_80())
5180: return true;
5181: }
5182: return false;
5183: }
5184:
5185: final private boolean jj_3R_79() {
5186: if (jj_scan_token(THIS))
5187: return true;
5188: if (jj_3R_63())
5189: return true;
5190: if (jj_scan_token(SEMICOLON))
5191: return true;
5192: return false;
5193: }
5194:
5195: final private boolean jj_3R_217() {
5196: if (jj_scan_token(THROWS))
5197: return true;
5198: if (jj_3R_245())
5199: return true;
5200: return false;
5201: }
5202:
5203: final private boolean jj_3R_214() {
5204: if (jj_3R_116())
5205: return true;
5206: return false;
5207: }
5208:
5209: final private boolean jj_3R_213() {
5210: if (jj_3R_61())
5211: return true;
5212: return false;
5213: }
5214:
5215: final private boolean jj_3R_260() {
5216: if (jj_3R_283())
5217: return true;
5218: return false;
5219: }
5220:
5221: final private boolean jj_3R_248() {
5222: if (jj_3R_275())
5223: return true;
5224: return false;
5225: }
5226:
5227: final private boolean jj_3R_210() {
5228: Token xsp;
5229: xsp = jj_scanpos;
5230: if (jj_3R_241()) {
5231: jj_scanpos = xsp;
5232: if (jj_3R_242()) {
5233: jj_scanpos = xsp;
5234: if (jj_3R_243())
5235: return true;
5236: }
5237: }
5238: return false;
5239: }
5240:
5241: final private boolean jj_3R_241() {
5242: if (jj_3R_273())
5243: return true;
5244: return false;
5245: }
5246:
5247: final private boolean jj_3R_200() {
5248: Token xsp;
5249: xsp = jj_scanpos;
5250: if (jj_3R_210())
5251: jj_scanpos = xsp;
5252: if (jj_3R_65())
5253: return true;
5254: if (jj_3R_211())
5255: return true;
5256: xsp = jj_scanpos;
5257: if (jj_3R_212())
5258: jj_scanpos = xsp;
5259: if (jj_scan_token(LBRACE))
5260: return true;
5261: xsp = jj_scanpos;
5262: if (jj_3R_213())
5263: jj_scanpos = xsp;
5264: while (true) {
5265: xsp = jj_scanpos;
5266: if (jj_3R_214()) {
5267: jj_scanpos = xsp;
5268: break;
5269: }
5270: }
5271: if (jj_scan_token(RBRACE))
5272: return true;
5273: return false;
5274: }
5275:
5276: final private boolean jj_3_10() {
5277: if (jj_scan_token(COMMA))
5278: return true;
5279: if (jj_3R_60())
5280: return true;
5281: return false;
5282: }
5283:
5284: final private boolean jj_3R_292() {
5285: if (jj_scan_token(FINAL))
5286: return true;
5287: return false;
5288: }
5289:
5290: final private boolean jj_3R_259() {
5291: if (jj_3R_271())
5292: return true;
5293: return false;
5294: }
5295:
5296: final private boolean jj_3R_244() {
5297: if (jj_3R_278())
5298: return true;
5299: Token xsp;
5300: while (true) {
5301: xsp = jj_scanpos;
5302: if (jj_3R_279()) {
5303: jj_scanpos = xsp;
5304: break;
5305: }
5306: }
5307: return false;
5308: }
5309:
5310: final private boolean jj_3R_278() {
5311: Token xsp;
5312: xsp = jj_scanpos;
5313: if (jj_3R_292())
5314: jj_scanpos = xsp;
5315: if (jj_3R_73())
5316: return true;
5317: if (jj_3R_263())
5318: return true;
5319: return false;
5320: }
5321:
5322: final private boolean jj_3R_211() {
5323: if (jj_scan_token(LPAREN))
5324: return true;
5325: Token xsp;
5326: xsp = jj_scanpos;
5327: if (jj_3R_244())
5328: jj_scanpos = xsp;
5329: if (jj_scan_token(RPAREN))
5330: return true;
5331: return false;
5332: }
5333:
5334: final private boolean jj_3R_247() {
5335: if (jj_3R_274())
5336: return true;
5337: return false;
5338: }
5339:
5340: final private boolean jj_3R_258() {
5341: if (jj_3R_269())
5342: return true;
5343: return false;
5344: }
5345:
5346: final private boolean jj_3R_216() {
5347: if (jj_3R_65())
5348: return true;
5349: if (jj_3R_211())
5350: return true;
5351: if (jj_3R_95())
5352: return true;
5353: return false;
5354: }
5355:
5356: final private boolean jj_3R_218() {
5357: if (jj_3R_75())
5358: return true;
5359: return false;
5360: }
5361:
5362: final private boolean jj_3R_238() {
5363: if (jj_3R_275())
5364: return true;
5365: return false;
5366: }
5367:
5368: final private boolean jj_3R_215() {
5369: Token xsp;
5370: xsp = jj_scanpos;
5371: if (jj_3R_246()) {
5372: jj_scanpos = xsp;
5373: if (jj_3R_247()) {
5374: jj_scanpos = xsp;
5375: if (jj_3R_248()) {
5376: jj_scanpos = xsp;
5377: if (jj_3R_249()) {
5378: jj_scanpos = xsp;
5379: if (jj_3R_250()) {
5380: jj_scanpos = xsp;
5381: if (jj_3R_251()) {
5382: jj_scanpos = xsp;
5383: if (jj_3R_252()) {
5384: jj_scanpos = xsp;
5385: if (jj_3R_253()) {
5386: jj_scanpos = xsp;
5387: if (jj_3R_254())
5388: return true;
5389: }
5390: }
5391: }
5392: }
5393: }
5394: }
5395: }
5396: }
5397: return false;
5398: }
5399:
5400: final private boolean jj_3R_246() {
5401: if (jj_3R_273())
5402: return true;
5403: return false;
5404: }
5405:
5406: final private boolean jj_3R_184() {
5407: if (jj_3R_60())
5408: return true;
5409: Token xsp;
5410: while (true) {
5411: xsp = jj_scanpos;
5412: if (jj_3_10()) {
5413: jj_scanpos = xsp;
5414: break;
5415: }
5416: }
5417: return false;
5418: }
5419:
5420: final private boolean jj_3R_201() {
5421: Token xsp;
5422: while (true) {
5423: xsp = jj_scanpos;
5424: if (jj_3R_215()) {
5425: jj_scanpos = xsp;
5426: break;
5427: }
5428: }
5429: if (jj_3R_69())
5430: return true;
5431: if (jj_3R_216())
5432: return true;
5433: xsp = jj_scanpos;
5434: if (jj_3R_217())
5435: jj_scanpos = xsp;
5436: xsp = jj_scanpos;
5437: if (jj_3R_218()) {
5438: jj_scanpos = xsp;
5439: if (jj_scan_token(82))
5440: return true;
5441: }
5442: return false;
5443: }
5444:
5445: final private boolean jj_3R_264() {
5446: if (jj_scan_token(ASSIGN))
5447: return true;
5448: if (jj_3R_60())
5449: return true;
5450: return false;
5451: }
5452:
5453: final private boolean jj_3R_221() {
5454: if (jj_scan_token(COMMA))
5455: return true;
5456: if (jj_3R_220())
5457: return true;
5458: return false;
5459: }
5460:
5461: final private boolean jj_3R_257() {
5462: if (jj_3R_275())
5463: return true;
5464: return false;
5465: }
5466:
5467: final private boolean jj_3R_97() {
5468: if (jj_scan_token(LBRACE))
5469: return true;
5470: Token xsp;
5471: xsp = jj_scanpos;
5472: if (jj_3R_184())
5473: jj_scanpos = xsp;
5474: xsp = jj_scanpos;
5475: if (jj_scan_token(83))
5476: jj_scanpos = xsp;
5477: if (jj_scan_token(RBRACE))
5478: return true;
5479: return false;
5480: }
5481:
5482: final private boolean jj_3R_237() {
5483: if (jj_3R_274())
5484: return true;
5485: return false;
5486: }
5487:
5488: final private boolean jj_3R_78() {
5489: if (jj_3R_71())
5490: return true;
5491: return false;
5492: }
5493:
5494: final private boolean jj_3R_60() {
5495: Token xsp;
5496: xsp = jj_scanpos;
5497: if (jj_3R_77()) {
5498: jj_scanpos = xsp;
5499: if (jj_3R_78())
5500: return true;
5501: }
5502: return false;
5503: }
5504:
5505: final private boolean jj_3R_77() {
5506: if (jj_3R_97())
5507: return true;
5508: return false;
5509: }
5510:
5511: final private boolean jj_3R_256() {
5512: if (jj_3R_274())
5513: return true;
5514: return false;
5515: }
5516:
5517: final private boolean jj_3R_263() {
5518: if (jj_3R_65())
5519: return true;
5520: if (jj_3R_95())
5521: return true;
5522: return false;
5523: }
5524:
5525: final private boolean jj_3R_236() {
5526: if (jj_3R_273())
5527: return true;
5528: return false;
5529: }
5530:
5531: final private boolean jj_3R_230() {
5532: if (jj_3R_275())
5533: return true;
5534: return false;
5535: }
5536:
5537: final private boolean jj_3R_220() {
5538: if (jj_3R_263())
5539: return true;
5540: Token xsp;
5541: xsp = jj_scanpos;
5542: if (jj_3R_264())
5543: jj_scanpos = xsp;
5544: return false;
5545: }
5546:
5547: final private boolean jj_3R_239() {
5548: if (jj_scan_token(EXTENDS))
5549: return true;
5550: if (jj_3R_276())
5551: return true;
5552: return false;
5553: }
5554:
5555: final private boolean jj_3_9() {
5556: if (jj_3R_57())
5557: return true;
5558: return false;
5559: }
5560:
5561: final private boolean jj_3R_219() {
5562: Token xsp;
5563: xsp = jj_scanpos;
5564: if (jj_3R_255()) {
5565: jj_scanpos = xsp;
5566: if (jj_3R_256()) {
5567: jj_scanpos = xsp;
5568: if (jj_3R_257()) {
5569: jj_scanpos = xsp;
5570: if (jj_3R_258()) {
5571: jj_scanpos = xsp;
5572: if (jj_3R_259()) {
5573: jj_scanpos = xsp;
5574: if (jj_3R_260()) {
5575: jj_scanpos = xsp;
5576: if (jj_3R_261()) {
5577: jj_scanpos = xsp;
5578: if (jj_3R_262())
5579: return true;
5580: }
5581: }
5582: }
5583: }
5584: }
5585: }
5586: }
5587: return false;
5588: }
5589:
5590: final private boolean jj_3R_255() {
5591: if (jj_3R_273())
5592: return true;
5593: return false;
5594: }
5595:
5596: final private boolean jj_3R_59() {
5597: Token xsp;
5598: xsp = jj_scanpos;
5599: if (jj_scan_token(51)) {
5600: jj_scanpos = xsp;
5601: if (jj_scan_token(13)) {
5602: jj_scanpos = xsp;
5603: if (jj_scan_token(30)) {
5604: jj_scanpos = xsp;
5605: if (jj_scan_token(48)) {
5606: jj_scanpos = xsp;
5607: if (jj_scan_token(47)) {
5608: jj_scanpos = xsp;
5609: if (jj_scan_token(46))
5610: return true;
5611: }
5612: }
5613: }
5614: }
5615: }
5616: return false;
5617: }
5618:
5619: final private boolean jj_3R_202() {
5620: Token xsp;
5621: while (true) {
5622: xsp = jj_scanpos;
5623: if (jj_3R_219()) {
5624: jj_scanpos = xsp;
5625: break;
5626: }
5627: }
5628: if (jj_3R_73())
5629: return true;
5630: if (jj_3R_220())
5631: return true;
5632: while (true) {
5633: xsp = jj_scanpos;
5634: if (jj_3R_221()) {
5635: jj_scanpos = xsp;
5636: break;
5637: }
5638: }
5639: if (jj_scan_token(SEMICOLON))
5640: return true;
5641: return false;
5642: }
5643:
5644: final private boolean jj_3_8() {
5645: Token xsp;
5646: while (true) {
5647: xsp = jj_scanpos;
5648: if (jj_3R_59()) {
5649: jj_scanpos = xsp;
5650: break;
5651: }
5652: }
5653: if (jj_scan_token(INTERFACE))
5654: return true;
5655: return false;
5656: }
5657:
5658: final private boolean jj_3R_235() {
5659: if (jj_3R_271())
5660: return true;
5661: return false;
5662: }
5663:
5664: final private boolean jj_3R_58() {
5665: Token xsp;
5666: xsp = jj_scanpos;
5667: if (jj_scan_token(51)) {
5668: jj_scanpos = xsp;
5669: if (jj_scan_token(13)) {
5670: jj_scanpos = xsp;
5671: if (jj_scan_token(30)) {
5672: jj_scanpos = xsp;
5673: if (jj_scan_token(52)) {
5674: jj_scanpos = xsp;
5675: if (jj_scan_token(48)) {
5676: jj_scanpos = xsp;
5677: if (jj_scan_token(47)) {
5678: jj_scanpos = xsp;
5679: if (jj_scan_token(46))
5680: return true;
5681: }
5682: }
5683: }
5684: }
5685: }
5686: }
5687: return false;
5688: }
5689:
5690: final private boolean jj_3_7() {
5691: Token xsp;
5692: while (true) {
5693: xsp = jj_scanpos;
5694: if (jj_3R_58()) {
5695: jj_scanpos = xsp;
5696: break;
5697: }
5698: }
5699: if (jj_scan_token(CLASS))
5700: return true;
5701: return false;
5702: }
5703:
5704: final private boolean jj_3R_291() {
5705: if (jj_3R_202())
5706: return true;
5707: Token xsp;
5708: while (true) {
5709: xsp = jj_scanpos;
5710: if (jj_scan_token(82)) {
5711: jj_scanpos = xsp;
5712: break;
5713: }
5714: }
5715: return false;
5716: }
5717:
5718: final private boolean jj_3R_229() {
5719: if (jj_3R_274())
5720: return true;
5721: return false;
5722: }
5723:
5724: final private boolean jj_3R_290() {
5725: if (jj_3R_201())
5726: return true;
5727: Token xsp;
5728: while (true) {
5729: xsp = jj_scanpos;
5730: if (jj_scan_token(82)) {
5731: jj_scanpos = xsp;
5732: break;
5733: }
5734: }
5735: return false;
5736: }
5737:
5738: final private boolean jj_3R_289() {
5739: if (jj_3R_199())
5740: return true;
5741: Token xsp;
5742: while (true) {
5743: xsp = jj_scanpos;
5744: if (jj_scan_token(82)) {
5745: jj_scanpos = xsp;
5746: break;
5747: }
5748: }
5749: return false;
5750: }
5751:
5752: final private boolean jj_3R_288() {
5753: if (jj_3R_198())
5754: return true;
5755: Token xsp;
5756: while (true) {
5757: xsp = jj_scanpos;
5758: if (jj_scan_token(82)) {
5759: jj_scanpos = xsp;
5760: break;
5761: }
5762: }
5763: return false;
5764: }
5765:
5766: final private boolean jj_3R_234() {
5767: if (jj_3R_270())
5768: return true;
5769: return false;
5770: }
5771:
5772: final private boolean jj_3R_240() {
5773: if (jj_3R_277())
5774: return true;
5775: return false;
5776: }
5777:
5778: final private boolean jj_3R_277() {
5779: Token xsp;
5780: xsp = jj_scanpos;
5781: if (jj_3R_288()) {
5782: jj_scanpos = xsp;
5783: if (jj_3R_289()) {
5784: jj_scanpos = xsp;
5785: if (jj_3R_290()) {
5786: jj_scanpos = xsp;
5787: if (jj_3R_291())
5788: return true;
5789: }
5790: }
5791: }
5792: return false;
5793: }
5794:
5795: final private boolean jj_3R_304() {
5796: if (jj_scan_token(FINALLY))
5797: return true;
5798: if (jj_3R_75())
5799: return true;
5800: return false;
5801: }
5802:
5803: final private boolean jj_3R_303() {
5804: if (jj_scan_token(CATCH))
5805: return true;
5806: if (jj_scan_token(LPAREN))
5807: return true;
5808: if (jj_3R_278())
5809: return true;
5810: if (jj_scan_token(RPAREN))
5811: return true;
5812: if (jj_3R_75())
5813: return true;
5814: return false;
5815: }
5816:
5817: final private boolean jj_3R_228() {
5818: if (jj_3R_273())
5819: return true;
5820: return false;
5821: }
5822:
5823: final private boolean jj_3R_163() {
5824: if (jj_scan_token(TRY))
5825: return true;
5826: if (jj_3R_75())
5827: return true;
5828: Token xsp;
5829: while (true) {
5830: xsp = jj_scanpos;
5831: if (jj_3R_303()) {
5832: jj_scanpos = xsp;
5833: break;
5834: }
5835: }
5836: xsp = jj_scanpos;
5837: if (jj_3R_304())
5838: jj_scanpos = xsp;
5839: return false;
5840: }
5841:
5842: final private boolean jj_3R_130() {
5843: if (jj_scan_token(INTERFACE))
5844: return true;
5845: if (jj_3R_65())
5846: return true;
5847: Token xsp;
5848: xsp = jj_scanpos;
5849: if (jj_3R_239())
5850: jj_scanpos = xsp;
5851: if (jj_scan_token(LBRACE))
5852: return true;
5853: while (true) {
5854: xsp = jj_scanpos;
5855: if (jj_3R_240()) {
5856: jj_scanpos = xsp;
5857: break;
5858: }
5859: }
5860: if (jj_scan_token(RBRACE))
5861: return true;
5862: return false;
5863: }
5864:
5865: final private boolean jj_3R_209() {
5866: Token xsp;
5867: xsp = jj_scanpos;
5868: if (jj_3R_233()) {
5869: jj_scanpos = xsp;
5870: if (jj_3R_234()) {
5871: jj_scanpos = xsp;
5872: if (jj_3R_235()) {
5873: jj_scanpos = xsp;
5874: if (jj_3R_236()) {
5875: jj_scanpos = xsp;
5876: if (jj_3R_237()) {
5877: jj_scanpos = xsp;
5878: if (jj_3R_238())
5879: return true;
5880: }
5881: }
5882: }
5883: }
5884: }
5885: return false;
5886: }
5887:
5888: final private boolean jj_3R_233() {
5889: if (jj_3R_269())
5890: return true;
5891: return false;
5892: }
5893:
5894: final private boolean jj_3R_199() {
5895: Token xsp;
5896: while (true) {
5897: xsp = jj_scanpos;
5898: if (jj_3R_209()) {
5899: jj_scanpos = xsp;
5900: break;
5901: }
5902: }
5903: if (jj_3R_130())
5904: return true;
5905: return false;
5906: }
5907:
5908: final private boolean jj_3R_301() {
5909: if (jj_3R_310())
5910: return true;
5911: return false;
5912: }
5913:
5914: final private boolean jj_3R_162() {
5915: if (jj_scan_token(SYNCHRONIZED))
5916: return true;
5917: if (jj_scan_token(LPAREN))
5918: return true;
5919: if (jj_3R_71())
5920: return true;
5921: if (jj_scan_token(RPAREN))
5922: return true;
5923: if (jj_3R_75())
5924: return true;
5925: return false;
5926: }
5927:
5928: final private boolean jj_3R_302() {
5929: if (jj_3R_71())
5930: return true;
5931: return false;
5932: }
5933:
5934: final private boolean jj_3R_227() {
5935: if (jj_3R_272())
5936: return true;
5937: return false;
5938: }
5939:
5940: final private boolean jj_3R_161() {
5941: if (jj_scan_token(THROW))
5942: return true;
5943: if (jj_3R_71())
5944: return true;
5945: if (jj_scan_token(SEMICOLON))
5946: return true;
5947: return false;
5948: }
5949:
5950: final private boolean jj_3R_232() {
5951: if (jj_scan_token(IMPLEMENTS))
5952: return true;
5953: if (jj_3R_276())
5954: return true;
5955: return false;
5956: }
5957:
5958: final private boolean jj_3R_76() {
5959: Token xsp;
5960: xsp = jj_scanpos;
5961: if (jj_scan_token(48)) {
5962: jj_scanpos = xsp;
5963: if (jj_scan_token(47)) {
5964: jj_scanpos = xsp;
5965: if (jj_scan_token(46)) {
5966: jj_scanpos = xsp;
5967: if (jj_scan_token(51)) {
5968: jj_scanpos = xsp;
5969: if (jj_scan_token(13)) {
5970: jj_scanpos = xsp;
5971: if (jj_scan_token(30)) {
5972: jj_scanpos = xsp;
5973: if (jj_scan_token(52)) {
5974: jj_scanpos = xsp;
5975: if (jj_scan_token(42)) {
5976: jj_scanpos = xsp;
5977: if (jj_scan_token(55))
5978: return true;
5979: }
5980: }
5981: }
5982: }
5983: }
5984: }
5985: }
5986: }
5987: return false;
5988: }
5989:
5990: final private boolean jj_3_6() {
5991: if (jj_3R_57())
5992: return true;
5993: return false;
5994: }
5995:
5996: final private boolean jj_3R_317() {
5997: if (jj_scan_token(COMMA))
5998: return true;
5999: if (jj_3R_152())
6000: return true;
6001: return false;
6002: }
6003:
6004: final private boolean jj_3R_55() {
6005: Token xsp;
6006: xsp = jj_scanpos;
6007: if (jj_scan_token(48)) {
6008: jj_scanpos = xsp;
6009: if (jj_scan_token(47)) {
6010: jj_scanpos = xsp;
6011: if (jj_scan_token(46))
6012: return true;
6013: }
6014: }
6015: return false;
6016: }
6017:
6018: final private boolean jj_3R_57() {
6019: Token xsp;
6020: while (true) {
6021: xsp = jj_scanpos;
6022: if (jj_3R_76()) {
6023: jj_scanpos = xsp;
6024: break;
6025: }
6026: }
6027: if (jj_3R_69())
6028: return true;
6029: if (jj_scan_token(IDENTIFIER))
6030: return true;
6031: if (jj_scan_token(LPAREN))
6032: return true;
6033: return false;
6034: }
6035:
6036: final private boolean jj_3R_160() {
6037: if (jj_scan_token(RETURN))
6038: return true;
6039: Token xsp;
6040: xsp = jj_scanpos;
6041: if (jj_3R_302())
6042: jj_scanpos = xsp;
6043: if (jj_scan_token(SEMICOLON))
6044: return true;
6045: return false;
6046: }
6047:
6048: final private boolean jj_3R_226() {
6049: if (jj_3R_271())
6050: return true;
6051: return false;
6052: }
6053:
6054: final private boolean jj_3_5() {
6055: Token xsp;
6056: xsp = jj_scanpos;
6057: if (jj_3R_55())
6058: jj_scanpos = xsp;
6059: if (jj_3R_56())
6060: return true;
6061: if (jj_scan_token(LPAREN))
6062: return true;
6063: return false;
6064: }
6065:
6066: final private boolean jj_3R_54() {
6067: Token xsp;
6068: xsp = jj_scanpos;
6069: if (jj_scan_token(51)) {
6070: jj_scanpos = xsp;
6071: if (jj_scan_token(13)) {
6072: jj_scanpos = xsp;
6073: if (jj_scan_token(30)) {
6074: jj_scanpos = xsp;
6075: if (jj_scan_token(48)) {
6076: jj_scanpos = xsp;
6077: if (jj_scan_token(47)) {
6078: jj_scanpos = xsp;
6079: if (jj_scan_token(46))
6080: return true;
6081: }
6082: }
6083: }
6084: }
6085: }
6086: return false;
6087: }
6088:
6089: final private boolean jj_3_4() {
6090: Token xsp;
6091: while (true) {
6092: xsp = jj_scanpos;
6093: if (jj_3R_54()) {
6094: jj_scanpos = xsp;
6095: break;
6096: }
6097: }
6098: if (jj_scan_token(INTERFACE))
6099: return true;
6100: return false;
6101: }
6102:
6103: final private boolean jj_3R_53() {
6104: Token xsp;
6105: xsp = jj_scanpos;
6106: if (jj_scan_token(51)) {
6107: jj_scanpos = xsp;
6108: if (jj_scan_token(13)) {
6109: jj_scanpos = xsp;
6110: if (jj_scan_token(30)) {
6111: jj_scanpos = xsp;
6112: if (jj_scan_token(52)) {
6113: jj_scanpos = xsp;
6114: if (jj_scan_token(48)) {
6115: jj_scanpos = xsp;
6116: if (jj_scan_token(47)) {
6117: jj_scanpos = xsp;
6118: if (jj_scan_token(46))
6119: return true;
6120: }
6121: }
6122: }
6123: }
6124: }
6125: }
6126: return false;
6127: }
6128:
6129: final private boolean jj_3R_159() {
6130: if (jj_scan_token(CONTINUE))
6131: return true;
6132: Token xsp;
6133: xsp = jj_scanpos;
6134: if (jj_scan_token(73))
6135: jj_scanpos = xsp;
6136: if (jj_scan_token(SEMICOLON))
6137: return true;
6138: return false;
6139: }
6140:
6141: final private boolean jj_3R_195() {
6142: if (jj_3R_202())
6143: return true;
6144: Token xsp;
6145: while (true) {
6146: xsp = jj_scanpos;
6147: if (jj_scan_token(82)) {
6148: jj_scanpos = xsp;
6149: break;
6150: }
6151: }
6152: return false;
6153: }
6154:
6155: final private boolean jj_3_3() {
6156: Token xsp;
6157: while (true) {
6158: xsp = jj_scanpos;
6159: if (jj_3R_53()) {
6160: jj_scanpos = xsp;
6161: break;
6162: }
6163: }
6164: if (jj_scan_token(CLASS))
6165: return true;
6166: return false;
6167: }
6168:
6169: final private boolean jj_3R_300() {
6170: if (jj_3R_71())
6171: return true;
6172: return false;
6173: }
6174:
6175: final private boolean jj_3R_194() {
6176: if (jj_3R_201())
6177: return true;
6178: Token xsp;
6179: while (true) {
6180: xsp = jj_scanpos;
6181: if (jj_scan_token(82)) {
6182: jj_scanpos = xsp;
6183: break;
6184: }
6185: }
6186: return false;
6187: }
6188:
6189: final private boolean jj_3R_158() {
6190: if (jj_scan_token(BREAK))
6191: return true;
6192: Token xsp;
6193: xsp = jj_scanpos;
6194: if (jj_scan_token(73))
6195: jj_scanpos = xsp;
6196: if (jj_scan_token(SEMICOLON))
6197: return true;
6198: return false;
6199: }
6200:
6201: final private boolean jj_3R_193() {
6202: if (jj_3R_200())
6203: return true;
6204: Token xsp;
6205: while (true) {
6206: xsp = jj_scanpos;
6207: if (jj_scan_token(82)) {
6208: jj_scanpos = xsp;
6209: break;
6210: }
6211: }
6212: return false;
6213: }
6214:
6215: final private boolean jj_3R_225() {
6216: if (jj_3R_270())
6217: return true;
6218: return false;
6219: }
6220:
6221: final private boolean jj_3R_192() {
6222: if (jj_3R_199())
6223: return true;
6224: Token xsp;
6225: while (true) {
6226: xsp = jj_scanpos;
6227: if (jj_scan_token(82)) {
6228: jj_scanpos = xsp;
6229: break;
6230: }
6231: }
6232: return false;
6233: }
6234:
6235: final private boolean jj_3R_298() {
6236: if (jj_scan_token(ELSE))
6237: return true;
6238: if (jj_3R_128())
6239: return true;
6240: return false;
6241: }
6242:
6243: final private boolean jj_3R_310() {
6244: if (jj_3R_316())
6245: return true;
6246: return false;
6247: }
6248:
6249: final private boolean jj_3R_231() {
6250: if (jj_scan_token(EXTENDS))
6251: return true;
6252: if (jj_3R_56())
6253: return true;
6254: return false;
6255: }
6256:
6257: final private boolean jj_3R_191() {
6258: if (jj_3R_198())
6259: return true;
6260: Token xsp;
6261: while (true) {
6262: xsp = jj_scanpos;
6263: if (jj_scan_token(82)) {
6264: jj_scanpos = xsp;
6265: break;
6266: }
6267: }
6268: return false;
6269: }
6270:
6271: final private boolean jj_3_2() {
6272: if (jj_3R_52())
6273: return true;
6274: Token xsp;
6275: while (true) {
6276: xsp = jj_scanpos;
6277: if (jj_scan_token(82)) {
6278: jj_scanpos = xsp;
6279: break;
6280: }
6281: }
6282: return false;
6283: }
6284:
6285: final private boolean jj_3R_188() {
6286: Token xsp;
6287: xsp = jj_scanpos;
6288: if (jj_3_2()) {
6289: jj_scanpos = xsp;
6290: if (jj_3R_191()) {
6291: jj_scanpos = xsp;
6292: if (jj_3R_192()) {
6293: jj_scanpos = xsp;
6294: if (jj_3R_193()) {
6295: jj_scanpos = xsp;
6296: if (jj_3R_194()) {
6297: jj_scanpos = xsp;
6298: if (jj_3R_195())
6299: return true;
6300: }
6301: }
6302: }
6303: }
6304: }
6305: return false;
6306: }
6307:
6308: final private boolean jj_3_29() {
6309: Token xsp;
6310: xsp = jj_scanpos;
6311: if (jj_scan_token(30))
6312: jj_scanpos = xsp;
6313: if (jj_3R_73())
6314: return true;
6315: if (jj_scan_token(IDENTIFIER))
6316: return true;
6317: return false;
6318: }
6319:
6320: final private boolean jj_3R_316() {
6321: if (jj_3R_152())
6322: return true;
6323: Token xsp;
6324: while (true) {
6325: xsp = jj_scanpos;
6326: if (jj_3R_317()) {
6327: jj_scanpos = xsp;
6328: break;
6329: }
6330: }
6331: return false;
6332: }
6333:
6334: final private boolean jj_3R_299() {
6335: if (jj_3R_309())
6336: return true;
6337: return false;
6338: }
6339:
6340: final private boolean jj_3R_208() {
6341: Token xsp;
6342: xsp = jj_scanpos;
6343: if (jj_3R_224()) {
6344: jj_scanpos = xsp;
6345: if (jj_3R_225()) {
6346: jj_scanpos = xsp;
6347: if (jj_3R_226()) {
6348: jj_scanpos = xsp;
6349: if (jj_3R_227()) {
6350: jj_scanpos = xsp;
6351: if (jj_3R_228()) {
6352: jj_scanpos = xsp;
6353: if (jj_3R_229()) {
6354: jj_scanpos = xsp;
6355: if (jj_3R_230())
6356: return true;
6357: }
6358: }
6359: }
6360: }
6361: }
6362: }
6363: return false;
6364: }
6365:
6366: final private boolean jj_3R_224() {
6367: if (jj_3R_269())
6368: return true;
6369: return false;
6370: }
6371:
6372: final private boolean jj_3R_185() {
6373: if (jj_3R_188())
6374: return true;
6375: return false;
6376: }
6377:
6378: final private boolean jj_3R_198() {
6379: Token xsp;
6380: while (true) {
6381: xsp = jj_scanpos;
6382: if (jj_3R_208()) {
6383: jj_scanpos = xsp;
6384: break;
6385: }
6386: }
6387: if (jj_3R_129())
6388: return true;
6389: return false;
6390: }
6391:
6392: final private boolean jj_3R_315() {
6393: if (jj_3R_316())
6394: return true;
6395: return false;
6396: }
6397:
6398: final private boolean jj_3R_314() {
6399: if (jj_3R_127())
6400: return true;
6401: return false;
6402: }
6403:
6404: final private boolean jj_3R_309() {
6405: Token xsp;
6406: xsp = jj_scanpos;
6407: if (jj_3R_314()) {
6408: jj_scanpos = xsp;
6409: if (jj_3R_315())
6410: return true;
6411: }
6412: return false;
6413: }
6414:
6415: final private boolean jj_3R_181() {
6416: if (jj_scan_token(LBRACE))
6417: return true;
6418: Token xsp;
6419: while (true) {
6420: xsp = jj_scanpos;
6421: if (jj_3R_185()) {
6422: jj_scanpos = xsp;
6423: break;
6424: }
6425: }
6426: if (jj_scan_token(RBRACE))
6427: return true;
6428: return false;
6429: }
6430:
6431: final private boolean jj_3R_157() {
6432: if (jj_scan_token(FOR))
6433: return true;
6434: if (jj_scan_token(LPAREN))
6435: return true;
6436: Token xsp;
6437: xsp = jj_scanpos;
6438: if (jj_3R_299())
6439: jj_scanpos = xsp;
6440: if (jj_scan_token(SEMICOLON))
6441: return true;
6442: xsp = jj_scanpos;
6443: if (jj_3R_300())
6444: jj_scanpos = xsp;
6445: if (jj_scan_token(SEMICOLON))
6446: return true;
6447: xsp = jj_scanpos;
6448: if (jj_3R_301())
6449: jj_scanpos = xsp;
6450: if (jj_scan_token(RPAREN))
6451: return true;
6452: if (jj_3R_128())
6453: return true;
6454: return false;
6455: }
6456:
6457: final private boolean jj_3R_129() {
6458: if (jj_scan_token(CLASS))
6459: return true;
6460: if (jj_3R_65())
6461: return true;
6462: Token xsp;
6463: xsp = jj_scanpos;
6464: if (jj_3R_231())
6465: jj_scanpos = xsp;
6466: xsp = jj_scanpos;
6467: if (jj_3R_232())
6468: jj_scanpos = xsp;
6469: if (jj_3R_181())
6470: return true;
6471: return false;
6472: }
6473:
6474: final private boolean jj_3R_156() {
6475: if (jj_scan_token(DO))
6476: return true;
6477: if (jj_3R_128())
6478: return true;
6479: if (jj_scan_token(WHILE))
6480: return true;
6481: if (jj_scan_token(LPAREN))
6482: return true;
6483: if (jj_3R_71())
6484: return true;
6485: if (jj_scan_token(RPAREN))
6486: return true;
6487: if (jj_scan_token(SEMICOLON))
6488: return true;
6489: return false;
6490: }
6491:
6492: final private boolean jj_3R_155() {
6493: if (jj_scan_token(WHILE))
6494: return true;
6495: if (jj_scan_token(LPAREN))
6496: return true;
6497: if (jj_3R_71())
6498: return true;
6499: if (jj_scan_token(RPAREN))
6500: return true;
6501: if (jj_3R_128())
6502: return true;
6503: return false;
6504: }
6505:
6506: final private boolean jj_3R_51() {
6507: Token xsp;
6508: xsp = jj_scanpos;
6509: if (jj_scan_token(13)) {
6510: jj_scanpos = xsp;
6511: if (jj_scan_token(30)) {
6512: jj_scanpos = xsp;
6513: if (jj_scan_token(52)) {
6514: jj_scanpos = xsp;
6515: if (jj_scan_token(48))
6516: return true;
6517: }
6518: }
6519: }
6520: return false;
6521: }
6522:
6523: final private boolean jj_3_1() {
6524: Token xsp;
6525: while (true) {
6526: xsp = jj_scanpos;
6527: if (jj_3R_51()) {
6528: jj_scanpos = xsp;
6529: break;
6530: }
6531: }
6532: if (jj_scan_token(CLASS))
6533: return true;
6534: return false;
6535: }
6536:
6537: final private boolean jj_3R_308() {
6538: if (jj_3R_116())
6539: return true;
6540: return false;
6541: }
6542:
6543: final private boolean jj_3R_154() {
6544: if (jj_scan_token(IF))
6545: return true;
6546: if (jj_scan_token(LPAREN))
6547: return true;
6548: if (jj_3R_71())
6549: return true;
6550: if (jj_scan_token(RPAREN))
6551: return true;
6552: if (jj_3R_128())
6553: return true;
6554: Token xsp;
6555: xsp = jj_scanpos;
6556: if (jj_3R_298())
6557: jj_scanpos = xsp;
6558: return false;
6559: }
6560:
6561: final private boolean jj_3R_313() {
6562: if (jj_scan_token(_DEFAULT))
6563: return true;
6564: if (jj_scan_token(COLON))
6565: return true;
6566: return false;
6567: }
6568:
6569: final private boolean jj_3R_312() {
6570: if (jj_scan_token(CASE))
6571: return true;
6572: if (jj_3R_71())
6573: return true;
6574: if (jj_scan_token(COLON))
6575: return true;
6576: return false;
6577: }
6578:
6579: final private boolean jj_3R_307() {
6580: Token xsp;
6581: xsp = jj_scanpos;
6582: if (jj_3R_312()) {
6583: jj_scanpos = xsp;
6584: if (jj_3R_313())
6585: return true;
6586: }
6587: return false;
6588: }
6589:
6590: final private boolean jj_3R_295() {
6591: if (jj_scan_token(COMMA))
6592: return true;
6593: if (jj_3R_220())
6594: return true;
6595: return false;
6596: }
6597:
6598: final private boolean jj_3R_297() {
6599: if (jj_3R_307())
6600: return true;
6601: Token xsp;
6602: while (true) {
6603: xsp = jj_scanpos;
6604: if (jj_3R_308()) {
6605: jj_scanpos = xsp;
6606: break;
6607: }
6608: }
6609: return false;
6610: }
6611:
6612: final private boolean jj_3R_153() {
6613: if (jj_scan_token(SWITCH))
6614: return true;
6615: if (jj_scan_token(LPAREN))
6616: return true;
6617: if (jj_3R_71())
6618: return true;
6619: if (jj_scan_token(RPAREN))
6620: return true;
6621: if (jj_scan_token(LBRACE))
6622: return true;
6623: Token xsp;
6624: while (true) {
6625: xsp = jj_scanpos;
6626: if (jj_3R_297()) {
6627: jj_scanpos = xsp;
6628: break;
6629: }
6630: }
6631: if (jj_scan_token(RBRACE))
6632: return true;
6633: return false;
6634: }
6635:
6636: final private boolean jj_3R_311() {
6637: if (jj_3R_133())
6638: return true;
6639: if (jj_3R_71())
6640: return true;
6641: return false;
6642: }
6643:
6644: final private boolean jj_3R_306() {
6645: Token xsp;
6646: xsp = jj_scanpos;
6647: if (jj_scan_token(98)) {
6648: jj_scanpos = xsp;
6649: if (jj_scan_token(99)) {
6650: jj_scanpos = xsp;
6651: if (jj_3R_311())
6652: return true;
6653: }
6654: }
6655: return false;
6656: }
6657:
6658: final private boolean jj_3R_168() {
6659: if (jj_3R_62())
6660: return true;
6661: Token xsp;
6662: xsp = jj_scanpos;
6663: if (jj_3R_306())
6664: jj_scanpos = xsp;
6665: return false;
6666: }
6667:
6668: final private boolean jj_3R_167() {
6669: if (jj_3R_175())
6670: return true;
6671: return false;
6672: }
6673:
6674: final private boolean jj_3R_152() {
6675: Token xsp;
6676: xsp = jj_scanpos;
6677: if (jj_3R_166()) {
6678: jj_scanpos = xsp;
6679: if (jj_3R_167()) {
6680: jj_scanpos = xsp;
6681: if (jj_3R_168())
6682: return true;
6683: }
6684: }
6685: return false;
6686: }
6687:
6688: final private boolean jj_3R_166() {
6689: if (jj_3R_174())
6690: return true;
6691: return false;
6692: }
6693:
6694: final private boolean jj_3R_127() {
6695: Token xsp;
6696: xsp = jj_scanpos;
6697: if (jj_scan_token(30))
6698: jj_scanpos = xsp;
6699: if (jj_3R_73())
6700: return true;
6701: if (jj_3R_220())
6702: return true;
6703: while (true) {
6704: xsp = jj_scanpos;
6705: if (jj_3R_295()) {
6706: jj_scanpos = xsp;
6707: break;
6708: }
6709: }
6710: return false;
6711: }
6712:
6713: final private boolean jj_3_28() {
6714: Token xsp;
6715: xsp = jj_scanpos;
6716: if (jj_scan_token(30))
6717: jj_scanpos = xsp;
6718: if (jj_3R_73())
6719: return true;
6720: if (jj_scan_token(IDENTIFIER))
6721: return true;
6722: return false;
6723: }
6724:
6725: final private boolean jj_3R_123() {
6726: if (jj_3R_130())
6727: return true;
6728: return false;
6729: }
6730:
6731: final private boolean jj_3R_122() {
6732: if (jj_3R_129())
6733: return true;
6734: return false;
6735: }
6736:
6737: final private boolean jj_3R_121() {
6738: if (jj_3R_128())
6739: return true;
6740: return false;
6741: }
6742:
6743: final private boolean jj_3R_120() {
6744: if (jj_3R_127())
6745: return true;
6746: if (jj_scan_token(SEMICOLON))
6747: return true;
6748: return false;
6749: }
6750:
6751: final private boolean jj_3R_116() {
6752: Token xsp;
6753: xsp = jj_scanpos;
6754: if (jj_3R_120()) {
6755: jj_scanpos = xsp;
6756: if (jj_3R_121()) {
6757: jj_scanpos = xsp;
6758: if (jj_3R_122()) {
6759: jj_scanpos = xsp;
6760: if (jj_3R_123())
6761: return true;
6762: }
6763: }
6764: }
6765: return false;
6766: }
6767:
6768: final private boolean jj_3R_296() {
6769: if (jj_scan_token(COLON))
6770: return true;
6771: if (jj_3R_71())
6772: return true;
6773: return false;
6774: }
6775:
6776: final private boolean jj_3R_96() {
6777: if (jj_3R_116())
6778: return true;
6779: return false;
6780: }
6781:
6782: final private boolean jj_3R_75() {
6783: if (jj_scan_token(LBRACE))
6784: return true;
6785: Token xsp;
6786: while (true) {
6787: xsp = jj_scanpos;
6788: if (jj_3R_96()) {
6789: jj_scanpos = xsp;
6790: break;
6791: }
6792: }
6793: if (jj_scan_token(RBRACE))
6794: return true;
6795: return false;
6796: }
6797:
6798: final private boolean jj_3R_72() {
6799: if (jj_scan_token(IDENTIFIER))
6800: return true;
6801: if (jj_scan_token(COLON))
6802: return true;
6803: if (jj_3R_128())
6804: return true;
6805: return false;
6806: }
6807:
6808: final private boolean jj_3R_151() {
6809: if (jj_scan_token(ASSERT))
6810: return true;
6811: if (jj_3R_71())
6812: return true;
6813: Token xsp;
6814: xsp = jj_scanpos;
6815: if (jj_3R_296())
6816: jj_scanpos = xsp;
6817: if (jj_scan_token(SEMICOLON))
6818: return true;
6819: return false;
6820: }
6821:
6822: final private boolean jj_3R_148() {
6823: if (jj_3R_163())
6824: return true;
6825: return false;
6826: }
6827:
6828: final private boolean jj_3R_147() {
6829: if (jj_3R_162())
6830: return true;
6831: return false;
6832: }
6833:
6834: final private boolean jj_3_25() {
6835: if (jj_scan_token(LBRACKET))
6836: return true;
6837: if (jj_scan_token(RBRACKET))
6838: return true;
6839: return false;
6840: }
6841:
6842: final private boolean jj_3R_146() {
6843: if (jj_3R_161())
6844: return true;
6845: return false;
6846: }
6847:
6848: final private boolean jj_3R_145() {
6849: if (jj_3R_160())
6850: return true;
6851: return false;
6852: }
6853:
6854: final private boolean jj_3R_144() {
6855: if (jj_3R_159())
6856: return true;
6857: return false;
6858: }
6859:
6860: final private boolean jj_3R_143() {
6861: if (jj_3R_158())
6862: return true;
6863: return false;
6864: }
6865:
6866: final private boolean jj_3R_142() {
6867: if (jj_3R_157())
6868: return true;
6869: return false;
6870: }
6871:
6872: final private boolean jj_3R_141() {
6873: if (jj_3R_156())
6874: return true;
6875: return false;
6876: }
6877:
6878: final private boolean jj_3R_140() {
6879: if (jj_3R_155())
6880: return true;
6881: return false;
6882: }
6883:
6884: final private boolean jj_3R_139() {
6885: if (jj_3R_154())
6886: return true;
6887: return false;
6888: }
6889:
6890: final private boolean jj_3R_138() {
6891: if (jj_3R_153())
6892: return true;
6893: return false;
6894: }
6895:
6896: final private boolean jj_3R_137() {
6897: if (jj_3R_152())
6898: return true;
6899: if (jj_scan_token(SEMICOLON))
6900: return true;
6901: return false;
6902: }
6903:
6904: final private boolean jj_3R_136() {
6905: if (jj_3R_75())
6906: return true;
6907: return false;
6908: }
6909:
6910: final private boolean jj_3R_135() {
6911: if (jj_3R_151())
6912: return true;
6913: return false;
6914: }
6915:
6916: final private boolean jj_3R_128() {
6917: Token xsp;
6918: xsp = jj_scanpos;
6919: if (jj_3_27()) {
6920: jj_scanpos = xsp;
6921: if (jj_3R_135()) {
6922: jj_scanpos = xsp;
6923: if (jj_3R_136()) {
6924: jj_scanpos = xsp;
6925: if (jj_scan_token(82)) {
6926: jj_scanpos = xsp;
6927: if (jj_3R_137()) {
6928: jj_scanpos = xsp;
6929: if (jj_3R_138()) {
6930: jj_scanpos = xsp;
6931: if (jj_3R_139()) {
6932: jj_scanpos = xsp;
6933: if (jj_3R_140()) {
6934: jj_scanpos = xsp;
6935: if (jj_3R_141()) {
6936: jj_scanpos = xsp;
6937: if (jj_3R_142()) {
6938: jj_scanpos = xsp;
6939: if (jj_3R_143()) {
6940: jj_scanpos = xsp;
6941: if (jj_3R_144()) {
6942: jj_scanpos = xsp;
6943: if (jj_3R_145()) {
6944: jj_scanpos = xsp;
6945: if (jj_3R_146()) {
6946: jj_scanpos = xsp;
6947: if (jj_3R_147()) {
6948: jj_scanpos = xsp;
6949: if (jj_3R_148())
6950: return true;
6951: }
6952: }
6953: }
6954: }
6955: }
6956: }
6957: }
6958: }
6959: }
6960: }
6961: }
6962: }
6963: }
6964: }
6965: }
6966: return false;
6967: }
6968:
6969: final private boolean jj_3_27() {
6970: if (jj_3R_72())
6971: return true;
6972: return false;
6973: }
6974:
6975: final private boolean jj_3R_177() {
6976: if (jj_3R_181())
6977: return true;
6978: return false;
6979: }
6980:
6981: final private boolean jj_3R_180() {
6982: if (jj_scan_token(LBRACKET))
6983: return true;
6984: if (jj_scan_token(RBRACKET))
6985: return true;
6986: return false;
6987: }
6988:
6989: final private boolean jj_3_24() {
6990: if (jj_scan_token(LBRACKET))
6991: return true;
6992: if (jj_3R_71())
6993: return true;
6994: if (jj_scan_token(RBRACKET))
6995: return true;
6996: return false;
6997: }
6998:
6999: final private boolean jj_3R_176() {
7000: Token xsp;
7001: if (jj_3R_180())
7002: return true;
7003: while (true) {
7004: xsp = jj_scanpos;
7005: if (jj_3R_180()) {
7006: jj_scanpos = xsp;
7007: break;
7008: }
7009: }
7010: if (jj_3R_97())
7011: return true;
7012: return false;
7013: }
7014:
7015: final private boolean jj_3_26() {
7016: Token xsp;
7017: if (jj_3_24())
7018: return true;
7019: while (true) {
7020: xsp = jj_scanpos;
7021: if (jj_3_24()) {
7022: jj_scanpos = xsp;
7023: break;
7024: }
7025: }
7026: while (true) {
7027: xsp = jj_scanpos;
7028: if (jj_3_25()) {
7029: jj_scanpos = xsp;
7030: break;
7031: }
7032: }
7033: return false;
7034: }
7035:
7036: final private boolean jj_3R_169() {
7037: Token xsp;
7038: xsp = jj_scanpos;
7039: if (jj_3_26()) {
7040: jj_scanpos = xsp;
7041: if (jj_3R_176())
7042: return true;
7043: }
7044: return false;
7045: }
7046:
7047: final private boolean jj_3R_171() {
7048: if (jj_3R_63())
7049: return true;
7050: Token xsp;
7051: xsp = jj_scanpos;
7052: if (jj_3R_177())
7053: jj_scanpos = xsp;
7054: return false;
7055: }
7056:
7057: final private boolean jj_3R_118() {
7058: if (jj_scan_token(COMMA))
7059: return true;
7060: if (jj_3R_71())
7061: return true;
7062: return false;
7063: }
7064:
7065: final private boolean jj_3R_170() {
7066: if (jj_3R_169())
7067: return true;
7068: return false;
7069: }
7070:
7071: final private boolean jj_3R_91() {
7072: if (jj_scan_token(NEW))
7073: return true;
7074: if (jj_3R_56())
7075: return true;
7076: Token xsp;
7077: xsp = jj_scanpos;
7078: if (jj_3R_170()) {
7079: jj_scanpos = xsp;
7080: if (jj_3R_171())
7081: return true;
7082: }
7083: return false;
7084: }
7085:
7086: final private boolean jj_3_23() {
7087: if (jj_scan_token(NEW))
7088: return true;
7089: if (jj_3R_67())
7090: return true;
7091: if (jj_3R_169())
7092: return true;
7093: return false;
7094: }
7095:
7096: final private boolean jj_3R_70() {
7097: Token xsp;
7098: xsp = jj_scanpos;
7099: if (jj_3_23()) {
7100: jj_scanpos = xsp;
7101: if (jj_3R_91())
7102: return true;
7103: }
7104: return false;
7105: }
7106:
7107: final private boolean jj_3R_104() {
7108: if (jj_3R_71())
7109: return true;
7110: Token xsp;
7111: while (true) {
7112: xsp = jj_scanpos;
7113: if (jj_3R_118()) {
7114: jj_scanpos = xsp;
7115: break;
7116: }
7117: }
7118: return false;
7119: }
7120:
7121: final private boolean jj_3R_82() {
7122: if (jj_3R_104())
7123: return true;
7124: return false;
7125: }
7126:
7127: final private boolean jj_3R_63() {
7128: if (jj_scan_token(LPAREN))
7129: return true;
7130: Token xsp;
7131: xsp = jj_scanpos;
7132: if (jj_3R_82())
7133: jj_scanpos = xsp;
7134: if (jj_scan_token(RPAREN))
7135: return true;
7136: return false;
7137: }
7138:
7139: final private boolean jj_3R_131() {
7140: Token xsp;
7141: xsp = jj_scanpos;
7142: if (jj_scan_token(60)) {
7143: jj_scanpos = xsp;
7144: if (jj_scan_token(29))
7145: return true;
7146: }
7147: return false;
7148: }
7149:
7150: final private boolean jj_3R_105() {
7151: if (jj_3R_117())
7152: return true;
7153: return false;
7154: }
7155:
7156: final private boolean jj_3R_124() {
7157: if (jj_3R_131())
7158: return true;
7159: return false;
7160: }
7161:
7162: final private boolean jj_3R_117() {
7163: Token xsp;
7164: xsp = jj_scanpos;
7165: if (jj_scan_token(65)) {
7166: jj_scanpos = xsp;
7167: if (jj_scan_token(69)) {
7168: jj_scanpos = xsp;
7169: if (jj_scan_token(71)) {
7170: jj_scanpos = xsp;
7171: if (jj_scan_token(72)) {
7172: jj_scanpos = xsp;
7173: if (jj_3R_124()) {
7174: jj_scanpos = xsp;
7175: if (jj_scan_token(44))
7176: return true;
7177: }
7178: }
7179: }
7180: }
7181: }
7182: return false;
7183: }
7184:
7185: final private boolean jj_3R_88() {
7186: if (jj_3R_63())
7187: return true;
7188: return false;
7189: }
7190:
7191: final private boolean jj_3R_87() {
7192: if (jj_scan_token(DOT))
7193: return true;
7194: if (jj_scan_token(IDENTIFIER))
7195: return true;
7196: return false;
7197: }
7198:
7199: final private boolean jj_3R_86() {
7200: if (jj_scan_token(LBRACKET))
7201: return true;
7202: if (jj_3R_71())
7203: return true;
7204: if (jj_scan_token(RBRACKET))
7205: return true;
7206: return false;
7207: }
7208:
7209: final private boolean jj_3_22() {
7210: if (jj_scan_token(DOT))
7211: return true;
7212: if (jj_3R_70())
7213: return true;
7214: return false;
7215: }
7216:
7217: final private boolean jj_3_20() {
7218: if (jj_3R_69())
7219: return true;
7220: if (jj_scan_token(DOT))
7221: return true;
7222: if (jj_scan_token(CLASS))
7223: return true;
7224: return false;
7225: }
7226:
7227: final private boolean jj_3_21() {
7228: if (jj_scan_token(DOT))
7229: return true;
7230: if (jj_scan_token(THIS))
7231: return true;
7232: return false;
7233: }
7234:
7235: final private boolean jj_3R_68() {
7236: Token xsp;
7237: xsp = jj_scanpos;
7238: if (jj_3_21()) {
7239: jj_scanpos = xsp;
7240: if (jj_3_22()) {
7241: jj_scanpos = xsp;
7242: if (jj_3R_86()) {
7243: jj_scanpos = xsp;
7244: if (jj_3R_87()) {
7245: jj_scanpos = xsp;
7246: if (jj_3R_88())
7247: return true;
7248: }
7249: }
7250: }
7251: }
7252: return false;
7253: }
7254:
7255: final private boolean jj_3R_103() {
7256: if (jj_3R_56())
7257: return true;
7258: return false;
7259: }
7260:
7261: final private boolean jj_3_19() {
7262: if (jj_3R_68())
7263: return true;
7264: return false;
7265: }
7266:
7267: final private boolean jj_3R_102() {
7268: if (jj_3R_69())
7269: return true;
7270: if (jj_scan_token(DOT))
7271: return true;
7272: if (jj_scan_token(CLASS))
7273: return true;
7274: return false;
7275: }
7276:
7277: final private boolean jj_3R_101() {
7278: if (jj_3R_70())
7279: return true;
7280: return false;
7281: }
7282:
7283: final private boolean jj_3R_100() {
7284: if (jj_scan_token(LPAREN))
7285: return true;
7286: if (jj_3R_71())
7287: return true;
7288: if (jj_scan_token(RPAREN))
7289: return true;
7290: return false;
7291: }
7292:
7293: final private boolean jj_3R_99() {
7294: if (jj_scan_token(SUPER))
7295: return true;
7296: if (jj_scan_token(DOT))
7297: return true;
7298: if (jj_scan_token(IDENTIFIER))
7299: return true;
7300: return false;
7301: }
7302:
7303: final private boolean jj_3R_305() {
7304: Token xsp;
7305: xsp = jj_scanpos;
7306: if (jj_scan_token(98)) {
7307: jj_scanpos = xsp;
7308: if (jj_scan_token(99))
7309: return true;
7310: }
7311: return false;
7312: }
7313:
7314: final private boolean jj_3R_98() {
7315: if (jj_3R_117())
7316: return true;
7317: return false;
7318: }
7319:
7320: final private boolean jj_3R_81() {
7321: Token xsp;
7322: xsp = jj_scanpos;
7323: if (jj_3R_98()) {
7324: jj_scanpos = xsp;
7325: if (jj_scan_token(56)) {
7326: jj_scanpos = xsp;
7327: if (jj_3R_99()) {
7328: jj_scanpos = xsp;
7329: if (jj_3R_100()) {
7330: jj_scanpos = xsp;
7331: if (jj_3R_101()) {
7332: jj_scanpos = xsp;
7333: if (jj_3R_102()) {
7334: jj_scanpos = xsp;
7335: if (jj_3R_103())
7336: return true;
7337: }
7338: }
7339: }
7340: }
7341: }
7342: }
7343: return false;
7344: }
7345:
7346: final private boolean jj_3_18() {
7347: if (jj_scan_token(LPAREN))
7348: return true;
7349: if (jj_3R_67())
7350: return true;
7351: return false;
7352: }
7353:
7354: final private boolean jj_3R_62() {
7355: if (jj_3R_81())
7356: return true;
7357: Token xsp;
7358: while (true) {
7359: xsp = jj_scanpos;
7360: if (jj_3_19()) {
7361: jj_scanpos = xsp;
7362: break;
7363: }
7364: }
7365: return false;
7366: }
7367:
7368: final private boolean jj_3R_294() {
7369: if (jj_scan_token(LPAREN))
7370: return true;
7371: if (jj_3R_73())
7372: return true;
7373: if (jj_scan_token(RPAREN))
7374: return true;
7375: if (jj_3R_223())
7376: return true;
7377: return false;
7378: }
7379:
7380: final private boolean jj_3R_293() {
7381: if (jj_scan_token(LPAREN))
7382: return true;
7383: if (jj_3R_73())
7384: return true;
7385: if (jj_scan_token(RPAREN))
7386: return true;
7387: if (jj_3R_197())
7388: return true;
7389: return false;
7390: }
7391:
7392: final private boolean jj_3R_285() {
7393: Token xsp;
7394: xsp = jj_scanpos;
7395: if (jj_3R_293()) {
7396: jj_scanpos = xsp;
7397: if (jj_3R_294())
7398: return true;
7399: }
7400: return false;
7401: }
7402:
7403: final private boolean jj_3_17() {
7404: if (jj_scan_token(LPAREN))
7405: return true;
7406: if (jj_3R_56())
7407: return true;
7408: if (jj_scan_token(LBRACKET))
7409: return true;
7410: return false;
7411: }
7412:
7413: final private boolean jj_3R_286() {
7414: if (jj_3R_62())
7415: return true;
7416: Token xsp;
7417: xsp = jj_scanpos;
7418: if (jj_3R_305())
7419: jj_scanpos = xsp;
7420: return false;
7421: }
7422:
7423: final private boolean jj_3R_84() {
7424: if (jj_scan_token(LPAREN))
7425: return true;
7426: if (jj_3R_56())
7427: return true;
7428: if (jj_scan_token(RPAREN))
7429: return true;
7430: Token xsp;
7431: xsp = jj_scanpos;
7432: if (jj_scan_token(89)) {
7433: jj_scanpos = xsp;
7434: if (jj_scan_token(88)) {
7435: jj_scanpos = xsp;
7436: if (jj_scan_token(76)) {
7437: jj_scanpos = xsp;
7438: if (jj_scan_token(73)) {
7439: jj_scanpos = xsp;
7440: if (jj_scan_token(56)) {
7441: jj_scanpos = xsp;
7442: if (jj_scan_token(53)) {
7443: jj_scanpos = xsp;
7444: if (jj_scan_token(43)) {
7445: jj_scanpos = xsp;
7446: if (jj_3R_105())
7447: return true;
7448: }
7449: }
7450: }
7451: }
7452: }
7453: }
7454: }
7455: return false;
7456: }
7457:
7458: final private boolean jj_3R_83() {
7459: if (jj_scan_token(LPAREN))
7460: return true;
7461: if (jj_3R_56())
7462: return true;
7463: if (jj_scan_token(LBRACKET))
7464: return true;
7465: if (jj_scan_token(RBRACKET))
7466: return true;
7467: return false;
7468: }
7469:
7470: final private boolean jj_3_16() {
7471: if (jj_scan_token(LPAREN))
7472: return true;
7473: if (jj_3R_67())
7474: return true;
7475: return false;
7476: }
7477:
7478: final private boolean jj_3R_66() {
7479: Token xsp;
7480: xsp = jj_scanpos;
7481: if (jj_3_16()) {
7482: jj_scanpos = xsp;
7483: if (jj_3R_83()) {
7484: jj_scanpos = xsp;
7485: if (jj_3R_84())
7486: return true;
7487: }
7488: }
7489: return false;
7490: }
7491:
7492: final private boolean jj_3_15() {
7493: if (jj_3R_66())
7494: return true;
7495: return false;
7496: }
7497:
7498: final private boolean jj_3R_268() {
7499: if (jj_3R_286())
7500: return true;
7501: return false;
7502: }
7503:
7504: final private boolean jj_3R_267() {
7505: if (jj_3R_285())
7506: return true;
7507: return false;
7508: }
7509:
7510: final private boolean jj_3R_223() {
7511: Token xsp;
7512: xsp = jj_scanpos;
7513: if (jj_3R_266()) {
7514: jj_scanpos = xsp;
7515: if (jj_3R_267()) {
7516: jj_scanpos = xsp;
7517: if (jj_3R_268())
7518: return true;
7519: }
7520: }
7521: return false;
7522: }
7523:
7524: final private boolean jj_3R_266() {
7525: Token xsp;
7526: xsp = jj_scanpos;
7527: if (jj_scan_token(89)) {
7528: jj_scanpos = xsp;
7529: if (jj_scan_token(88))
7530: return true;
7531: }
7532: if (jj_3R_197())
7533: return true;
7534: return false;
7535: }
7536:
7537: final private boolean jj_3R_175() {
7538: if (jj_scan_token(DECR))
7539: return true;
7540: if (jj_3R_62())
7541: return true;
7542: return false;
7543: }
7544:
7545: final private boolean jj_3R_222() {
7546: Token xsp;
7547: xsp = jj_scanpos;
7548: if (jj_scan_token(100)) {
7549: jj_scanpos = xsp;
7550: if (jj_scan_token(101))
7551: return true;
7552: }
7553: if (jj_3R_190())
7554: return true;
7555: return false;
7556: }
7557:
7558: final private boolean jj_3R_265() {
7559: Token xsp;
7560: xsp = jj_scanpos;
7561: if (jj_scan_token(102)) {
7562: jj_scanpos = xsp;
7563: if (jj_scan_token(103)) {
7564: jj_scanpos = xsp;
7565: if (jj_scan_token(107))
7566: return true;
7567: }
7568: }
7569: if (jj_3R_197())
7570: return true;
7571: return false;
7572: }
7573:
7574: final private boolean jj_3R_174() {
7575: if (jj_scan_token(INCR))
7576: return true;
7577: if (jj_3R_62())
7578: return true;
7579: return false;
7580: }
7581:
7582: final private boolean jj_3R_207() {
7583: if (jj_3R_223())
7584: return true;
7585: return false;
7586: }
7587:
7588: final private boolean jj_3R_203() {
7589: Token xsp;
7590: xsp = jj_scanpos;
7591: if (jj_scan_token(108)) {
7592: jj_scanpos = xsp;
7593: if (jj_scan_token(109)) {
7594: jj_scanpos = xsp;
7595: if (jj_scan_token(110))
7596: return true;
7597: }
7598: }
7599: if (jj_3R_187())
7600: return true;
7601: return false;
7602: }
7603:
7604: final private boolean jj_3R_206() {
7605: if (jj_3R_175())
7606: return true;
7607: return false;
7608: }
7609:
7610: final private boolean jj_3R_205() {
7611: if (jj_3R_174())
7612: return true;
7613: return false;
7614: }
7615:
7616: final private boolean jj_3R_197() {
7617: Token xsp;
7618: xsp = jj_scanpos;
7619: if (jj_3R_204()) {
7620: jj_scanpos = xsp;
7621: if (jj_3R_205()) {
7622: jj_scanpos = xsp;
7623: if (jj_3R_206()) {
7624: jj_scanpos = xsp;
7625: if (jj_3R_207())
7626: return true;
7627: }
7628: }
7629: }
7630: return false;
7631: }
7632:
7633: final private boolean jj_3R_204() {
7634: Token xsp;
7635: xsp = jj_scanpos;
7636: if (jj_scan_token(100)) {
7637: jj_scanpos = xsp;
7638: if (jj_scan_token(101))
7639: return true;
7640: }
7641: if (jj_3R_197())
7642: return true;
7643: return false;
7644: }
7645:
7646: final private boolean jj_3R_196() {
7647: Token xsp;
7648: xsp = jj_scanpos;
7649: if (jj_scan_token(87)) {
7650: jj_scanpos = xsp;
7651: if (jj_scan_token(86)) {
7652: jj_scanpos = xsp;
7653: if (jj_scan_token(93)) {
7654: jj_scanpos = xsp;
7655: if (jj_scan_token(94))
7656: return true;
7657: }
7658: }
7659: }
7660: if (jj_3R_183())
7661: return true;
7662: return false;
7663: }
7664:
7665: final private boolean jj_3R_189() {
7666: if (jj_scan_token(INSTANCEOF))
7667: return true;
7668: if (jj_3R_73())
7669: return true;
7670: return false;
7671: }
7672:
7673: final private boolean jj_3R_190() {
7674: if (jj_3R_197())
7675: return true;
7676: Token xsp;
7677: while (true) {
7678: xsp = jj_scanpos;
7679: if (jj_3R_265()) {
7680: jj_scanpos = xsp;
7681: break;
7682: }
7683: }
7684: return false;
7685: }
7686:
7687: final private boolean jj_3R_186() {
7688: Token xsp;
7689: xsp = jj_scanpos;
7690: if (jj_scan_token(92)) {
7691: jj_scanpos = xsp;
7692: if (jj_scan_token(95))
7693: return true;
7694: }
7695: if (jj_3R_173())
7696: return true;
7697: return false;
7698: }
7699:
7700: final private boolean jj_3R_187() {
7701: if (jj_3R_190())
7702: return true;
7703: Token xsp;
7704: while (true) {
7705: xsp = jj_scanpos;
7706: if (jj_3R_222()) {
7707: jj_scanpos = xsp;
7708: break;
7709: }
7710: }
7711: return false;
7712: }
7713:
7714: final private boolean jj_3R_183() {
7715: if (jj_3R_187())
7716: return true;
7717: Token xsp;
7718: while (true) {
7719: xsp = jj_scanpos;
7720: if (jj_3R_203()) {
7721: jj_scanpos = xsp;
7722: break;
7723: }
7724: }
7725: return false;
7726: }
7727:
7728: final private boolean jj_3R_182() {
7729: if (jj_scan_token(BIT_AND))
7730: return true;
7731: if (jj_3R_165())
7732: return true;
7733: return false;
7734: }
7735:
7736: final private boolean jj_3R_179() {
7737: if (jj_3R_183())
7738: return true;
7739: Token xsp;
7740: while (true) {
7741: xsp = jj_scanpos;
7742: if (jj_3R_196()) {
7743: jj_scanpos = xsp;
7744: break;
7745: }
7746: }
7747: return false;
7748: }
7749:
7750: final private boolean jj_3R_172() {
7751: if (jj_scan_token(BIT_OR))
7752: return true;
7753: if (jj_3R_134())
7754: return true;
7755: return false;
7756: }
7757:
7758: final private boolean jj_3R_173() {
7759: if (jj_3R_179())
7760: return true;
7761: Token xsp;
7762: xsp = jj_scanpos;
7763: if (jj_3R_189())
7764: jj_scanpos = xsp;
7765: return false;
7766: }
7767:
7768: final private boolean jj_3R_178() {
7769: if (jj_scan_token(XOR))
7770: return true;
7771: if (jj_3R_150())
7772: return true;
7773: return false;
7774: }
7775:
7776: final private boolean jj_3R_164() {
7777: if (jj_scan_token(SC_AND))
7778: return true;
7779: if (jj_3R_126())
7780: return true;
7781: return false;
7782: }
7783:
7784: final private boolean jj_3R_165() {
7785: if (jj_3R_173())
7786: return true;
7787: Token xsp;
7788: while (true) {
7789: xsp = jj_scanpos;
7790: if (jj_3R_186()) {
7791: jj_scanpos = xsp;
7792: break;
7793: }
7794: }
7795: return false;
7796: }
7797:
7798: final private boolean jj_3R_149() {
7799: if (jj_scan_token(SC_OR))
7800: return true;
7801: if (jj_3R_119())
7802: return true;
7803: return false;
7804: }
7805:
7806: final private boolean jj_3R_150() {
7807: if (jj_3R_165())
7808: return true;
7809: Token xsp;
7810: while (true) {
7811: xsp = jj_scanpos;
7812: if (jj_3R_182()) {
7813: jj_scanpos = xsp;
7814: break;
7815: }
7816: }
7817: return false;
7818: }
7819:
7820: final private boolean jj_3R_132() {
7821: if (jj_scan_token(HOOK))
7822: return true;
7823: if (jj_3R_71())
7824: return true;
7825: if (jj_scan_token(COLON))
7826: return true;
7827: if (jj_3R_92())
7828: return true;
7829: return false;
7830: }
7831:
7832: final private boolean jj_3R_134() {
7833: if (jj_3R_150())
7834: return true;
7835: Token xsp;
7836: while (true) {
7837: xsp = jj_scanpos;
7838: if (jj_3R_178()) {
7839: jj_scanpos = xsp;
7840: break;
7841: }
7842: }
7843: return false;
7844: }
7845:
7846: final private boolean jj_3R_126() {
7847: if (jj_3R_134())
7848: return true;
7849: Token xsp;
7850: while (true) {
7851: xsp = jj_scanpos;
7852: if (jj_3R_172()) {
7853: jj_scanpos = xsp;
7854: break;
7855: }
7856: }
7857: return false;
7858: }
7859:
7860: final private boolean jj_3R_119() {
7861: if (jj_3R_126())
7862: return true;
7863: Token xsp;
7864: while (true) {
7865: xsp = jj_scanpos;
7866: if (jj_3R_164()) {
7867: jj_scanpos = xsp;
7868: break;
7869: }
7870: }
7871: return false;
7872: }
7873:
7874: final private boolean jj_3R_114() {
7875: if (jj_3R_119())
7876: return true;
7877: Token xsp;
7878: while (true) {
7879: xsp = jj_scanpos;
7880: if (jj_3R_149()) {
7881: jj_scanpos = xsp;
7882: break;
7883: }
7884: }
7885: return false;
7886: }
7887:
7888: final private boolean jj_3R_92() {
7889: if (jj_3R_114())
7890: return true;
7891: Token xsp;
7892: xsp = jj_scanpos;
7893: if (jj_3R_132())
7894: jj_scanpos = xsp;
7895: return false;
7896: }
7897:
7898: final private boolean jj_3R_133() {
7899: Token xsp;
7900: xsp = jj_scanpos;
7901: if (jj_scan_token(85)) {
7902: jj_scanpos = xsp;
7903: if (jj_scan_token(113)) {
7904: jj_scanpos = xsp;
7905: if (jj_scan_token(114)) {
7906: jj_scanpos = xsp;
7907: if (jj_scan_token(118)) {
7908: jj_scanpos = xsp;
7909: if (jj_scan_token(111)) {
7910: jj_scanpos = xsp;
7911: if (jj_scan_token(112)) {
7912: jj_scanpos = xsp;
7913: if (jj_scan_token(119)) {
7914: jj_scanpos = xsp;
7915: if (jj_scan_token(120)) {
7916: jj_scanpos = xsp;
7917: if (jj_scan_token(121)) {
7918: jj_scanpos = xsp;
7919: if (jj_scan_token(115)) {
7920: jj_scanpos = xsp;
7921: if (jj_scan_token(117)) {
7922: jj_scanpos = xsp;
7923: if (jj_scan_token(116))
7924: return true;
7925: }
7926: }
7927: }
7928: }
7929: }
7930: }
7931: }
7932: }
7933: }
7934: }
7935: }
7936: return false;
7937: }
7938:
7939: final private boolean jj_3R_125() {
7940: if (jj_3R_133())
7941: return true;
7942: if (jj_3R_71())
7943: return true;
7944: return false;
7945: }
7946:
7947: final private boolean jj_3R_71() {
7948: if (jj_3R_92())
7949: return true;
7950: Token xsp;
7951: xsp = jj_scanpos;
7952: if (jj_3R_125())
7953: jj_scanpos = xsp;
7954: return false;
7955: }
7956:
7957: final private boolean jj_3R_281() {
7958: if (jj_scan_token(NATIVE))
7959: return true;
7960: return false;
7961: }
7962:
7963: final private boolean jj_3R_272() {
7964: if (jj_scan_token(STRICTFP))
7965: return true;
7966: return false;
7967: }
7968:
7969: final private boolean jj_3R_284() {
7970: if (jj_scan_token(VOLATILE))
7971: return true;
7972: return false;
7973: }
7974:
7975: final private boolean jj_3R_283() {
7976: if (jj_scan_token(TRANSIENT))
7977: return true;
7978: return false;
7979: }
7980:
7981: final private boolean jj_3R_271() {
7982: if (jj_scan_token(FINAL))
7983: return true;
7984: return false;
7985: }
7986:
7987: final private boolean jj_3R_282() {
7988: if (jj_scan_token(SYNCHRONIZED))
7989: return true;
7990: return false;
7991: }
7992:
7993: final private boolean jj_3R_270() {
7994: if (jj_scan_token(ABSTRACT))
7995: return true;
7996: return false;
7997: }
7998:
7999: final private boolean jj_3R_269() {
8000: if (jj_scan_token(STATIC))
8001: return true;
8002: return false;
8003: }
8004:
8005: public ParserTokenManager token_source;
8006: JavaCharStream jj_input_stream;
8007: public Token token, jj_nt;
8008: private int jj_ntk;
8009: private Token jj_scanpos, jj_lastpos;
8010: private int jj_la;
8011: public boolean lookingAhead = false;
8012: private boolean jj_semLA;
8013: private int jj_gen;
8014: final private int[] jj_la1 = new int[122];
8015: static private int[] jj_la1_0;
8016: static private int[] jj_la1_1;
8017: static private int[] jj_la1_2;
8018: static private int[] jj_la1_3;
8019: static {
8020: jj_la1_0();
8021: jj_la1_1();
8022: jj_la1_2();
8023: jj_la1_3();
8024: }
8025:
8026: private static void jj_la1_0() {
8027: jj_la1_0 = new int[] { 0x0, 0x0, 0x40202000, 0x0, 0x2000,
8028: 0x40002000, 0x40002000, 0x10000000, 0x0, 0x4432a000,
8029: 0x40002000, 0x40002000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8030: 0x44128000, 0x40002000, 0x40002000, 0x2000, 0x2000,
8031: 0x40002000, 0x40002000, 0x10000000, 0x4432a000, 0x0,
8032: 0x0, 0x0, 0x0, 0x44128000, 0x40000000, 0x40000000, 0x0,
8033: 0x0, 0x24128000, 0x24128000, 0x0, 0x40002000,
8034: 0x40002000, 0x0, 0x0, 0x0, 0x44128000, 0x40000000, 0x0,
8035: 0x0, 0x0, 0x66b3c000, 0x24128000, 0x0, 0x4128000,
8036: 0x4128000, 0x4128000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8037: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8038: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x24128000, 0x0, 0x0,
8039: 0x24128000, 0x20000000, 0x0, 0x0, 0x0, 0x0, 0x20000000,
8040: 0x0, 0x0, 0x20000000, 0x20000000, 0x24128000, 0x0, 0x0,
8041: 0x0, 0x0, 0x0, 0x0, 0x2693c000, 0x0, 0x66b3c000,
8042: 0x26b3c000, 0x40000000, 0x0, 0x0, 0x0, 0x24128000,
8043: 0x1040000, 0x66b3c000, 0x1040000, 0x8000000,
8044: 0x64128000, 0x24128000, 0x24128000, 0x24128000, 0x0,
8045: 0x0, 0x0, 0x24128000, 0x80000, 0x80000000, };
8046: }
8047:
8048: private static void jj_la1_1() {
8049: jj_la1_1 = new int[] { 0x2000, 0x20, 0x110100, 0x0, 0x10100,
8050: 0x110000, 0x110000, 0x0, 0x10, 0xc89dc781, 0x19c000,
8051: 0x19c000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x881dc281,
8052: 0x99c400, 0x99c400, 0x10000, 0x10000, 0x9c000, 0x9c000,
8053: 0x0, 0xc89dc781, 0x0, 0x0, 0x0, 0x0, 0x881dc281,
8054: 0x8819c000, 0x8819c000, 0x0, 0x0, 0x51241a81,
8055: 0x51241a81, 0x0, 0x99c400, 0x99c400, 0x4000000, 0x0,
8056: 0x0, 0x40281, 0x0, 0x1c000, 0x1c000, 0x4000000,
8057: 0x73e61b8b, 0x51241a81, 0x80000, 0x40281, 0x40281,
8058: 0x40040281, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8059: 0x0, 0x0, 0x0, 0x0, 0x0, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0,
8060: 0x0, 0x0, 0x0, 0x0, 0x51241a81, 0x0, 0x0, 0x51241a81,
8061: 0x11201800, 0x0, 0x0, 0x0, 0x0, 0x11201800, 0x0, 0x0,
8062: 0x10001000, 0x10000000, 0x51241a81, 0x0, 0x0, 0x0,
8063: 0x800, 0x0, 0x0, 0x73e61a8b, 0x0, 0x73e61b8b,
8064: 0x73e61b8b, 0x0, 0x0, 0x0, 0x0, 0x51241a81, 0x0,
8065: 0x73e61b8b, 0x0, 0x0, 0x51241a81, 0x51241a81,
8066: 0x51241a81, 0x51241a81, 0x0, 0x0, 0x0, 0x51241a81, 0x0,
8067: 0x0, };
8068: }
8069:
8070: private static void jj_la1_2() {
8071: jj_la1_2 = new int[] { 0x0, 0x0, 0x40000, 0x100000, 0x40000,
8072: 0x0, 0x0, 0x0, 0x0, 0x4200, 0x0, 0x0, 0x40000, 0x40000,
8073: 0x40000, 0x40000, 0x40000, 0x40000, 0x200, 0x0, 0x0,
8074: 0x0, 0x0, 0x0, 0x0, 0x0, 0x200, 0x40000, 0x40000,
8075: 0x40000, 0x40000, 0x200, 0x0, 0x0, 0x80000, 0x200000,
8076: 0x30053a2, 0x30053a2, 0x80000, 0x0, 0x0, 0x0, 0x44000,
8077: 0x80000, 0x200, 0x0, 0x0, 0x0, 0x0, 0x453a3, 0x13a2,
8078: 0x0, 0x200, 0x0, 0x200, 0x80000, 0x80000, 0x10000,
8079: 0x200000, 0x200000, 0x4000000, 0x0, 0x0, 0x0, 0x0, 0x0,
8080: 0x90000000, 0x90000000, 0x0, 0x60c00000, 0x60c00000,
8081: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x30013a2,
8082: 0x3000000, 0x3000000, 0x13a2, 0x30013a2, 0x1000, 0x0,
8083: 0x0, 0x1000, 0x11a2, 0x200, 0x111000, 0x1a2, 0x0,
8084: 0x30013a2, 0x80000, 0x4000, 0x11000, 0x0, 0x10000,
8085: 0x10000, 0x453a3, 0x8000000, 0x453a3, 0x453a3, 0x0,
8086: 0x80000, 0x200000, 0x200000, 0x13a2, 0x0, 0x453a3, 0x0,
8087: 0x0, 0x13a2, 0x30013a2, 0x13a2, 0x13a2, 0x80000, 0x200,
8088: 0x200, 0x30013a2, 0x0, 0x0, };
8089: }
8090:
8091: private static void jj_la1_3() {
8092: jj_la1_3 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8093: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8094: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
8095: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x3c, 0x0, 0x0,
8096: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0x0,
8097: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3ff8000,
8098: 0x3ff8000, 0x0, 0x1, 0x2, 0x200, 0x400, 0x100, 0x0,
8099: 0x0, 0x0, 0x0, 0x0, 0x7000, 0x7000, 0x30, 0x30, 0x8c0,
8100: 0x8c0, 0x30, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xc,
8101: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0,
8102: 0x0, 0x0, 0xc, 0x0, 0xc, 0xc, 0x0, 0x0, 0x3ff800c,
8103: 0x3ff800c, 0xc, 0x0, 0xc, 0x0, 0x0, 0xc, 0x3c, 0xc,
8104: 0xc, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, };
8105: }
8106:
8107: final private JJCalls[] jj_2_rtns = new JJCalls[29];
8108: private boolean jj_rescan = false;
8109: private int jj_gc = 0;
8110:
8111: public Parser(java.io.InputStream stream) {
8112: jj_input_stream = new JavaCharStream(stream, 1, 1);
8113: token_source = new ParserTokenManager(jj_input_stream);
8114: token = new Token();
8115: jj_ntk = -1;
8116: jj_gen = 0;
8117: for (int i = 0; i < 122; i++)
8118: jj_la1[i] = -1;
8119: for (int i = 0; i < jj_2_rtns.length; i++)
8120: jj_2_rtns[i] = new JJCalls();
8121: }
8122:
8123: public void ReInit(java.io.InputStream stream) {
8124: jj_input_stream.ReInit(stream, 1, 1);
8125: token_source.ReInit(jj_input_stream);
8126: token = new Token();
8127: jj_ntk = -1;
8128: jjtree.reset();
8129: jj_gen = 0;
8130: for (int i = 0; i < 122; i++)
8131: jj_la1[i] = -1;
8132: for (int i = 0; i < jj_2_rtns.length; i++)
8133: jj_2_rtns[i] = new JJCalls();
8134: }
8135:
8136: public Parser(java.io.Reader stream) {
8137: jj_input_stream = new JavaCharStream(stream, 1, 1);
8138: token_source = new ParserTokenManager(jj_input_stream);
8139: token = new Token();
8140: jj_ntk = -1;
8141: jj_gen = 0;
8142: for (int i = 0; i < 122; i++)
8143: jj_la1[i] = -1;
8144: for (int i = 0; i < jj_2_rtns.length; i++)
8145: jj_2_rtns[i] = new JJCalls();
8146: }
8147:
8148: public void ReInit(java.io.Reader stream) {
8149: jj_input_stream.ReInit(stream, 1, 1);
8150: token_source.ReInit(jj_input_stream);
8151: token = new Token();
8152: jj_ntk = -1;
8153: jjtree.reset();
8154: jj_gen = 0;
8155: for (int i = 0; i < 122; i++)
8156: jj_la1[i] = -1;
8157: for (int i = 0; i < jj_2_rtns.length; i++)
8158: jj_2_rtns[i] = new JJCalls();
8159: }
8160:
8161: public Parser(ParserTokenManager tm) {
8162: token_source = tm;
8163: token = new Token();
8164: jj_ntk = -1;
8165: jj_gen = 0;
8166: for (int i = 0; i < 122; i++)
8167: jj_la1[i] = -1;
8168: for (int i = 0; i < jj_2_rtns.length; i++)
8169: jj_2_rtns[i] = new JJCalls();
8170: }
8171:
8172: public void ReInit(ParserTokenManager tm) {
8173: token_source = tm;
8174: token = new Token();
8175: jj_ntk = -1;
8176: jjtree.reset();
8177: jj_gen = 0;
8178: for (int i = 0; i < 122; i++)
8179: jj_la1[i] = -1;
8180: for (int i = 0; i < jj_2_rtns.length; i++)
8181: jj_2_rtns[i] = new JJCalls();
8182: }
8183:
8184: final private Token jj_consume_token(int kind)
8185: throws ParseException {
8186: Token oldToken;
8187: if ((oldToken = token).next != null)
8188: token = token.next;
8189: else
8190: token = token.next = token_source.getNextToken();
8191: jj_ntk = -1;
8192: if (token.kind == kind) {
8193: jj_gen++;
8194: if (++jj_gc > 100) {
8195: jj_gc = 0;
8196: for (int i = 0; i < jj_2_rtns.length; i++) {
8197: JJCalls c = jj_2_rtns[i];
8198: while (c != null) {
8199: if (c.gen < jj_gen)
8200: c.first = null;
8201: c = c.next;
8202: }
8203: }
8204: }
8205: return token;
8206: }
8207: token = oldToken;
8208: jj_kind = kind;
8209: throw generateParseException();
8210: }
8211:
8212: static private final class LookaheadSuccess extends java.lang.Error {
8213: }
8214:
8215: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
8216:
8217: final private boolean jj_scan_token(int kind) {
8218: if (jj_scanpos == jj_lastpos) {
8219: jj_la--;
8220: if (jj_scanpos.next == null) {
8221: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
8222: .getNextToken();
8223: } else {
8224: jj_lastpos = jj_scanpos = jj_scanpos.next;
8225: }
8226: } else {
8227: jj_scanpos = jj_scanpos.next;
8228: }
8229: if (jj_rescan) {
8230: int i = 0;
8231: Token tok = token;
8232: while (tok != null && tok != jj_scanpos) {
8233: i++;
8234: tok = tok.next;
8235: }
8236: if (tok != null)
8237: jj_add_error_token(kind, i);
8238: }
8239: if (jj_scanpos.kind != kind)
8240: return true;
8241: if (jj_la == 0 && jj_scanpos == jj_lastpos)
8242: throw jj_ls;
8243: return false;
8244: }
8245:
8246: final public Token getNextToken() {
8247: if (token.next != null)
8248: token = token.next;
8249: else
8250: token = token.next = token_source.getNextToken();
8251: jj_ntk = -1;
8252: jj_gen++;
8253: return token;
8254: }
8255:
8256: final public Token getToken(int index) {
8257: Token t = lookingAhead ? jj_scanpos : token;
8258: for (int i = 0; i < index; i++) {
8259: if (t.next != null)
8260: t = t.next;
8261: else
8262: t = t.next = token_source.getNextToken();
8263: }
8264: return t;
8265: }
8266:
8267: final private int jj_ntk() {
8268: if ((jj_nt = token.next) == null)
8269: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
8270: else
8271: return (jj_ntk = jj_nt.kind);
8272: }
8273:
8274: private java.util.Vector jj_expentries = new java.util.Vector();
8275: private int[] jj_expentry;
8276: private int jj_kind = -1;
8277: private int[] jj_lasttokens = new int[100];
8278: private int jj_endpos;
8279:
8280: private void jj_add_error_token(int kind, int pos) {
8281: if (pos >= 100)
8282: return;
8283: if (pos == jj_endpos + 1) {
8284: jj_lasttokens[jj_endpos++] = kind;
8285: } else if (jj_endpos != 0) {
8286: jj_expentry = new int[jj_endpos];
8287: for (int i = 0; i < jj_endpos; i++) {
8288: jj_expentry[i] = jj_lasttokens[i];
8289: }
8290: boolean exists = false;
8291: for (java.util.Enumeration e = jj_expentries.elements(); e
8292: .hasMoreElements();) {
8293: int[] oldentry = (int[]) (e.nextElement());
8294: if (oldentry.length == jj_expentry.length) {
8295: exists = true;
8296: for (int i = 0; i < jj_expentry.length; i++) {
8297: if (oldentry[i] != jj_expentry[i]) {
8298: exists = false;
8299: break;
8300: }
8301: }
8302: if (exists)
8303: break;
8304: }
8305: }
8306: if (!exists)
8307: jj_expentries.addElement(jj_expentry);
8308: if (pos != 0)
8309: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
8310: }
8311: }
8312:
8313: public ParseException generateParseException() {
8314: jj_expentries.removeAllElements();
8315: boolean[] la1tokens = new boolean[122];
8316: for (int i = 0; i < 122; i++) {
8317: la1tokens[i] = false;
8318: }
8319: if (jj_kind >= 0) {
8320: la1tokens[jj_kind] = true;
8321: jj_kind = -1;
8322: }
8323: for (int i = 0; i < 122; i++) {
8324: if (jj_la1[i] == jj_gen) {
8325: for (int j = 0; j < 32; j++) {
8326: if ((jj_la1_0[i] & (1 << j)) != 0) {
8327: la1tokens[j] = true;
8328: }
8329: if ((jj_la1_1[i] & (1 << j)) != 0) {
8330: la1tokens[32 + j] = true;
8331: }
8332: if ((jj_la1_2[i] & (1 << j)) != 0) {
8333: la1tokens[64 + j] = true;
8334: }
8335: if ((jj_la1_3[i] & (1 << j)) != 0) {
8336: la1tokens[96 + j] = true;
8337: }
8338: }
8339: }
8340: }
8341: for (int i = 0; i < 122; i++) {
8342: if (la1tokens[i]) {
8343: jj_expentry = new int[1];
8344: jj_expentry[0] = i;
8345: jj_expentries.addElement(jj_expentry);
8346: }
8347: }
8348: jj_endpos = 0;
8349: jj_rescan_token();
8350: jj_add_error_token(0, 0);
8351: int[][] exptokseq = new int[jj_expentries.size()][];
8352: for (int i = 0; i < jj_expentries.size(); i++) {
8353: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
8354: }
8355: return new ParseException(token, exptokseq, tokenImage);
8356: }
8357:
8358: final public void enable_tracing() {
8359: }
8360:
8361: final public void disable_tracing() {
8362: }
8363:
8364: final private void jj_rescan_token() {
8365: jj_rescan = true;
8366: for (int i = 0; i < 29; i++) {
8367: JJCalls p = jj_2_rtns[i];
8368: do {
8369: if (p.gen > jj_gen) {
8370: jj_la = p.arg;
8371: jj_lastpos = jj_scanpos = p.first;
8372: switch (i) {
8373: case 0:
8374: jj_3_1();
8375: break;
8376: case 1:
8377: jj_3_2();
8378: break;
8379: case 2:
8380: jj_3_3();
8381: break;
8382: case 3:
8383: jj_3_4();
8384: break;
8385: case 4:
8386: jj_3_5();
8387: break;
8388: case 5:
8389: jj_3_6();
8390: break;
8391: case 6:
8392: jj_3_7();
8393: break;
8394: case 7:
8395: jj_3_8();
8396: break;
8397: case 8:
8398: jj_3_9();
8399: break;
8400: case 9:
8401: jj_3_10();
8402: break;
8403: case 10:
8404: jj_3_11();
8405: break;
8406: case 11:
8407: jj_3_12();
8408: break;
8409: case 12:
8410: jj_3_13();
8411: break;
8412: case 13:
8413: jj_3_14();
8414: break;
8415: case 14:
8416: jj_3_15();
8417: break;
8418: case 15:
8419: jj_3_16();
8420: break;
8421: case 16:
8422: jj_3_17();
8423: break;
8424: case 17:
8425: jj_3_18();
8426: break;
8427: case 18:
8428: jj_3_19();
8429: break;
8430: case 19:
8431: jj_3_20();
8432: break;
8433: case 20:
8434: jj_3_21();
8435: break;
8436: case 21:
8437: jj_3_22();
8438: break;
8439: case 22:
8440: jj_3_23();
8441: break;
8442: case 23:
8443: jj_3_24();
8444: break;
8445: case 24:
8446: jj_3_25();
8447: break;
8448: case 25:
8449: jj_3_26();
8450: break;
8451: case 26:
8452: jj_3_27();
8453: break;
8454: case 27:
8455: jj_3_28();
8456: break;
8457: case 28:
8458: jj_3_29();
8459: break;
8460: }
8461: }
8462: p = p.next;
8463: } while (p != null);
8464: }
8465: jj_rescan = false;
8466: }
8467:
8468: final private void jj_save(int index, int xla) {
8469: JJCalls p = jj_2_rtns[index];
8470: while (p.gen > jj_gen) {
8471: if (p.next == null) {
8472: p = p.next = new JJCalls();
8473: break;
8474: }
8475: p = p.next;
8476: }
8477: p.gen = jj_gen + xla - jj_la;
8478: p.first = token;
8479: p.arg = xla;
8480: }
8481:
8482: static final class JJCalls {
8483: int gen;
8484: Token first;
8485: int arg;
8486: JJCalls next;
8487: }
8488:
8489: }
|