0001: /* Generated By:JavaCC: Do not edit this line. JavaParser.java */
0002: package xtc.lang.javacc;
0003:
0004: @SuppressWarnings("unchecked")
0005: public class JavaParser implements JavaParserConstants {
0006: // modified main Andrea Gini 24/02/2002
0007: // modified main. DW, 7/99
0008: public static void main(String[] args) {
0009: JavaParser parser;
0010: String filename = null;
0011: long initTime = 0;
0012: long parseTime = 0;
0013: long startTime = 0;
0014: long stopTime = 0;
0015: if (args.length == 0) {
0016: System.out
0017: .println("Java Parser Version 1.1 (for Java1.4 code): Reading from standard input . . .");
0018: parser = new JavaParser(System.in);
0019: } else if (args.length == 1) {
0020: filename = args[0];
0021: System.out
0022: .println("Java Parser Version 1.1 (for Java1.4 code): Reading from file "
0023: + filename + " . . .");
0024: try {
0025: startTime = System.currentTimeMillis();
0026: parser = new JavaParser(new java.io.FileInputStream(
0027: filename));
0028: stopTime = System.currentTimeMillis();
0029: initTime = stopTime - startTime;
0030: } catch (java.io.FileNotFoundException e) {
0031: System.out
0032: .println("Java Parser Version 1.1 (for Java1.4 code): File "
0033: + filename + " not found.");
0034: return;
0035: }
0036: } else {
0037: System.out
0038: .println("Java Parser Version 1.1 (for Java1.4 code): Usage is one of:");
0039: System.out.println(" java JavaParser < inputfile");
0040: System.out.println("OR");
0041: System.out.println(" java JavaParser inputfile");
0042: return;
0043: }
0044: try {
0045: startTime = System.currentTimeMillis();
0046: parser.CompilationUnit();
0047: stopTime = System.currentTimeMillis();
0048: parseTime = stopTime - startTime;
0049: System.out
0050: .println("Java Parser Version 1.1 (for Java1.4 code): ");
0051: System.out.println(" Java program parsed " + filename
0052: + " successfully in " + (initTime + parseTime)
0053: + " ms.");
0054: System.out.println(" parser initialization time was "
0055: + initTime + " ms.");
0056: System.out.println(" parser parse time was "
0057: + parseTime + " ms.");
0058: } catch (ParseException e) {
0059: System.out.println(e.getMessage());
0060: System.out
0061: .println("Java Parser Version 1.1 (for Java1.4 code): Encountered errors during parse.");
0062: }
0063: }
0064:
0065: /*****************************************
0066: * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
0067: *****************************************/
0068:
0069: /*
0070: * Program structuring syntax follows.
0071: */
0072: final public void CompilationUnit() throws ParseException {
0073: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0074: case PACKAGE:
0075: PackageDeclaration();
0076: break;
0077: default:
0078: jj_la1[0] = jj_gen;
0079: ;
0080: }
0081: label_1: while (true) {
0082: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0083: case IMPORT:
0084: ;
0085: break;
0086: default:
0087: jj_la1[1] = jj_gen;
0088: break label_1;
0089: }
0090: ImportDeclaration();
0091: }
0092: label_2: while (true) {
0093: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0094: case ABSTRACT:
0095: case CLASS:
0096: case FINAL:
0097: case INTERFACE:
0098: case PUBLIC:
0099: case STRICTFP:
0100: case SEMICOLON:
0101: ;
0102: break;
0103: default:
0104: jj_la1[2] = jj_gen;
0105: break label_2;
0106: }
0107: TypeDeclaration();
0108: }
0109: jj_consume_token(0);
0110: }
0111:
0112: final public void PackageDeclaration() throws ParseException {
0113: jj_consume_token(PACKAGE);
0114: Name();
0115: jj_consume_token(SEMICOLON);
0116: }
0117:
0118: final public void ImportDeclaration() throws ParseException {
0119: jj_consume_token(IMPORT);
0120: Name();
0121: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0122: case DOT:
0123: jj_consume_token(DOT);
0124: jj_consume_token(STAR);
0125: break;
0126: default:
0127: jj_la1[3] = jj_gen;
0128: ;
0129: }
0130: jj_consume_token(SEMICOLON);
0131: }
0132:
0133: final public void TypeDeclaration() throws ParseException {
0134: if (jj_2_1(2147483647)) {
0135: ClassDeclaration();
0136: } else {
0137: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0138: case ABSTRACT:
0139: case INTERFACE:
0140: case PUBLIC:
0141: case STRICTFP:
0142: InterfaceDeclaration();
0143: break;
0144: case SEMICOLON:
0145: jj_consume_token(SEMICOLON);
0146: break;
0147: default:
0148: jj_la1[4] = jj_gen;
0149: jj_consume_token(-1);
0150: throw new ParseException();
0151: }
0152: }
0153: }
0154:
0155: /*
0156: * Declaration syntax follows.
0157: */
0158: final public void ClassDeclaration() throws ParseException {
0159: label_3: while (true) {
0160: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0161: case ABSTRACT:
0162: case FINAL:
0163: case PUBLIC:
0164: case STRICTFP:
0165: ;
0166: break;
0167: default:
0168: jj_la1[5] = jj_gen;
0169: break label_3;
0170: }
0171: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0172: case ABSTRACT:
0173: jj_consume_token(ABSTRACT);
0174: break;
0175: case FINAL:
0176: jj_consume_token(FINAL);
0177: break;
0178: case PUBLIC:
0179: jj_consume_token(PUBLIC);
0180: break;
0181: case STRICTFP:
0182: jj_consume_token(STRICTFP);
0183: break;
0184: default:
0185: jj_la1[6] = jj_gen;
0186: jj_consume_token(-1);
0187: throw new ParseException();
0188: }
0189: }
0190: UnmodifiedClassDeclaration();
0191: }
0192:
0193: final public void UnmodifiedClassDeclaration()
0194: throws ParseException {
0195: jj_consume_token(CLASS);
0196: jj_consume_token(IDENTIFIER);
0197: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0198: case EXTENDS:
0199: jj_consume_token(EXTENDS);
0200: Name();
0201: break;
0202: default:
0203: jj_la1[7] = jj_gen;
0204: ;
0205: }
0206: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0207: case IMPLEMENTS:
0208: jj_consume_token(IMPLEMENTS);
0209: NameList();
0210: break;
0211: default:
0212: jj_la1[8] = jj_gen;
0213: ;
0214: }
0215: ClassBody();
0216: }
0217:
0218: final public void ClassBody() throws ParseException {
0219: jj_consume_token(LBRACE);
0220: label_4: while (true) {
0221: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0222: case ABSTRACT:
0223: case BOOLEAN:
0224: case BYTE:
0225: case CHAR:
0226: case CLASS:
0227: case DOUBLE:
0228: case FINAL:
0229: case FLOAT:
0230: case INT:
0231: case INTERFACE:
0232: case LONG:
0233: case NATIVE:
0234: case PRIVATE:
0235: case PROTECTED:
0236: case PUBLIC:
0237: case SHORT:
0238: case STATIC:
0239: case SYNCHRONIZED:
0240: case TRANSIENT:
0241: case VOID:
0242: case VOLATILE:
0243: case STRICTFP:
0244: case IDENTIFIER:
0245: case LBRACE:
0246: case SEMICOLON:
0247: ;
0248: break;
0249: default:
0250: jj_la1[9] = jj_gen;
0251: break label_4;
0252: }
0253: ClassBodyDeclaration();
0254: }
0255: jj_consume_token(RBRACE);
0256: }
0257:
0258: final public void NestedClassDeclaration() throws ParseException {
0259: label_5: while (true) {
0260: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0261: case ABSTRACT:
0262: case FINAL:
0263: case PRIVATE:
0264: case PROTECTED:
0265: case PUBLIC:
0266: case STATIC:
0267: case STRICTFP:
0268: ;
0269: break;
0270: default:
0271: jj_la1[10] = jj_gen;
0272: break label_5;
0273: }
0274: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0275: case STATIC:
0276: jj_consume_token(STATIC);
0277: break;
0278: case ABSTRACT:
0279: jj_consume_token(ABSTRACT);
0280: break;
0281: case FINAL:
0282: jj_consume_token(FINAL);
0283: break;
0284: case PUBLIC:
0285: jj_consume_token(PUBLIC);
0286: break;
0287: case PROTECTED:
0288: jj_consume_token(PROTECTED);
0289: break;
0290: case PRIVATE:
0291: jj_consume_token(PRIVATE);
0292: break;
0293: case STRICTFP:
0294: jj_consume_token(STRICTFP);
0295: break;
0296: default:
0297: jj_la1[11] = jj_gen;
0298: jj_consume_token(-1);
0299: throw new ParseException();
0300: }
0301: }
0302: UnmodifiedClassDeclaration();
0303: }
0304:
0305: /* Modified by Andrea Gini 2
0306: * According rules ClassBody and ClassBodyDeclaration
0307: * in the Java Language Specification,
0308: * semi-colons can be duplicated.
0309: * Source : http://java.sun.com/docs/books/jls/second_edition/html/syntax.doc.html
0310: */
0311: final public void ClassBodyDeclaration() throws ParseException {
0312: if (jj_2_2(2)) {
0313: Initializer();
0314: } else if (jj_2_3(2147483647)) {
0315: NestedClassDeclaration();
0316: } else if (jj_2_4(2147483647)) {
0317: NestedInterfaceDeclaration();
0318: } else if (jj_2_5(2147483647)) {
0319: ConstructorDeclaration();
0320: } else if (jj_2_6(2147483647)) {
0321: MethodDeclaration();
0322: } else {
0323: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0324: case BOOLEAN:
0325: case BYTE:
0326: case CHAR:
0327: case DOUBLE:
0328: case FINAL:
0329: case FLOAT:
0330: case INT:
0331: case LONG:
0332: case PRIVATE:
0333: case PROTECTED:
0334: case PUBLIC:
0335: case SHORT:
0336: case STATIC:
0337: case TRANSIENT:
0338: case VOLATILE:
0339: case IDENTIFIER:
0340: FieldDeclaration();
0341: break;
0342: case SEMICOLON:
0343: jj_consume_token(SEMICOLON);
0344: break;
0345: default:
0346: jj_la1[12] = jj_gen;
0347: jj_consume_token(-1);
0348: throw new ParseException();
0349: }
0350: }
0351: }
0352:
0353: // This production is to determine lookahead only.
0354: final public void MethodDeclarationLookahead()
0355: throws ParseException {
0356: label_6: while (true) {
0357: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0358: case ABSTRACT:
0359: case FINAL:
0360: case NATIVE:
0361: case PRIVATE:
0362: case PROTECTED:
0363: case PUBLIC:
0364: case STATIC:
0365: case SYNCHRONIZED:
0366: case STRICTFP:
0367: ;
0368: break;
0369: default:
0370: jj_la1[13] = jj_gen;
0371: break label_6;
0372: }
0373: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0374: case PUBLIC:
0375: jj_consume_token(PUBLIC);
0376: break;
0377: case PROTECTED:
0378: jj_consume_token(PROTECTED);
0379: break;
0380: case PRIVATE:
0381: jj_consume_token(PRIVATE);
0382: break;
0383: case STATIC:
0384: jj_consume_token(STATIC);
0385: break;
0386: case ABSTRACT:
0387: jj_consume_token(ABSTRACT);
0388: break;
0389: case FINAL:
0390: jj_consume_token(FINAL);
0391: break;
0392: case NATIVE:
0393: jj_consume_token(NATIVE);
0394: break;
0395: case SYNCHRONIZED:
0396: jj_consume_token(SYNCHRONIZED);
0397: break;
0398: case STRICTFP:
0399: jj_consume_token(STRICTFP);
0400: break;
0401: default:
0402: jj_la1[14] = jj_gen;
0403: jj_consume_token(-1);
0404: throw new ParseException();
0405: }
0406: }
0407: ResultType();
0408: jj_consume_token(IDENTIFIER);
0409: jj_consume_token(LPAREN);
0410: }
0411:
0412: final public void InterfaceDeclaration() throws ParseException {
0413: label_7: while (true) {
0414: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0415: case ABSTRACT:
0416: case PUBLIC:
0417: case STRICTFP:
0418: ;
0419: break;
0420: default:
0421: jj_la1[15] = jj_gen;
0422: break label_7;
0423: }
0424: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0425: case ABSTRACT:
0426: jj_consume_token(ABSTRACT);
0427: break;
0428: case PUBLIC:
0429: jj_consume_token(PUBLIC);
0430: break;
0431: case STRICTFP:
0432: jj_consume_token(STRICTFP);
0433: break;
0434: default:
0435: jj_la1[16] = jj_gen;
0436: jj_consume_token(-1);
0437: throw new ParseException();
0438: }
0439: }
0440: UnmodifiedInterfaceDeclaration();
0441: }
0442:
0443: final public void NestedInterfaceDeclaration()
0444: throws ParseException {
0445: label_8: while (true) {
0446: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0447: case ABSTRACT:
0448: case FINAL:
0449: case PRIVATE:
0450: case PROTECTED:
0451: case PUBLIC:
0452: case STATIC:
0453: case STRICTFP:
0454: ;
0455: break;
0456: default:
0457: jj_la1[17] = jj_gen;
0458: break label_8;
0459: }
0460: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0461: case STATIC:
0462: jj_consume_token(STATIC);
0463: break;
0464: case ABSTRACT:
0465: jj_consume_token(ABSTRACT);
0466: break;
0467: case FINAL:
0468: jj_consume_token(FINAL);
0469: break;
0470: case PUBLIC:
0471: jj_consume_token(PUBLIC);
0472: break;
0473: case PROTECTED:
0474: jj_consume_token(PROTECTED);
0475: break;
0476: case PRIVATE:
0477: jj_consume_token(PRIVATE);
0478: break;
0479: case STRICTFP:
0480: jj_consume_token(STRICTFP);
0481: break;
0482: default:
0483: jj_la1[18] = jj_gen;
0484: jj_consume_token(-1);
0485: throw new ParseException();
0486: }
0487: }
0488: UnmodifiedInterfaceDeclaration();
0489: }
0490:
0491: final public void UnmodifiedInterfaceDeclaration()
0492: throws ParseException {
0493: jj_consume_token(INTERFACE);
0494: jj_consume_token(IDENTIFIER);
0495: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0496: case EXTENDS:
0497: jj_consume_token(EXTENDS);
0498: NameList();
0499: break;
0500: default:
0501: jj_la1[19] = jj_gen;
0502: ;
0503: }
0504: jj_consume_token(LBRACE);
0505: label_9: while (true) {
0506: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0507: case ABSTRACT:
0508: case BOOLEAN:
0509: case BYTE:
0510: case CHAR:
0511: case CLASS:
0512: case DOUBLE:
0513: case FINAL:
0514: case FLOAT:
0515: case INT:
0516: case INTERFACE:
0517: case LONG:
0518: case NATIVE:
0519: case PRIVATE:
0520: case PROTECTED:
0521: case PUBLIC:
0522: case SHORT:
0523: case STATIC:
0524: case SYNCHRONIZED:
0525: case TRANSIENT:
0526: case VOID:
0527: case VOLATILE:
0528: case STRICTFP:
0529: case IDENTIFIER:
0530: case SEMICOLON:
0531: ;
0532: break;
0533: default:
0534: jj_la1[20] = jj_gen;
0535: break label_9;
0536: }
0537: InterfaceMemberDeclaration();
0538: }
0539: jj_consume_token(RBRACE);
0540: }
0541:
0542: /* Modified by Andrea Gini 2
0543: * According to rules InterfaceBody and InterfaceBodyDeclaration
0544: * in the Java Language Specification,
0545: * semi-colons can be duplicated.
0546: * Source : http://java.sun.com/docs/books/jls/second_edition/html/syntax.doc.html
0547: */
0548: final public void InterfaceMemberDeclaration()
0549: throws ParseException {
0550: if (jj_2_7(2147483647)) {
0551: NestedClassDeclaration();
0552: } else if (jj_2_8(2147483647)) {
0553: NestedInterfaceDeclaration();
0554: } else if (jj_2_9(2147483647)) {
0555: MethodDeclaration();
0556: } else {
0557: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0558: case BOOLEAN:
0559: case BYTE:
0560: case CHAR:
0561: case DOUBLE:
0562: case FINAL:
0563: case FLOAT:
0564: case INT:
0565: case LONG:
0566: case PRIVATE:
0567: case PROTECTED:
0568: case PUBLIC:
0569: case SHORT:
0570: case STATIC:
0571: case TRANSIENT:
0572: case VOLATILE:
0573: case IDENTIFIER:
0574: FieldDeclaration();
0575: break;
0576: case SEMICOLON:
0577: jj_consume_token(SEMICOLON);
0578: break;
0579: default:
0580: jj_la1[21] = jj_gen;
0581: jj_consume_token(-1);
0582: throw new ParseException();
0583: }
0584: }
0585: }
0586:
0587: final public void FieldDeclaration() throws ParseException {
0588: label_10: while (true) {
0589: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0590: case FINAL:
0591: case PRIVATE:
0592: case PROTECTED:
0593: case PUBLIC:
0594: case STATIC:
0595: case TRANSIENT:
0596: case VOLATILE:
0597: ;
0598: break;
0599: default:
0600: jj_la1[22] = jj_gen;
0601: break label_10;
0602: }
0603: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0604: case PUBLIC:
0605: jj_consume_token(PUBLIC);
0606: break;
0607: case PROTECTED:
0608: jj_consume_token(PROTECTED);
0609: break;
0610: case PRIVATE:
0611: jj_consume_token(PRIVATE);
0612: break;
0613: case STATIC:
0614: jj_consume_token(STATIC);
0615: break;
0616: case FINAL:
0617: jj_consume_token(FINAL);
0618: break;
0619: case TRANSIENT:
0620: jj_consume_token(TRANSIENT);
0621: break;
0622: case VOLATILE:
0623: jj_consume_token(VOLATILE);
0624: break;
0625: default:
0626: jj_la1[23] = jj_gen;
0627: jj_consume_token(-1);
0628: throw new ParseException();
0629: }
0630: }
0631: Type();
0632: VariableDeclarator();
0633: label_11: while (true) {
0634: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0635: case COMMA:
0636: ;
0637: break;
0638: default:
0639: jj_la1[24] = jj_gen;
0640: break label_11;
0641: }
0642: jj_consume_token(COMMA);
0643: VariableDeclarator();
0644: }
0645: jj_consume_token(SEMICOLON);
0646: }
0647:
0648: final public void VariableDeclarator() throws ParseException {
0649: VariableDeclaratorId();
0650: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0651: case ASSIGN:
0652: jj_consume_token(ASSIGN);
0653: VariableInitializer();
0654: break;
0655: default:
0656: jj_la1[25] = jj_gen;
0657: ;
0658: }
0659: }
0660:
0661: final public void VariableDeclaratorId() throws ParseException {
0662: jj_consume_token(IDENTIFIER);
0663: label_12: while (true) {
0664: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0665: case LBRACKET:
0666: ;
0667: break;
0668: default:
0669: jj_la1[26] = jj_gen;
0670: break label_12;
0671: }
0672: jj_consume_token(LBRACKET);
0673: jj_consume_token(RBRACKET);
0674: }
0675: }
0676:
0677: final public void VariableInitializer() throws ParseException {
0678: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0679: case LBRACE:
0680: ArrayInitializer();
0681: break;
0682: case BOOLEAN:
0683: case BYTE:
0684: case CHAR:
0685: case DOUBLE:
0686: case FALSE:
0687: case FLOAT:
0688: case INT:
0689: case LONG:
0690: case NEW:
0691: case NULL:
0692: case SHORT:
0693: case SUPER:
0694: case THIS:
0695: case TRUE:
0696: case VOID:
0697: case INTEGER_LITERAL:
0698: case FLOATING_POINT_LITERAL:
0699: case CHARACTER_LITERAL:
0700: case STRING_LITERAL:
0701: case IDENTIFIER:
0702: case LPAREN:
0703: case BANG:
0704: case TILDE:
0705: case INCR:
0706: case DECR:
0707: case PLUS:
0708: case MINUS:
0709: Expression();
0710: break;
0711: default:
0712: jj_la1[27] = jj_gen;
0713: jj_consume_token(-1);
0714: throw new ParseException();
0715: }
0716: }
0717:
0718: final public void ArrayInitializer() throws ParseException {
0719: jj_consume_token(LBRACE);
0720: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0721: case BOOLEAN:
0722: case BYTE:
0723: case CHAR:
0724: case DOUBLE:
0725: case FALSE:
0726: case FLOAT:
0727: case INT:
0728: case LONG:
0729: case NEW:
0730: case NULL:
0731: case SHORT:
0732: case SUPER:
0733: case THIS:
0734: case TRUE:
0735: case VOID:
0736: case INTEGER_LITERAL:
0737: case FLOATING_POINT_LITERAL:
0738: case CHARACTER_LITERAL:
0739: case STRING_LITERAL:
0740: case IDENTIFIER:
0741: case LPAREN:
0742: case LBRACE:
0743: case BANG:
0744: case TILDE:
0745: case INCR:
0746: case DECR:
0747: case PLUS:
0748: case MINUS:
0749: VariableInitializer();
0750: label_13: while (true) {
0751: if (jj_2_10(2)) {
0752: ;
0753: } else {
0754: break label_13;
0755: }
0756: jj_consume_token(COMMA);
0757: VariableInitializer();
0758: }
0759: break;
0760: default:
0761: jj_la1[28] = jj_gen;
0762: ;
0763: }
0764: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0765: case COMMA:
0766: jj_consume_token(COMMA);
0767: break;
0768: default:
0769: jj_la1[29] = jj_gen;
0770: ;
0771: }
0772: jj_consume_token(RBRACE);
0773: }
0774:
0775: final public void MethodDeclaration() throws ParseException {
0776: label_14: while (true) {
0777: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0778: case ABSTRACT:
0779: case FINAL:
0780: case NATIVE:
0781: case PRIVATE:
0782: case PROTECTED:
0783: case PUBLIC:
0784: case STATIC:
0785: case SYNCHRONIZED:
0786: case STRICTFP:
0787: ;
0788: break;
0789: default:
0790: jj_la1[30] = jj_gen;
0791: break label_14;
0792: }
0793: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0794: case PUBLIC:
0795: jj_consume_token(PUBLIC);
0796: break;
0797: case PROTECTED:
0798: jj_consume_token(PROTECTED);
0799: break;
0800: case PRIVATE:
0801: jj_consume_token(PRIVATE);
0802: break;
0803: case STATIC:
0804: jj_consume_token(STATIC);
0805: break;
0806: case ABSTRACT:
0807: jj_consume_token(ABSTRACT);
0808: break;
0809: case FINAL:
0810: jj_consume_token(FINAL);
0811: break;
0812: case NATIVE:
0813: jj_consume_token(NATIVE);
0814: break;
0815: case SYNCHRONIZED:
0816: jj_consume_token(SYNCHRONIZED);
0817: break;
0818: case STRICTFP:
0819: jj_consume_token(STRICTFP);
0820: break;
0821: default:
0822: jj_la1[31] = jj_gen;
0823: jj_consume_token(-1);
0824: throw new ParseException();
0825: }
0826: }
0827: ResultType();
0828: MethodDeclarator();
0829: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0830: case THROWS:
0831: jj_consume_token(THROWS);
0832: NameList();
0833: break;
0834: default:
0835: jj_la1[32] = jj_gen;
0836: ;
0837: }
0838: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0839: case LBRACE:
0840: Block();
0841: break;
0842: case SEMICOLON:
0843: jj_consume_token(SEMICOLON);
0844: break;
0845: default:
0846: jj_la1[33] = jj_gen;
0847: jj_consume_token(-1);
0848: throw new ParseException();
0849: }
0850: }
0851:
0852: final public void MethodDeclarator() throws ParseException {
0853: jj_consume_token(IDENTIFIER);
0854: FormalParameters();
0855: label_15: while (true) {
0856: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0857: case LBRACKET:
0858: ;
0859: break;
0860: default:
0861: jj_la1[34] = jj_gen;
0862: break label_15;
0863: }
0864: jj_consume_token(LBRACKET);
0865: jj_consume_token(RBRACKET);
0866: }
0867: }
0868:
0869: final public void FormalParameters() throws ParseException {
0870: jj_consume_token(LPAREN);
0871: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0872: case BOOLEAN:
0873: case BYTE:
0874: case CHAR:
0875: case DOUBLE:
0876: case FINAL:
0877: case FLOAT:
0878: case INT:
0879: case LONG:
0880: case SHORT:
0881: case IDENTIFIER:
0882: FormalParameter();
0883: label_16: while (true) {
0884: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0885: case COMMA:
0886: ;
0887: break;
0888: default:
0889: jj_la1[35] = jj_gen;
0890: break label_16;
0891: }
0892: jj_consume_token(COMMA);
0893: FormalParameter();
0894: }
0895: break;
0896: default:
0897: jj_la1[36] = jj_gen;
0898: ;
0899: }
0900: jj_consume_token(RPAREN);
0901: }
0902:
0903: final public void FormalParameter() throws ParseException {
0904: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0905: case FINAL:
0906: jj_consume_token(FINAL);
0907: break;
0908: default:
0909: jj_la1[37] = jj_gen;
0910: ;
0911: }
0912: Type();
0913: VariableDeclaratorId();
0914: }
0915:
0916: final public void ConstructorDeclaration() throws ParseException {
0917: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0918: case PRIVATE:
0919: case PROTECTED:
0920: case PUBLIC:
0921: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0922: case PUBLIC:
0923: jj_consume_token(PUBLIC);
0924: break;
0925: case PROTECTED:
0926: jj_consume_token(PROTECTED);
0927: break;
0928: case PRIVATE:
0929: jj_consume_token(PRIVATE);
0930: break;
0931: default:
0932: jj_la1[38] = jj_gen;
0933: jj_consume_token(-1);
0934: throw new ParseException();
0935: }
0936: break;
0937: default:
0938: jj_la1[39] = jj_gen;
0939: ;
0940: }
0941: jj_consume_token(IDENTIFIER);
0942: FormalParameters();
0943: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0944: case THROWS:
0945: jj_consume_token(THROWS);
0946: NameList();
0947: break;
0948: default:
0949: jj_la1[40] = jj_gen;
0950: ;
0951: }
0952: jj_consume_token(LBRACE);
0953: if (jj_2_11(2147483647)) {
0954: ExplicitConstructorInvocation();
0955: } else {
0956: ;
0957: }
0958: label_17: while (true) {
0959: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
0960: case BOOLEAN:
0961: case BREAK:
0962: case BYTE:
0963: case CHAR:
0964: case CLASS:
0965: case CONTINUE:
0966: case DO:
0967: case DOUBLE:
0968: case FALSE:
0969: case FINAL:
0970: case FLOAT:
0971: case FOR:
0972: case IF:
0973: case INT:
0974: case INTERFACE:
0975: case LONG:
0976: case NEW:
0977: case NULL:
0978: case RETURN:
0979: case SHORT:
0980: case SUPER:
0981: case SWITCH:
0982: case SYNCHRONIZED:
0983: case THIS:
0984: case THROW:
0985: case TRUE:
0986: case TRY:
0987: case VOID:
0988: case WHILE:
0989: case ASSERT:
0990: case INTEGER_LITERAL:
0991: case FLOATING_POINT_LITERAL:
0992: case CHARACTER_LITERAL:
0993: case STRING_LITERAL:
0994: case IDENTIFIER:
0995: case LPAREN:
0996: case LBRACE:
0997: case SEMICOLON:
0998: case INCR:
0999: case DECR:
1000: ;
1001: break;
1002: default:
1003: jj_la1[41] = jj_gen;
1004: break label_17;
1005: }
1006: BlockStatement();
1007: }
1008: jj_consume_token(RBRACE);
1009: }
1010:
1011: final public void ExplicitConstructorInvocation()
1012: throws ParseException {
1013: if (jj_2_13(2147483647)) {
1014: jj_consume_token(THIS);
1015: Arguments();
1016: jj_consume_token(SEMICOLON);
1017: } else {
1018: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1019: case BOOLEAN:
1020: case BYTE:
1021: case CHAR:
1022: case DOUBLE:
1023: case FALSE:
1024: case FLOAT:
1025: case INT:
1026: case LONG:
1027: case NEW:
1028: case NULL:
1029: case SHORT:
1030: case SUPER:
1031: case THIS:
1032: case TRUE:
1033: case VOID:
1034: case INTEGER_LITERAL:
1035: case FLOATING_POINT_LITERAL:
1036: case CHARACTER_LITERAL:
1037: case STRING_LITERAL:
1038: case IDENTIFIER:
1039: case LPAREN:
1040: if (jj_2_12(2)) {
1041: PrimaryExpression();
1042: jj_consume_token(DOT);
1043: } else {
1044: ;
1045: }
1046: jj_consume_token(SUPER);
1047: Arguments();
1048: jj_consume_token(SEMICOLON);
1049: break;
1050: default:
1051: jj_la1[42] = jj_gen;
1052: jj_consume_token(-1);
1053: throw new ParseException();
1054: }
1055: }
1056: }
1057:
1058: final public void Initializer() throws ParseException {
1059: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1060: case STATIC:
1061: jj_consume_token(STATIC);
1062: break;
1063: default:
1064: jj_la1[43] = jj_gen;
1065: ;
1066: }
1067: Block();
1068: }
1069:
1070: /*
1071: * Type, name and expression syntax follows.
1072: */
1073: final public void Type() throws ParseException {
1074: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1075: case BOOLEAN:
1076: case BYTE:
1077: case CHAR:
1078: case DOUBLE:
1079: case FLOAT:
1080: case INT:
1081: case LONG:
1082: case SHORT:
1083: PrimitiveType();
1084: break;
1085: case IDENTIFIER:
1086: Name();
1087: break;
1088: default:
1089: jj_la1[44] = jj_gen;
1090: jj_consume_token(-1);
1091: throw new ParseException();
1092: }
1093: label_18: while (true) {
1094: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1095: case LBRACKET:
1096: ;
1097: break;
1098: default:
1099: jj_la1[45] = jj_gen;
1100: break label_18;
1101: }
1102: jj_consume_token(LBRACKET);
1103: jj_consume_token(RBRACKET);
1104: }
1105: }
1106:
1107: final public void PrimitiveType() throws ParseException {
1108: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1109: case BOOLEAN:
1110: jj_consume_token(BOOLEAN);
1111: break;
1112: case CHAR:
1113: jj_consume_token(CHAR);
1114: break;
1115: case BYTE:
1116: jj_consume_token(BYTE);
1117: break;
1118: case SHORT:
1119: jj_consume_token(SHORT);
1120: break;
1121: case INT:
1122: jj_consume_token(INT);
1123: break;
1124: case LONG:
1125: jj_consume_token(LONG);
1126: break;
1127: case FLOAT:
1128: jj_consume_token(FLOAT);
1129: break;
1130: case DOUBLE:
1131: jj_consume_token(DOUBLE);
1132: break;
1133: default:
1134: jj_la1[46] = jj_gen;
1135: jj_consume_token(-1);
1136: throw new ParseException();
1137: }
1138: }
1139:
1140: final public void ResultType() throws ParseException {
1141: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1142: case VOID:
1143: jj_consume_token(VOID);
1144: break;
1145: case BOOLEAN:
1146: case BYTE:
1147: case CHAR:
1148: case DOUBLE:
1149: case FLOAT:
1150: case INT:
1151: case LONG:
1152: case SHORT:
1153: case IDENTIFIER:
1154: Type();
1155: break;
1156: default:
1157: jj_la1[47] = jj_gen;
1158: jj_consume_token(-1);
1159: throw new ParseException();
1160: }
1161: }
1162:
1163: final public void Name() throws ParseException {
1164: jj_consume_token(IDENTIFIER);
1165: label_19: while (true) {
1166: if (jj_2_14(2)) {
1167: ;
1168: } else {
1169: break label_19;
1170: }
1171: jj_consume_token(DOT);
1172: jj_consume_token(IDENTIFIER);
1173: }
1174: }
1175:
1176: final public void NameList() throws ParseException {
1177: Name();
1178: label_20: while (true) {
1179: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1180: case COMMA:
1181: ;
1182: break;
1183: default:
1184: jj_la1[48] = jj_gen;
1185: break label_20;
1186: }
1187: jj_consume_token(COMMA);
1188: Name();
1189: }
1190: }
1191:
1192: /*
1193: * Expression syntax follows.
1194: */
1195: final public void Expression() throws ParseException {
1196: ConditionalExpression();
1197: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1198: case ASSIGN:
1199: case PLUSASSIGN:
1200: case MINUSASSIGN:
1201: case STARASSIGN:
1202: case SLASHASSIGN:
1203: case ANDASSIGN:
1204: case ORASSIGN:
1205: case XORASSIGN:
1206: case REMASSIGN:
1207: case LSHIFTASSIGN:
1208: case RSIGNEDSHIFTASSIGN:
1209: case RUNSIGNEDSHIFTASSIGN:
1210: AssignmentOperator();
1211: Expression();
1212: break;
1213: default:
1214: jj_la1[49] = jj_gen;
1215: ;
1216: }
1217: }
1218:
1219: final public void AssignmentOperator() throws ParseException {
1220: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1221: case ASSIGN:
1222: jj_consume_token(ASSIGN);
1223: break;
1224: case STARASSIGN:
1225: jj_consume_token(STARASSIGN);
1226: break;
1227: case SLASHASSIGN:
1228: jj_consume_token(SLASHASSIGN);
1229: break;
1230: case REMASSIGN:
1231: jj_consume_token(REMASSIGN);
1232: break;
1233: case PLUSASSIGN:
1234: jj_consume_token(PLUSASSIGN);
1235: break;
1236: case MINUSASSIGN:
1237: jj_consume_token(MINUSASSIGN);
1238: break;
1239: case LSHIFTASSIGN:
1240: jj_consume_token(LSHIFTASSIGN);
1241: break;
1242: case RSIGNEDSHIFTASSIGN:
1243: jj_consume_token(RSIGNEDSHIFTASSIGN);
1244: break;
1245: case RUNSIGNEDSHIFTASSIGN:
1246: jj_consume_token(RUNSIGNEDSHIFTASSIGN);
1247: break;
1248: case ANDASSIGN:
1249: jj_consume_token(ANDASSIGN);
1250: break;
1251: case XORASSIGN:
1252: jj_consume_token(XORASSIGN);
1253: break;
1254: case ORASSIGN:
1255: jj_consume_token(ORASSIGN);
1256: break;
1257: default:
1258: jj_la1[50] = jj_gen;
1259: jj_consume_token(-1);
1260: throw new ParseException();
1261: }
1262: }
1263:
1264: final public void ConditionalExpression() throws ParseException {
1265: ConditionalOrExpression();
1266: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1267: case HOOK:
1268: jj_consume_token(HOOK);
1269: Expression();
1270: jj_consume_token(COLON);
1271: ConditionalExpression();
1272: break;
1273: default:
1274: jj_la1[51] = jj_gen;
1275: ;
1276: }
1277: }
1278:
1279: final public void ConditionalOrExpression() throws ParseException {
1280: ConditionalAndExpression();
1281: label_21: while (true) {
1282: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1283: case SC_OR:
1284: ;
1285: break;
1286: default:
1287: jj_la1[52] = jj_gen;
1288: break label_21;
1289: }
1290: jj_consume_token(SC_OR);
1291: ConditionalAndExpression();
1292: }
1293: }
1294:
1295: final public void ConditionalAndExpression() throws ParseException {
1296: InclusiveOrExpression();
1297: label_22: while (true) {
1298: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1299: case SC_AND:
1300: ;
1301: break;
1302: default:
1303: jj_la1[53] = jj_gen;
1304: break label_22;
1305: }
1306: jj_consume_token(SC_AND);
1307: InclusiveOrExpression();
1308: }
1309: }
1310:
1311: final public void InclusiveOrExpression() throws ParseException {
1312: ExclusiveOrExpression();
1313: label_23: while (true) {
1314: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1315: case BIT_OR:
1316: ;
1317: break;
1318: default:
1319: jj_la1[54] = jj_gen;
1320: break label_23;
1321: }
1322: jj_consume_token(BIT_OR);
1323: ExclusiveOrExpression();
1324: }
1325: }
1326:
1327: final public void ExclusiveOrExpression() throws ParseException {
1328: AndExpression();
1329: label_24: while (true) {
1330: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1331: case XOR:
1332: ;
1333: break;
1334: default:
1335: jj_la1[55] = jj_gen;
1336: break label_24;
1337: }
1338: jj_consume_token(XOR);
1339: AndExpression();
1340: }
1341: }
1342:
1343: final public void AndExpression() throws ParseException {
1344: EqualityExpression();
1345: label_25: while (true) {
1346: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1347: case BIT_AND:
1348: ;
1349: break;
1350: default:
1351: jj_la1[56] = jj_gen;
1352: break label_25;
1353: }
1354: jj_consume_token(BIT_AND);
1355: EqualityExpression();
1356: }
1357: }
1358:
1359: final public void EqualityExpression() throws ParseException {
1360: InstanceOfExpression();
1361: label_26: while (true) {
1362: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1363: case EQ:
1364: case NE:
1365: ;
1366: break;
1367: default:
1368: jj_la1[57] = jj_gen;
1369: break label_26;
1370: }
1371: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1372: case EQ:
1373: jj_consume_token(EQ);
1374: break;
1375: case NE:
1376: jj_consume_token(NE);
1377: break;
1378: default:
1379: jj_la1[58] = jj_gen;
1380: jj_consume_token(-1);
1381: throw new ParseException();
1382: }
1383: InstanceOfExpression();
1384: }
1385: }
1386:
1387: final public void InstanceOfExpression() throws ParseException {
1388: RelationalExpression();
1389: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1390: case INSTANCEOF:
1391: jj_consume_token(INSTANCEOF);
1392: Type();
1393: break;
1394: default:
1395: jj_la1[59] = jj_gen;
1396: ;
1397: }
1398: }
1399:
1400: final public void RelationalExpression() throws ParseException {
1401: ShiftExpression();
1402: label_27: while (true) {
1403: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1404: case GT:
1405: case LT:
1406: case LE:
1407: case GE:
1408: ;
1409: break;
1410: default:
1411: jj_la1[60] = jj_gen;
1412: break label_27;
1413: }
1414: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1415: case LT:
1416: jj_consume_token(LT);
1417: break;
1418: case GT:
1419: jj_consume_token(GT);
1420: break;
1421: case LE:
1422: jj_consume_token(LE);
1423: break;
1424: case GE:
1425: jj_consume_token(GE);
1426: break;
1427: default:
1428: jj_la1[61] = jj_gen;
1429: jj_consume_token(-1);
1430: throw new ParseException();
1431: }
1432: ShiftExpression();
1433: }
1434: }
1435:
1436: final public void ShiftExpression() throws ParseException {
1437: AdditiveExpression();
1438: label_28: while (true) {
1439: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1440: case LSHIFT:
1441: case RSIGNEDSHIFT:
1442: case RUNSIGNEDSHIFT:
1443: ;
1444: break;
1445: default:
1446: jj_la1[62] = jj_gen;
1447: break label_28;
1448: }
1449: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1450: case LSHIFT:
1451: jj_consume_token(LSHIFT);
1452: break;
1453: case RSIGNEDSHIFT:
1454: jj_consume_token(RSIGNEDSHIFT);
1455: break;
1456: case RUNSIGNEDSHIFT:
1457: jj_consume_token(RUNSIGNEDSHIFT);
1458: break;
1459: default:
1460: jj_la1[63] = jj_gen;
1461: jj_consume_token(-1);
1462: throw new ParseException();
1463: }
1464: AdditiveExpression();
1465: }
1466: }
1467:
1468: final public void AdditiveExpression() throws ParseException {
1469: MultiplicativeExpression();
1470: label_29: while (true) {
1471: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1472: case PLUS:
1473: case MINUS:
1474: ;
1475: break;
1476: default:
1477: jj_la1[64] = jj_gen;
1478: break label_29;
1479: }
1480: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1481: case PLUS:
1482: jj_consume_token(PLUS);
1483: break;
1484: case MINUS:
1485: jj_consume_token(MINUS);
1486: break;
1487: default:
1488: jj_la1[65] = jj_gen;
1489: jj_consume_token(-1);
1490: throw new ParseException();
1491: }
1492: MultiplicativeExpression();
1493: }
1494: }
1495:
1496: final public void MultiplicativeExpression() throws ParseException {
1497: UnaryExpression();
1498: label_30: while (true) {
1499: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1500: case STAR:
1501: case SLASH:
1502: case REM:
1503: ;
1504: break;
1505: default:
1506: jj_la1[66] = jj_gen;
1507: break label_30;
1508: }
1509: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1510: case STAR:
1511: jj_consume_token(STAR);
1512: break;
1513: case SLASH:
1514: jj_consume_token(SLASH);
1515: break;
1516: case REM:
1517: jj_consume_token(REM);
1518: break;
1519: default:
1520: jj_la1[67] = jj_gen;
1521: jj_consume_token(-1);
1522: throw new ParseException();
1523: }
1524: UnaryExpression();
1525: }
1526: }
1527:
1528: final public void UnaryExpression() throws ParseException {
1529: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1530: case PLUS:
1531: case MINUS:
1532: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1533: case PLUS:
1534: jj_consume_token(PLUS);
1535: break;
1536: case MINUS:
1537: jj_consume_token(MINUS);
1538: break;
1539: default:
1540: jj_la1[68] = jj_gen;
1541: jj_consume_token(-1);
1542: throw new ParseException();
1543: }
1544: UnaryExpression();
1545: break;
1546: case INCR:
1547: PreIncrementExpression();
1548: break;
1549: case DECR:
1550: PreDecrementExpression();
1551: break;
1552: case BOOLEAN:
1553: case BYTE:
1554: case CHAR:
1555: case DOUBLE:
1556: case FALSE:
1557: case FLOAT:
1558: case INT:
1559: case LONG:
1560: case NEW:
1561: case NULL:
1562: case SHORT:
1563: case SUPER:
1564: case THIS:
1565: case TRUE:
1566: case VOID:
1567: case INTEGER_LITERAL:
1568: case FLOATING_POINT_LITERAL:
1569: case CHARACTER_LITERAL:
1570: case STRING_LITERAL:
1571: case IDENTIFIER:
1572: case LPAREN:
1573: case BANG:
1574: case TILDE:
1575: UnaryExpressionNotPlusMinus();
1576: break;
1577: default:
1578: jj_la1[69] = jj_gen;
1579: jj_consume_token(-1);
1580: throw new ParseException();
1581: }
1582: }
1583:
1584: final public void PreIncrementExpression() throws ParseException {
1585: jj_consume_token(INCR);
1586: PrimaryExpression();
1587: }
1588:
1589: final public void PreDecrementExpression() throws ParseException {
1590: jj_consume_token(DECR);
1591: PrimaryExpression();
1592: }
1593:
1594: final public void UnaryExpressionNotPlusMinus()
1595: throws ParseException {
1596: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1597: case BANG:
1598: case TILDE:
1599: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1600: case TILDE:
1601: jj_consume_token(TILDE);
1602: break;
1603: case BANG:
1604: jj_consume_token(BANG);
1605: break;
1606: default:
1607: jj_la1[70] = jj_gen;
1608: jj_consume_token(-1);
1609: throw new ParseException();
1610: }
1611: UnaryExpression();
1612: break;
1613: default:
1614: jj_la1[71] = jj_gen;
1615: if (jj_2_15(2147483647)) {
1616: CastExpression();
1617: } else {
1618: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1619: case BOOLEAN:
1620: case BYTE:
1621: case CHAR:
1622: case DOUBLE:
1623: case FALSE:
1624: case FLOAT:
1625: case INT:
1626: case LONG:
1627: case NEW:
1628: case NULL:
1629: case SHORT:
1630: case SUPER:
1631: case THIS:
1632: case TRUE:
1633: case VOID:
1634: case INTEGER_LITERAL:
1635: case FLOATING_POINT_LITERAL:
1636: case CHARACTER_LITERAL:
1637: case STRING_LITERAL:
1638: case IDENTIFIER:
1639: case LPAREN:
1640: PostfixExpression();
1641: break;
1642: default:
1643: jj_la1[72] = jj_gen;
1644: jj_consume_token(-1);
1645: throw new ParseException();
1646: }
1647: }
1648: }
1649: }
1650:
1651: // This production is to determine lookahead only. The LOOKAHEAD specifications
1652: // below are not used, but they are there just to indicate that we know about
1653: // this.
1654: final public void CastLookahead() throws ParseException {
1655: if (jj_2_16(2)) {
1656: jj_consume_token(LPAREN);
1657: PrimitiveType();
1658: } else if (jj_2_17(2147483647)) {
1659: jj_consume_token(LPAREN);
1660: Name();
1661: jj_consume_token(LBRACKET);
1662: jj_consume_token(RBRACKET);
1663: } else {
1664: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1665: case LPAREN:
1666: jj_consume_token(LPAREN);
1667: Name();
1668: jj_consume_token(RPAREN);
1669: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1670: case TILDE:
1671: jj_consume_token(TILDE);
1672: break;
1673: case BANG:
1674: jj_consume_token(BANG);
1675: break;
1676: case LPAREN:
1677: jj_consume_token(LPAREN);
1678: break;
1679: case IDENTIFIER:
1680: jj_consume_token(IDENTIFIER);
1681: break;
1682: case THIS:
1683: jj_consume_token(THIS);
1684: break;
1685: case SUPER:
1686: jj_consume_token(SUPER);
1687: break;
1688: case NEW:
1689: jj_consume_token(NEW);
1690: break;
1691: case FALSE:
1692: case NULL:
1693: case TRUE:
1694: case INTEGER_LITERAL:
1695: case FLOATING_POINT_LITERAL:
1696: case CHARACTER_LITERAL:
1697: case STRING_LITERAL:
1698: Literal();
1699: break;
1700: default:
1701: jj_la1[73] = jj_gen;
1702: jj_consume_token(-1);
1703: throw new ParseException();
1704: }
1705: break;
1706: default:
1707: jj_la1[74] = jj_gen;
1708: jj_consume_token(-1);
1709: throw new ParseException();
1710: }
1711: }
1712: }
1713:
1714: final public void PostfixExpression() throws ParseException {
1715: PrimaryExpression();
1716: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1717: case INCR:
1718: case DECR:
1719: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1720: case INCR:
1721: jj_consume_token(INCR);
1722: break;
1723: case DECR:
1724: jj_consume_token(DECR);
1725: break;
1726: default:
1727: jj_la1[75] = jj_gen;
1728: jj_consume_token(-1);
1729: throw new ParseException();
1730: }
1731: break;
1732: default:
1733: jj_la1[76] = jj_gen;
1734: ;
1735: }
1736: }
1737:
1738: final public void CastExpression() throws ParseException {
1739: if (jj_2_18(2147483647)) {
1740: jj_consume_token(LPAREN);
1741: Type();
1742: jj_consume_token(RPAREN);
1743: UnaryExpression();
1744: } else {
1745: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1746: case LPAREN:
1747: jj_consume_token(LPAREN);
1748: Type();
1749: jj_consume_token(RPAREN);
1750: UnaryExpressionNotPlusMinus();
1751: break;
1752: default:
1753: jj_la1[77] = jj_gen;
1754: jj_consume_token(-1);
1755: throw new ParseException();
1756: }
1757: }
1758: }
1759:
1760: final public void PrimaryExpression() throws ParseException {
1761: PrimaryPrefix();
1762: label_31: while (true) {
1763: if (jj_2_19(2)) {
1764: ;
1765: } else {
1766: break label_31;
1767: }
1768: PrimarySuffix();
1769: }
1770: }
1771:
1772: final public void PrimaryPrefix() throws ParseException {
1773: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1774: case FALSE:
1775: case NULL:
1776: case TRUE:
1777: case INTEGER_LITERAL:
1778: case FLOATING_POINT_LITERAL:
1779: case CHARACTER_LITERAL:
1780: case STRING_LITERAL:
1781: Literal();
1782: break;
1783: case THIS:
1784: jj_consume_token(THIS);
1785: break;
1786: case SUPER:
1787: jj_consume_token(SUPER);
1788: jj_consume_token(DOT);
1789: jj_consume_token(IDENTIFIER);
1790: break;
1791: case LPAREN:
1792: jj_consume_token(LPAREN);
1793: Expression();
1794: jj_consume_token(RPAREN);
1795: break;
1796: case NEW:
1797: AllocationExpression();
1798: break;
1799: default:
1800: jj_la1[78] = jj_gen;
1801: if (jj_2_20(2147483647)) {
1802: ResultType();
1803: jj_consume_token(DOT);
1804: jj_consume_token(CLASS);
1805: } else {
1806: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1807: case IDENTIFIER:
1808: Name();
1809: break;
1810: default:
1811: jj_la1[79] = jj_gen;
1812: jj_consume_token(-1);
1813: throw new ParseException();
1814: }
1815: }
1816: }
1817: }
1818:
1819: /* Add "." "super" to be compatible with Java 1.2,
1820: * Modified by Marco Savard
1821: */
1822: final public void PrimarySuffix() throws ParseException {
1823: if (jj_2_21(2)) {
1824: jj_consume_token(DOT);
1825: jj_consume_token(THIS);
1826: } else if (jj_2_22(2)) {
1827: jj_consume_token(DOT);
1828: jj_consume_token(SUPER);
1829: } else if (jj_2_23(2)) {
1830: jj_consume_token(DOT);
1831: AllocationExpression();
1832: } else {
1833: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1834: case LBRACKET:
1835: jj_consume_token(LBRACKET);
1836: Expression();
1837: jj_consume_token(RBRACKET);
1838: break;
1839: case DOT:
1840: jj_consume_token(DOT);
1841: jj_consume_token(IDENTIFIER);
1842: break;
1843: case LPAREN:
1844: Arguments();
1845: break;
1846: default:
1847: jj_la1[80] = jj_gen;
1848: jj_consume_token(-1);
1849: throw new ParseException();
1850: }
1851: }
1852: }
1853:
1854: final public void Literal() throws ParseException {
1855: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1856: case INTEGER_LITERAL:
1857: jj_consume_token(INTEGER_LITERAL);
1858: break;
1859: case FLOATING_POINT_LITERAL:
1860: jj_consume_token(FLOATING_POINT_LITERAL);
1861: break;
1862: case CHARACTER_LITERAL:
1863: jj_consume_token(CHARACTER_LITERAL);
1864: break;
1865: case STRING_LITERAL:
1866: jj_consume_token(STRING_LITERAL);
1867: break;
1868: case FALSE:
1869: case TRUE:
1870: BooleanLiteral();
1871: break;
1872: case NULL:
1873: NullLiteral();
1874: break;
1875: default:
1876: jj_la1[81] = jj_gen;
1877: jj_consume_token(-1);
1878: throw new ParseException();
1879: }
1880: }
1881:
1882: final public void BooleanLiteral() throws ParseException {
1883: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1884: case TRUE:
1885: jj_consume_token(TRUE);
1886: break;
1887: case FALSE:
1888: jj_consume_token(FALSE);
1889: break;
1890: default:
1891: jj_la1[82] = jj_gen;
1892: jj_consume_token(-1);
1893: throw new ParseException();
1894: }
1895: }
1896:
1897: final public void NullLiteral() throws ParseException {
1898: jj_consume_token(NULL);
1899: }
1900:
1901: final public void Arguments() throws ParseException {
1902: jj_consume_token(LPAREN);
1903: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1904: case BOOLEAN:
1905: case BYTE:
1906: case CHAR:
1907: case DOUBLE:
1908: case FALSE:
1909: case FLOAT:
1910: case INT:
1911: case LONG:
1912: case NEW:
1913: case NULL:
1914: case SHORT:
1915: case SUPER:
1916: case THIS:
1917: case TRUE:
1918: case VOID:
1919: case INTEGER_LITERAL:
1920: case FLOATING_POINT_LITERAL:
1921: case CHARACTER_LITERAL:
1922: case STRING_LITERAL:
1923: case IDENTIFIER:
1924: case LPAREN:
1925: case BANG:
1926: case TILDE:
1927: case INCR:
1928: case DECR:
1929: case PLUS:
1930: case MINUS:
1931: ArgumentList();
1932: break;
1933: default:
1934: jj_la1[83] = jj_gen;
1935: ;
1936: }
1937: jj_consume_token(RPAREN);
1938: }
1939:
1940: final public void ArgumentList() throws ParseException {
1941: Expression();
1942: label_32: while (true) {
1943: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1944: case COMMA:
1945: ;
1946: break;
1947: default:
1948: jj_la1[84] = jj_gen;
1949: break label_32;
1950: }
1951: jj_consume_token(COMMA);
1952: Expression();
1953: }
1954: }
1955:
1956: final public void AllocationExpression() throws ParseException {
1957: if (jj_2_24(2)) {
1958: jj_consume_token(NEW);
1959: PrimitiveType();
1960: ArrayDimsAndInits();
1961: } else {
1962: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1963: case NEW:
1964: jj_consume_token(NEW);
1965: Name();
1966: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1967: case LBRACKET:
1968: ArrayDimsAndInits();
1969: break;
1970: case LPAREN:
1971: Arguments();
1972: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
1973: case LBRACE:
1974: ClassBody();
1975: break;
1976: default:
1977: jj_la1[85] = jj_gen;
1978: ;
1979: }
1980: break;
1981: default:
1982: jj_la1[86] = jj_gen;
1983: jj_consume_token(-1);
1984: throw new ParseException();
1985: }
1986: break;
1987: default:
1988: jj_la1[87] = jj_gen;
1989: jj_consume_token(-1);
1990: throw new ParseException();
1991: }
1992: }
1993: }
1994:
1995: /*
1996: * The second LOOKAHEAD specification below is to parse to PrimarySuffix
1997: * if there is an expression between the "[...]".
1998: */
1999: final public void ArrayDimsAndInits() throws ParseException {
2000: if (jj_2_27(2)) {
2001: label_33: while (true) {
2002: jj_consume_token(LBRACKET);
2003: Expression();
2004: jj_consume_token(RBRACKET);
2005: if (jj_2_25(2)) {
2006: ;
2007: } else {
2008: break label_33;
2009: }
2010: }
2011: label_34: while (true) {
2012: if (jj_2_26(2)) {
2013: ;
2014: } else {
2015: break label_34;
2016: }
2017: jj_consume_token(LBRACKET);
2018: jj_consume_token(RBRACKET);
2019: }
2020: } else {
2021: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2022: case LBRACKET:
2023: label_35: while (true) {
2024: jj_consume_token(LBRACKET);
2025: jj_consume_token(RBRACKET);
2026: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2027: case LBRACKET:
2028: ;
2029: break;
2030: default:
2031: jj_la1[88] = jj_gen;
2032: break label_35;
2033: }
2034: }
2035: ArrayInitializer();
2036: break;
2037: default:
2038: jj_la1[89] = jj_gen;
2039: jj_consume_token(-1);
2040: throw new ParseException();
2041: }
2042: }
2043: }
2044:
2045: /*
2046: * Statement syntax follows.
2047: */
2048: final public void Statement() throws ParseException {
2049: if (jj_2_28(2)) {
2050: LabeledStatement();
2051: } else {
2052: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2053: case LBRACE:
2054: Block();
2055: break;
2056: case SEMICOLON:
2057: EmptyStatement();
2058: break;
2059: case BOOLEAN:
2060: case BYTE:
2061: case CHAR:
2062: case DOUBLE:
2063: case FALSE:
2064: case FLOAT:
2065: case INT:
2066: case LONG:
2067: case NEW:
2068: case NULL:
2069: case SHORT:
2070: case SUPER:
2071: case THIS:
2072: case TRUE:
2073: case VOID:
2074: case INTEGER_LITERAL:
2075: case FLOATING_POINT_LITERAL:
2076: case CHARACTER_LITERAL:
2077: case STRING_LITERAL:
2078: case IDENTIFIER:
2079: case LPAREN:
2080: case INCR:
2081: case DECR:
2082: StatementExpression();
2083: jj_consume_token(SEMICOLON);
2084: break;
2085: case SWITCH:
2086: SwitchStatement();
2087: break;
2088: case IF:
2089: IfStatement();
2090: break;
2091: case WHILE:
2092: WhileStatement();
2093: break;
2094: case DO:
2095: DoStatement();
2096: break;
2097: case FOR:
2098: ForStatement();
2099: break;
2100: case BREAK:
2101: BreakStatement();
2102: break;
2103: case CONTINUE:
2104: ContinueStatement();
2105: break;
2106: case RETURN:
2107: ReturnStatement();
2108: break;
2109: case THROW:
2110: ThrowStatement();
2111: break;
2112: case SYNCHRONIZED:
2113: SynchronizedStatement();
2114: break;
2115: case TRY:
2116: TryStatement();
2117: break;
2118: case ASSERT:
2119: AssertStatement();
2120: break;
2121: default:
2122: jj_la1[90] = jj_gen;
2123: jj_consume_token(-1);
2124: throw new ParseException();
2125: }
2126: }
2127: }
2128:
2129: final public void LabeledStatement() throws ParseException {
2130: jj_consume_token(IDENTIFIER);
2131: jj_consume_token(COLON);
2132: Statement();
2133: }
2134:
2135: final public void Block() throws ParseException {
2136: jj_consume_token(LBRACE);
2137: label_36: while (true) {
2138: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2139: case BOOLEAN:
2140: case BREAK:
2141: case BYTE:
2142: case CHAR:
2143: case CLASS:
2144: case CONTINUE:
2145: case DO:
2146: case DOUBLE:
2147: case FALSE:
2148: case FINAL:
2149: case FLOAT:
2150: case FOR:
2151: case IF:
2152: case INT:
2153: case INTERFACE:
2154: case LONG:
2155: case NEW:
2156: case NULL:
2157: case RETURN:
2158: case SHORT:
2159: case SUPER:
2160: case SWITCH:
2161: case SYNCHRONIZED:
2162: case THIS:
2163: case THROW:
2164: case TRUE:
2165: case TRY:
2166: case VOID:
2167: case WHILE:
2168: case ASSERT:
2169: case INTEGER_LITERAL:
2170: case FLOATING_POINT_LITERAL:
2171: case CHARACTER_LITERAL:
2172: case STRING_LITERAL:
2173: case IDENTIFIER:
2174: case LPAREN:
2175: case LBRACE:
2176: case SEMICOLON:
2177: case INCR:
2178: case DECR:
2179: ;
2180: break;
2181: default:
2182: jj_la1[91] = jj_gen;
2183: break label_36;
2184: }
2185: BlockStatement();
2186: }
2187: jj_consume_token(RBRACE);
2188: }
2189:
2190: final public void BlockStatement() throws ParseException {
2191: if (jj_2_29(2147483647)) {
2192: LocalVariableDeclaration();
2193: jj_consume_token(SEMICOLON);
2194: } else {
2195: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2196: case BOOLEAN:
2197: case BREAK:
2198: case BYTE:
2199: case CHAR:
2200: case CONTINUE:
2201: case DO:
2202: case DOUBLE:
2203: case FALSE:
2204: case FLOAT:
2205: case FOR:
2206: case IF:
2207: case INT:
2208: case LONG:
2209: case NEW:
2210: case NULL:
2211: case RETURN:
2212: case SHORT:
2213: case SUPER:
2214: case SWITCH:
2215: case SYNCHRONIZED:
2216: case THIS:
2217: case THROW:
2218: case TRUE:
2219: case TRY:
2220: case VOID:
2221: case WHILE:
2222: case ASSERT:
2223: case INTEGER_LITERAL:
2224: case FLOATING_POINT_LITERAL:
2225: case CHARACTER_LITERAL:
2226: case STRING_LITERAL:
2227: case IDENTIFIER:
2228: case LPAREN:
2229: case LBRACE:
2230: case SEMICOLON:
2231: case INCR:
2232: case DECR:
2233: Statement();
2234: break;
2235: case CLASS:
2236: UnmodifiedClassDeclaration();
2237: break;
2238: case INTERFACE:
2239: UnmodifiedInterfaceDeclaration();
2240: break;
2241: default:
2242: jj_la1[92] = jj_gen;
2243: jj_consume_token(-1);
2244: throw new ParseException();
2245: }
2246: }
2247: }
2248:
2249: final public void LocalVariableDeclaration() throws ParseException {
2250: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2251: case FINAL:
2252: jj_consume_token(FINAL);
2253: break;
2254: default:
2255: jj_la1[93] = jj_gen;
2256: ;
2257: }
2258: Type();
2259: VariableDeclarator();
2260: label_37: while (true) {
2261: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2262: case COMMA:
2263: ;
2264: break;
2265: default:
2266: jj_la1[94] = jj_gen;
2267: break label_37;
2268: }
2269: jj_consume_token(COMMA);
2270: VariableDeclarator();
2271: }
2272: }
2273:
2274: final public void EmptyStatement() throws ParseException {
2275: jj_consume_token(SEMICOLON);
2276: }
2277:
2278: final public void StatementExpression() throws ParseException {
2279: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2280: case INCR:
2281: PreIncrementExpression();
2282: break;
2283: case DECR:
2284: PreDecrementExpression();
2285: break;
2286: case BOOLEAN:
2287: case BYTE:
2288: case CHAR:
2289: case DOUBLE:
2290: case FALSE:
2291: case FLOAT:
2292: case INT:
2293: case LONG:
2294: case NEW:
2295: case NULL:
2296: case SHORT:
2297: case SUPER:
2298: case THIS:
2299: case TRUE:
2300: case VOID:
2301: case INTEGER_LITERAL:
2302: case FLOATING_POINT_LITERAL:
2303: case CHARACTER_LITERAL:
2304: case STRING_LITERAL:
2305: case IDENTIFIER:
2306: case LPAREN:
2307: PrimaryExpression();
2308: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2309: case ASSIGN:
2310: case INCR:
2311: case DECR:
2312: case PLUSASSIGN:
2313: case MINUSASSIGN:
2314: case STARASSIGN:
2315: case SLASHASSIGN:
2316: case ANDASSIGN:
2317: case ORASSIGN:
2318: case XORASSIGN:
2319: case REMASSIGN:
2320: case LSHIFTASSIGN:
2321: case RSIGNEDSHIFTASSIGN:
2322: case RUNSIGNEDSHIFTASSIGN:
2323: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2324: case INCR:
2325: jj_consume_token(INCR);
2326: break;
2327: case DECR:
2328: jj_consume_token(DECR);
2329: break;
2330: case ASSIGN:
2331: case PLUSASSIGN:
2332: case MINUSASSIGN:
2333: case STARASSIGN:
2334: case SLASHASSIGN:
2335: case ANDASSIGN:
2336: case ORASSIGN:
2337: case XORASSIGN:
2338: case REMASSIGN:
2339: case LSHIFTASSIGN:
2340: case RSIGNEDSHIFTASSIGN:
2341: case RUNSIGNEDSHIFTASSIGN:
2342: AssignmentOperator();
2343: Expression();
2344: break;
2345: default:
2346: jj_la1[95] = jj_gen;
2347: jj_consume_token(-1);
2348: throw new ParseException();
2349: }
2350: break;
2351: default:
2352: jj_la1[96] = jj_gen;
2353: ;
2354: }
2355: break;
2356: default:
2357: jj_la1[97] = jj_gen;
2358: jj_consume_token(-1);
2359: throw new ParseException();
2360: }
2361: }
2362:
2363: final public void SwitchStatement() throws ParseException {
2364: jj_consume_token(SWITCH);
2365: jj_consume_token(LPAREN);
2366: Expression();
2367: jj_consume_token(RPAREN);
2368: jj_consume_token(LBRACE);
2369: label_38: while (true) {
2370: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2371: case CASE:
2372: case _DEFAULT:
2373: ;
2374: break;
2375: default:
2376: jj_la1[98] = jj_gen;
2377: break label_38;
2378: }
2379: SwitchLabel();
2380: label_39: while (true) {
2381: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2382: case BOOLEAN:
2383: case BREAK:
2384: case BYTE:
2385: case CHAR:
2386: case CLASS:
2387: case CONTINUE:
2388: case DO:
2389: case DOUBLE:
2390: case FALSE:
2391: case FINAL:
2392: case FLOAT:
2393: case FOR:
2394: case IF:
2395: case INT:
2396: case INTERFACE:
2397: case LONG:
2398: case NEW:
2399: case NULL:
2400: case RETURN:
2401: case SHORT:
2402: case SUPER:
2403: case SWITCH:
2404: case SYNCHRONIZED:
2405: case THIS:
2406: case THROW:
2407: case TRUE:
2408: case TRY:
2409: case VOID:
2410: case WHILE:
2411: case ASSERT:
2412: case INTEGER_LITERAL:
2413: case FLOATING_POINT_LITERAL:
2414: case CHARACTER_LITERAL:
2415: case STRING_LITERAL:
2416: case IDENTIFIER:
2417: case LPAREN:
2418: case LBRACE:
2419: case SEMICOLON:
2420: case INCR:
2421: case DECR:
2422: ;
2423: break;
2424: default:
2425: jj_la1[99] = jj_gen;
2426: break label_39;
2427: }
2428: BlockStatement();
2429: }
2430: }
2431: jj_consume_token(RBRACE);
2432: }
2433:
2434: final public void SwitchLabel() throws ParseException {
2435: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2436: case CASE:
2437: jj_consume_token(CASE);
2438: Expression();
2439: jj_consume_token(COLON);
2440: break;
2441: case _DEFAULT:
2442: jj_consume_token(_DEFAULT);
2443: jj_consume_token(COLON);
2444: break;
2445: default:
2446: jj_la1[100] = jj_gen;
2447: jj_consume_token(-1);
2448: throw new ParseException();
2449: }
2450: }
2451:
2452: final public void IfStatement() throws ParseException {
2453: jj_consume_token(IF);
2454: jj_consume_token(LPAREN);
2455: Expression();
2456: jj_consume_token(RPAREN);
2457: Statement();
2458: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2459: case ELSE:
2460: jj_consume_token(ELSE);
2461: Statement();
2462: break;
2463: default:
2464: jj_la1[101] = jj_gen;
2465: ;
2466: }
2467: }
2468:
2469: final public void WhileStatement() throws ParseException {
2470: jj_consume_token(WHILE);
2471: jj_consume_token(LPAREN);
2472: Expression();
2473: jj_consume_token(RPAREN);
2474: Statement();
2475: }
2476:
2477: final public void DoStatement() throws ParseException {
2478: jj_consume_token(DO);
2479: Statement();
2480: jj_consume_token(WHILE);
2481: jj_consume_token(LPAREN);
2482: Expression();
2483: jj_consume_token(RPAREN);
2484: jj_consume_token(SEMICOLON);
2485: }
2486:
2487: final public void ForStatement() throws ParseException {
2488: jj_consume_token(FOR);
2489: jj_consume_token(LPAREN);
2490: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2491: case BOOLEAN:
2492: case BYTE:
2493: case CHAR:
2494: case DOUBLE:
2495: case FALSE:
2496: case FINAL:
2497: case FLOAT:
2498: case INT:
2499: case LONG:
2500: case NEW:
2501: case NULL:
2502: case SHORT:
2503: case SUPER:
2504: case THIS:
2505: case TRUE:
2506: case VOID:
2507: case INTEGER_LITERAL:
2508: case FLOATING_POINT_LITERAL:
2509: case CHARACTER_LITERAL:
2510: case STRING_LITERAL:
2511: case IDENTIFIER:
2512: case LPAREN:
2513: case INCR:
2514: case DECR:
2515: ForInit();
2516: break;
2517: default:
2518: jj_la1[102] = jj_gen;
2519: ;
2520: }
2521: jj_consume_token(SEMICOLON);
2522: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2523: case BOOLEAN:
2524: case BYTE:
2525: case CHAR:
2526: case DOUBLE:
2527: case FALSE:
2528: case FLOAT:
2529: case INT:
2530: case LONG:
2531: case NEW:
2532: case NULL:
2533: case SHORT:
2534: case SUPER:
2535: case THIS:
2536: case TRUE:
2537: case VOID:
2538: case INTEGER_LITERAL:
2539: case FLOATING_POINT_LITERAL:
2540: case CHARACTER_LITERAL:
2541: case STRING_LITERAL:
2542: case IDENTIFIER:
2543: case LPAREN:
2544: case BANG:
2545: case TILDE:
2546: case INCR:
2547: case DECR:
2548: case PLUS:
2549: case MINUS:
2550: Expression();
2551: break;
2552: default:
2553: jj_la1[103] = jj_gen;
2554: ;
2555: }
2556: jj_consume_token(SEMICOLON);
2557: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2558: case BOOLEAN:
2559: case BYTE:
2560: case CHAR:
2561: case DOUBLE:
2562: case FALSE:
2563: case FLOAT:
2564: case INT:
2565: case LONG:
2566: case NEW:
2567: case NULL:
2568: case SHORT:
2569: case SUPER:
2570: case THIS:
2571: case TRUE:
2572: case VOID:
2573: case INTEGER_LITERAL:
2574: case FLOATING_POINT_LITERAL:
2575: case CHARACTER_LITERAL:
2576: case STRING_LITERAL:
2577: case IDENTIFIER:
2578: case LPAREN:
2579: case INCR:
2580: case DECR:
2581: ForUpdate();
2582: break;
2583: default:
2584: jj_la1[104] = jj_gen;
2585: ;
2586: }
2587: jj_consume_token(RPAREN);
2588: Statement();
2589: }
2590:
2591: final public void ForInit() throws ParseException {
2592: if (jj_2_30(2147483647)) {
2593: LocalVariableDeclaration();
2594: } else {
2595: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2596: case BOOLEAN:
2597: case BYTE:
2598: case CHAR:
2599: case DOUBLE:
2600: case FALSE:
2601: case FLOAT:
2602: case INT:
2603: case LONG:
2604: case NEW:
2605: case NULL:
2606: case SHORT:
2607: case SUPER:
2608: case THIS:
2609: case TRUE:
2610: case VOID:
2611: case INTEGER_LITERAL:
2612: case FLOATING_POINT_LITERAL:
2613: case CHARACTER_LITERAL:
2614: case STRING_LITERAL:
2615: case IDENTIFIER:
2616: case LPAREN:
2617: case INCR:
2618: case DECR:
2619: StatementExpressionList();
2620: break;
2621: default:
2622: jj_la1[105] = jj_gen;
2623: jj_consume_token(-1);
2624: throw new ParseException();
2625: }
2626: }
2627: }
2628:
2629: final public void StatementExpressionList() throws ParseException {
2630: StatementExpression();
2631: label_40: while (true) {
2632: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2633: case COMMA:
2634: ;
2635: break;
2636: default:
2637: jj_la1[106] = jj_gen;
2638: break label_40;
2639: }
2640: jj_consume_token(COMMA);
2641: StatementExpression();
2642: }
2643: }
2644:
2645: final public void ForUpdate() throws ParseException {
2646: StatementExpressionList();
2647: }
2648:
2649: final public void BreakStatement() throws ParseException {
2650: jj_consume_token(BREAK);
2651: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2652: case IDENTIFIER:
2653: jj_consume_token(IDENTIFIER);
2654: break;
2655: default:
2656: jj_la1[107] = jj_gen;
2657: ;
2658: }
2659: jj_consume_token(SEMICOLON);
2660: }
2661:
2662: final public void ContinueStatement() throws ParseException {
2663: jj_consume_token(CONTINUE);
2664: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2665: case IDENTIFIER:
2666: jj_consume_token(IDENTIFIER);
2667: break;
2668: default:
2669: jj_la1[108] = jj_gen;
2670: ;
2671: }
2672: jj_consume_token(SEMICOLON);
2673: }
2674:
2675: final public void ReturnStatement() throws ParseException {
2676: jj_consume_token(RETURN);
2677: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2678: case BOOLEAN:
2679: case BYTE:
2680: case CHAR:
2681: case DOUBLE:
2682: case FALSE:
2683: case FLOAT:
2684: case INT:
2685: case LONG:
2686: case NEW:
2687: case NULL:
2688: case SHORT:
2689: case SUPER:
2690: case THIS:
2691: case TRUE:
2692: case VOID:
2693: case INTEGER_LITERAL:
2694: case FLOATING_POINT_LITERAL:
2695: case CHARACTER_LITERAL:
2696: case STRING_LITERAL:
2697: case IDENTIFIER:
2698: case LPAREN:
2699: case BANG:
2700: case TILDE:
2701: case INCR:
2702: case DECR:
2703: case PLUS:
2704: case MINUS:
2705: Expression();
2706: break;
2707: default:
2708: jj_la1[109] = jj_gen;
2709: ;
2710: }
2711: jj_consume_token(SEMICOLON);
2712: }
2713:
2714: final public void ThrowStatement() throws ParseException {
2715: jj_consume_token(THROW);
2716: Expression();
2717: jj_consume_token(SEMICOLON);
2718: }
2719:
2720: final public void SynchronizedStatement() throws ParseException {
2721: jj_consume_token(SYNCHRONIZED);
2722: jj_consume_token(LPAREN);
2723: Expression();
2724: jj_consume_token(RPAREN);
2725: Block();
2726: }
2727:
2728: final public void TryStatement() throws ParseException {
2729: jj_consume_token(TRY);
2730: Block();
2731: label_41: while (true) {
2732: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2733: case CATCH:
2734: ;
2735: break;
2736: default:
2737: jj_la1[110] = jj_gen;
2738: break label_41;
2739: }
2740: jj_consume_token(CATCH);
2741: jj_consume_token(LPAREN);
2742: FormalParameter();
2743: jj_consume_token(RPAREN);
2744: Block();
2745: }
2746: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2747: case FINALLY:
2748: jj_consume_token(FINALLY);
2749: Block();
2750: break;
2751: default:
2752: jj_la1[111] = jj_gen;
2753: ;
2754: }
2755: }
2756:
2757: // added by Andrea Gini
2758: final public void AssertStatement() throws ParseException {
2759: jj_consume_token(ASSERT);
2760: Expression();
2761: switch ((jj_ntk == -1) ? jj_ntk() : jj_ntk) {
2762: case COLON:
2763: jj_consume_token(COLON);
2764: Expression();
2765: break;
2766: default:
2767: jj_la1[112] = jj_gen;
2768: ;
2769: }
2770: jj_consume_token(SEMICOLON);
2771: }
2772:
2773: final private boolean jj_2_1(int xla) {
2774: jj_la = xla;
2775: jj_lastpos = jj_scanpos = token;
2776: try {
2777: return !jj_3_1();
2778: } catch (LookaheadSuccess ls) {
2779: return true;
2780: } finally {
2781: jj_save(0, xla);
2782: }
2783: }
2784:
2785: final private boolean jj_2_2(int xla) {
2786: jj_la = xla;
2787: jj_lastpos = jj_scanpos = token;
2788: try {
2789: return !jj_3_2();
2790: } catch (LookaheadSuccess ls) {
2791: return true;
2792: } finally {
2793: jj_save(1, xla);
2794: }
2795: }
2796:
2797: final private boolean jj_2_3(int xla) {
2798: jj_la = xla;
2799: jj_lastpos = jj_scanpos = token;
2800: try {
2801: return !jj_3_3();
2802: } catch (LookaheadSuccess ls) {
2803: return true;
2804: } finally {
2805: jj_save(2, xla);
2806: }
2807: }
2808:
2809: final private boolean jj_2_4(int xla) {
2810: jj_la = xla;
2811: jj_lastpos = jj_scanpos = token;
2812: try {
2813: return !jj_3_4();
2814: } catch (LookaheadSuccess ls) {
2815: return true;
2816: } finally {
2817: jj_save(3, xla);
2818: }
2819: }
2820:
2821: final private boolean jj_2_5(int xla) {
2822: jj_la = xla;
2823: jj_lastpos = jj_scanpos = token;
2824: try {
2825: return !jj_3_5();
2826: } catch (LookaheadSuccess ls) {
2827: return true;
2828: } finally {
2829: jj_save(4, xla);
2830: }
2831: }
2832:
2833: final private boolean jj_2_6(int xla) {
2834: jj_la = xla;
2835: jj_lastpos = jj_scanpos = token;
2836: try {
2837: return !jj_3_6();
2838: } catch (LookaheadSuccess ls) {
2839: return true;
2840: } finally {
2841: jj_save(5, xla);
2842: }
2843: }
2844:
2845: final private boolean jj_2_7(int xla) {
2846: jj_la = xla;
2847: jj_lastpos = jj_scanpos = token;
2848: try {
2849: return !jj_3_7();
2850: } catch (LookaheadSuccess ls) {
2851: return true;
2852: } finally {
2853: jj_save(6, xla);
2854: }
2855: }
2856:
2857: final private boolean jj_2_8(int xla) {
2858: jj_la = xla;
2859: jj_lastpos = jj_scanpos = token;
2860: try {
2861: return !jj_3_8();
2862: } catch (LookaheadSuccess ls) {
2863: return true;
2864: } finally {
2865: jj_save(7, xla);
2866: }
2867: }
2868:
2869: final private boolean jj_2_9(int xla) {
2870: jj_la = xla;
2871: jj_lastpos = jj_scanpos = token;
2872: try {
2873: return !jj_3_9();
2874: } catch (LookaheadSuccess ls) {
2875: return true;
2876: } finally {
2877: jj_save(8, xla);
2878: }
2879: }
2880:
2881: final private boolean jj_2_10(int xla) {
2882: jj_la = xla;
2883: jj_lastpos = jj_scanpos = token;
2884: try {
2885: return !jj_3_10();
2886: } catch (LookaheadSuccess ls) {
2887: return true;
2888: } finally {
2889: jj_save(9, xla);
2890: }
2891: }
2892:
2893: final private boolean jj_2_11(int xla) {
2894: jj_la = xla;
2895: jj_lastpos = jj_scanpos = token;
2896: try {
2897: return !jj_3_11();
2898: } catch (LookaheadSuccess ls) {
2899: return true;
2900: } finally {
2901: jj_save(10, xla);
2902: }
2903: }
2904:
2905: final private boolean jj_2_12(int xla) {
2906: jj_la = xla;
2907: jj_lastpos = jj_scanpos = token;
2908: try {
2909: return !jj_3_12();
2910: } catch (LookaheadSuccess ls) {
2911: return true;
2912: } finally {
2913: jj_save(11, xla);
2914: }
2915: }
2916:
2917: final private boolean jj_2_13(int xla) {
2918: jj_la = xla;
2919: jj_lastpos = jj_scanpos = token;
2920: try {
2921: return !jj_3_13();
2922: } catch (LookaheadSuccess ls) {
2923: return true;
2924: } finally {
2925: jj_save(12, xla);
2926: }
2927: }
2928:
2929: final private boolean jj_2_14(int xla) {
2930: jj_la = xla;
2931: jj_lastpos = jj_scanpos = token;
2932: try {
2933: return !jj_3_14();
2934: } catch (LookaheadSuccess ls) {
2935: return true;
2936: } finally {
2937: jj_save(13, xla);
2938: }
2939: }
2940:
2941: final private boolean jj_2_15(int xla) {
2942: jj_la = xla;
2943: jj_lastpos = jj_scanpos = token;
2944: try {
2945: return !jj_3_15();
2946: } catch (LookaheadSuccess ls) {
2947: return true;
2948: } finally {
2949: jj_save(14, xla);
2950: }
2951: }
2952:
2953: final private boolean jj_2_16(int xla) {
2954: jj_la = xla;
2955: jj_lastpos = jj_scanpos = token;
2956: try {
2957: return !jj_3_16();
2958: } catch (LookaheadSuccess ls) {
2959: return true;
2960: } finally {
2961: jj_save(15, xla);
2962: }
2963: }
2964:
2965: final private boolean jj_2_17(int xla) {
2966: jj_la = xla;
2967: jj_lastpos = jj_scanpos = token;
2968: try {
2969: return !jj_3_17();
2970: } catch (LookaheadSuccess ls) {
2971: return true;
2972: } finally {
2973: jj_save(16, xla);
2974: }
2975: }
2976:
2977: final private boolean jj_2_18(int xla) {
2978: jj_la = xla;
2979: jj_lastpos = jj_scanpos = token;
2980: try {
2981: return !jj_3_18();
2982: } catch (LookaheadSuccess ls) {
2983: return true;
2984: } finally {
2985: jj_save(17, xla);
2986: }
2987: }
2988:
2989: final private boolean jj_2_19(int xla) {
2990: jj_la = xla;
2991: jj_lastpos = jj_scanpos = token;
2992: try {
2993: return !jj_3_19();
2994: } catch (LookaheadSuccess ls) {
2995: return true;
2996: } finally {
2997: jj_save(18, xla);
2998: }
2999: }
3000:
3001: final private boolean jj_2_20(int xla) {
3002: jj_la = xla;
3003: jj_lastpos = jj_scanpos = token;
3004: try {
3005: return !jj_3_20();
3006: } catch (LookaheadSuccess ls) {
3007: return true;
3008: } finally {
3009: jj_save(19, xla);
3010: }
3011: }
3012:
3013: final private boolean jj_2_21(int xla) {
3014: jj_la = xla;
3015: jj_lastpos = jj_scanpos = token;
3016: try {
3017: return !jj_3_21();
3018: } catch (LookaheadSuccess ls) {
3019: return true;
3020: } finally {
3021: jj_save(20, xla);
3022: }
3023: }
3024:
3025: final private boolean jj_2_22(int xla) {
3026: jj_la = xla;
3027: jj_lastpos = jj_scanpos = token;
3028: try {
3029: return !jj_3_22();
3030: } catch (LookaheadSuccess ls) {
3031: return true;
3032: } finally {
3033: jj_save(21, xla);
3034: }
3035: }
3036:
3037: final private boolean jj_2_23(int xla) {
3038: jj_la = xla;
3039: jj_lastpos = jj_scanpos = token;
3040: try {
3041: return !jj_3_23();
3042: } catch (LookaheadSuccess ls) {
3043: return true;
3044: } finally {
3045: jj_save(22, xla);
3046: }
3047: }
3048:
3049: final private boolean jj_2_24(int xla) {
3050: jj_la = xla;
3051: jj_lastpos = jj_scanpos = token;
3052: try {
3053: return !jj_3_24();
3054: } catch (LookaheadSuccess ls) {
3055: return true;
3056: } finally {
3057: jj_save(23, xla);
3058: }
3059: }
3060:
3061: final private boolean jj_2_25(int xla) {
3062: jj_la = xla;
3063: jj_lastpos = jj_scanpos = token;
3064: try {
3065: return !jj_3_25();
3066: } catch (LookaheadSuccess ls) {
3067: return true;
3068: } finally {
3069: jj_save(24, xla);
3070: }
3071: }
3072:
3073: final private boolean jj_2_26(int xla) {
3074: jj_la = xla;
3075: jj_lastpos = jj_scanpos = token;
3076: try {
3077: return !jj_3_26();
3078: } catch (LookaheadSuccess ls) {
3079: return true;
3080: } finally {
3081: jj_save(25, xla);
3082: }
3083: }
3084:
3085: final private boolean jj_2_27(int xla) {
3086: jj_la = xla;
3087: jj_lastpos = jj_scanpos = token;
3088: try {
3089: return !jj_3_27();
3090: } catch (LookaheadSuccess ls) {
3091: return true;
3092: } finally {
3093: jj_save(26, xla);
3094: }
3095: }
3096:
3097: final private boolean jj_2_28(int xla) {
3098: jj_la = xla;
3099: jj_lastpos = jj_scanpos = token;
3100: try {
3101: return !jj_3_28();
3102: } catch (LookaheadSuccess ls) {
3103: return true;
3104: } finally {
3105: jj_save(27, xla);
3106: }
3107: }
3108:
3109: final private boolean jj_2_29(int xla) {
3110: jj_la = xla;
3111: jj_lastpos = jj_scanpos = token;
3112: try {
3113: return !jj_3_29();
3114: } catch (LookaheadSuccess ls) {
3115: return true;
3116: } finally {
3117: jj_save(28, xla);
3118: }
3119: }
3120:
3121: final private boolean jj_2_30(int xla) {
3122: jj_la = xla;
3123: jj_lastpos = jj_scanpos = token;
3124: try {
3125: return !jj_3_30();
3126: } catch (LookaheadSuccess ls) {
3127: return true;
3128: } finally {
3129: jj_save(29, xla);
3130: }
3131: }
3132:
3133: final private boolean jj_3R_102() {
3134: if (jj_3R_110())
3135: return true;
3136: if (jj_3R_60())
3137: return true;
3138: return false;
3139: }
3140:
3141: final private boolean jj_3R_60() {
3142: if (jj_3R_78())
3143: return true;
3144: Token xsp;
3145: xsp = jj_scanpos;
3146: if (jj_3R_102())
3147: jj_scanpos = xsp;
3148: return false;
3149: }
3150:
3151: final private boolean jj_3R_217() {
3152: if (jj_scan_token(COMMA))
3153: return true;
3154: if (jj_3R_47())
3155: return true;
3156: return false;
3157: }
3158:
3159: final private boolean jj_3R_206() {
3160: if (jj_3R_47())
3161: return true;
3162: Token xsp;
3163: while (true) {
3164: xsp = jj_scanpos;
3165: if (jj_3R_217()) {
3166: jj_scanpos = xsp;
3167: break;
3168: }
3169: }
3170: return false;
3171: }
3172:
3173: final private boolean jj_3_14() {
3174: if (jj_scan_token(DOT))
3175: return true;
3176: if (jj_scan_token(IDENTIFIER))
3177: return true;
3178: return false;
3179: }
3180:
3181: final private boolean jj_3R_47() {
3182: if (jj_scan_token(IDENTIFIER))
3183: return true;
3184: Token xsp;
3185: while (true) {
3186: xsp = jj_scanpos;
3187: if (jj_3_14()) {
3188: jj_scanpos = xsp;
3189: break;
3190: }
3191: }
3192: return false;
3193: }
3194:
3195: final private boolean jj_3R_81() {
3196: if (jj_scan_token(LBRACKET))
3197: return true;
3198: if (jj_scan_token(RBRACKET))
3199: return true;
3200: return false;
3201: }
3202:
3203: final private boolean jj_3R_76() {
3204: if (jj_3R_62())
3205: return true;
3206: return false;
3207: }
3208:
3209: final private boolean jj_3R_58() {
3210: Token xsp;
3211: xsp = jj_scanpos;
3212: if (jj_scan_token(60)) {
3213: jj_scanpos = xsp;
3214: if (jj_3R_76())
3215: return true;
3216: }
3217: return false;
3218: }
3219:
3220: final private boolean jj_3R_80() {
3221: if (jj_3R_47())
3222: return true;
3223: return false;
3224: }
3225:
3226: final private boolean jj_3R_56() {
3227: Token xsp;
3228: xsp = jj_scanpos;
3229: if (jj_scan_token(14)) {
3230: jj_scanpos = xsp;
3231: if (jj_scan_token(19)) {
3232: jj_scanpos = xsp;
3233: if (jj_scan_token(16)) {
3234: jj_scanpos = xsp;
3235: if (jj_scan_token(49)) {
3236: jj_scanpos = xsp;
3237: if (jj_scan_token(38)) {
3238: jj_scanpos = xsp;
3239: if (jj_scan_token(40)) {
3240: jj_scanpos = xsp;
3241: if (jj_scan_token(31)) {
3242: jj_scanpos = xsp;
3243: if (jj_scan_token(25))
3244: return true;
3245: }
3246: }
3247: }
3248: }
3249: }
3250: }
3251: }
3252: return false;
3253: }
3254:
3255: final private boolean jj_3R_189() {
3256: if (jj_scan_token(THROWS))
3257: return true;
3258: if (jj_3R_206())
3259: return true;
3260: return false;
3261: }
3262:
3263: final private boolean jj_3R_79() {
3264: if (jj_3R_56())
3265: return true;
3266: return false;
3267: }
3268:
3269: final private boolean jj_3R_62() {
3270: Token xsp;
3271: xsp = jj_scanpos;
3272: if (jj_3R_79()) {
3273: jj_scanpos = xsp;
3274: if (jj_3R_80())
3275: return true;
3276: }
3277: while (true) {
3278: xsp = jj_scanpos;
3279: if (jj_3R_81()) {
3280: jj_scanpos = xsp;
3281: break;
3282: }
3283: }
3284: return false;
3285: }
3286:
3287: final private boolean jj_3_13() {
3288: if (jj_scan_token(THIS))
3289: return true;
3290: if (jj_3R_54())
3291: return true;
3292: if (jj_scan_token(SEMICOLON))
3293: return true;
3294: return false;
3295: }
3296:
3297: final private boolean jj_3R_43() {
3298: Token xsp;
3299: xsp = jj_scanpos;
3300: if (jj_scan_token(50))
3301: jj_scanpos = xsp;
3302: if (jj_3R_63())
3303: return true;
3304: return false;
3305: }
3306:
3307: final private boolean jj_3_11() {
3308: if (jj_3R_52())
3309: return true;
3310: return false;
3311: }
3312:
3313: final private boolean jj_3_12() {
3314: if (jj_3R_53())
3315: return true;
3316: if (jj_scan_token(DOT))
3317: return true;
3318: return false;
3319: }
3320:
3321: final private boolean jj_3R_207() {
3322: if (jj_scan_token(LBRACKET))
3323: return true;
3324: if (jj_scan_token(RBRACKET))
3325: return true;
3326: return false;
3327: }
3328:
3329: final private boolean jj_3R_68() {
3330: Token xsp;
3331: xsp = jj_scanpos;
3332: if (jj_3_12())
3333: jj_scanpos = xsp;
3334: if (jj_scan_token(SUPER))
3335: return true;
3336: if (jj_3R_54())
3337: return true;
3338: if (jj_scan_token(SEMICOLON))
3339: return true;
3340: return false;
3341: }
3342:
3343: final private boolean jj_3R_216() {
3344: if (jj_scan_token(COMMA))
3345: return true;
3346: if (jj_3R_215())
3347: return true;
3348: return false;
3349: }
3350:
3351: final private boolean jj_3R_52() {
3352: Token xsp;
3353: xsp = jj_scanpos;
3354: if (jj_3R_67()) {
3355: jj_scanpos = xsp;
3356: if (jj_3R_68())
3357: return true;
3358: }
3359: return false;
3360: }
3361:
3362: final private boolean jj_3R_67() {
3363: if (jj_scan_token(THIS))
3364: return true;
3365: if (jj_3R_54())
3366: return true;
3367: if (jj_scan_token(SEMICOLON))
3368: return true;
3369: return false;
3370: }
3371:
3372: final private boolean jj_3R_194() {
3373: if (jj_scan_token(THROWS))
3374: return true;
3375: if (jj_3R_206())
3376: return true;
3377: return false;
3378: }
3379:
3380: final private boolean jj_3R_191() {
3381: if (jj_3R_93())
3382: return true;
3383: return false;
3384: }
3385:
3386: final private boolean jj_3R_190() {
3387: if (jj_3R_52())
3388: return true;
3389: return false;
3390: }
3391:
3392: final private boolean jj_3R_187() {
3393: Token xsp;
3394: xsp = jj_scanpos;
3395: if (jj_scan_token(47)) {
3396: jj_scanpos = xsp;
3397: if (jj_scan_token(46)) {
3398: jj_scanpos = xsp;
3399: if (jj_scan_token(45))
3400: return true;
3401: }
3402: }
3403: return false;
3404: }
3405:
3406: final private boolean jj_3R_177() {
3407: Token xsp;
3408: xsp = jj_scanpos;
3409: if (jj_3R_187())
3410: jj_scanpos = xsp;
3411: if (jj_scan_token(IDENTIFIER))
3412: return true;
3413: if (jj_3R_188())
3414: return true;
3415: xsp = jj_scanpos;
3416: if (jj_3R_189())
3417: jj_scanpos = xsp;
3418: if (jj_scan_token(LBRACE))
3419: return true;
3420: xsp = jj_scanpos;
3421: if (jj_3R_190())
3422: jj_scanpos = xsp;
3423: while (true) {
3424: xsp = jj_scanpos;
3425: if (jj_3R_191()) {
3426: jj_scanpos = xsp;
3427: break;
3428: }
3429: }
3430: if (jj_scan_token(RBRACE))
3431: return true;
3432: return false;
3433: }
3434:
3435: final private boolean jj_3_10() {
3436: if (jj_scan_token(COMMA))
3437: return true;
3438: if (jj_3R_51())
3439: return true;
3440: return false;
3441: }
3442:
3443: final private boolean jj_3R_205() {
3444: if (jj_3R_215())
3445: return true;
3446: Token xsp;
3447: while (true) {
3448: xsp = jj_scanpos;
3449: if (jj_3R_216()) {
3450: jj_scanpos = xsp;
3451: break;
3452: }
3453: }
3454: return false;
3455: }
3456:
3457: final private boolean jj_3R_215() {
3458: Token xsp;
3459: xsp = jj_scanpos;
3460: if (jj_scan_token(29))
3461: jj_scanpos = xsp;
3462: if (jj_3R_62())
3463: return true;
3464: if (jj_3R_208())
3465: return true;
3466: return false;
3467: }
3468:
3469: final private boolean jj_3R_188() {
3470: if (jj_scan_token(LPAREN))
3471: return true;
3472: Token xsp;
3473: xsp = jj_scanpos;
3474: if (jj_3R_205())
3475: jj_scanpos = xsp;
3476: if (jj_scan_token(RPAREN))
3477: return true;
3478: return false;
3479: }
3480:
3481: final private boolean jj_3R_193() {
3482: if (jj_scan_token(IDENTIFIER))
3483: return true;
3484: if (jj_3R_188())
3485: return true;
3486: Token xsp;
3487: while (true) {
3488: xsp = jj_scanpos;
3489: if (jj_3R_207()) {
3490: jj_scanpos = xsp;
3491: break;
3492: }
3493: }
3494: return false;
3495: }
3496:
3497: final private boolean jj_3R_195() {
3498: if (jj_3R_63())
3499: return true;
3500: return false;
3501: }
3502:
3503: final private boolean jj_3R_192() {
3504: Token xsp;
3505: xsp = jj_scanpos;
3506: if (jj_scan_token(47)) {
3507: jj_scanpos = xsp;
3508: if (jj_scan_token(46)) {
3509: jj_scanpos = xsp;
3510: if (jj_scan_token(45)) {
3511: jj_scanpos = xsp;
3512: if (jj_scan_token(50)) {
3513: jj_scanpos = xsp;
3514: if (jj_scan_token(13)) {
3515: jj_scanpos = xsp;
3516: if (jj_scan_token(29)) {
3517: jj_scanpos = xsp;
3518: if (jj_scan_token(41)) {
3519: jj_scanpos = xsp;
3520: if (jj_scan_token(53)) {
3521: jj_scanpos = xsp;
3522: if (jj_scan_token(63))
3523: return true;
3524: }
3525: }
3526: }
3527: }
3528: }
3529: }
3530: }
3531: }
3532: return false;
3533: }
3534:
3535: final private boolean jj_3R_161() {
3536: if (jj_3R_51())
3537: return true;
3538: Token xsp;
3539: while (true) {
3540: xsp = jj_scanpos;
3541: if (jj_3_10()) {
3542: jj_scanpos = xsp;
3543: break;
3544: }
3545: }
3546: return false;
3547: }
3548:
3549: final private boolean jj_3R_178() {
3550: Token xsp;
3551: while (true) {
3552: xsp = jj_scanpos;
3553: if (jj_3R_192()) {
3554: jj_scanpos = xsp;
3555: break;
3556: }
3557: }
3558: if (jj_3R_58())
3559: return true;
3560: if (jj_3R_193())
3561: return true;
3562: xsp = jj_scanpos;
3563: if (jj_3R_194())
3564: jj_scanpos = xsp;
3565: xsp = jj_scanpos;
3566: if (jj_3R_195()) {
3567: jj_scanpos = xsp;
3568: if (jj_scan_token(82))
3569: return true;
3570: }
3571: return false;
3572: }
3573:
3574: final private boolean jj_3R_209() {
3575: if (jj_scan_token(ASSIGN))
3576: return true;
3577: if (jj_3R_51())
3578: return true;
3579: return false;
3580: }
3581:
3582: final private boolean jj_3R_198() {
3583: if (jj_scan_token(COMMA))
3584: return true;
3585: if (jj_3R_197())
3586: return true;
3587: return false;
3588: }
3589:
3590: final private boolean jj_3R_218() {
3591: if (jj_scan_token(LBRACKET))
3592: return true;
3593: if (jj_scan_token(RBRACKET))
3594: return true;
3595: return false;
3596: }
3597:
3598: final private boolean jj_3R_83() {
3599: if (jj_scan_token(LBRACE))
3600: return true;
3601: Token xsp;
3602: xsp = jj_scanpos;
3603: if (jj_3R_161())
3604: jj_scanpos = xsp;
3605: xsp = jj_scanpos;
3606: if (jj_scan_token(83))
3607: jj_scanpos = xsp;
3608: if (jj_scan_token(RBRACE))
3609: return true;
3610: return false;
3611: }
3612:
3613: final private boolean jj_3R_66() {
3614: if (jj_3R_60())
3615: return true;
3616: return false;
3617: }
3618:
3619: final private boolean jj_3R_51() {
3620: Token xsp;
3621: xsp = jj_scanpos;
3622: if (jj_3R_65()) {
3623: jj_scanpos = xsp;
3624: if (jj_3R_66())
3625: return true;
3626: }
3627: return false;
3628: }
3629:
3630: final private boolean jj_3R_65() {
3631: if (jj_3R_83())
3632: return true;
3633: return false;
3634: }
3635:
3636: final private boolean jj_3R_208() {
3637: if (jj_scan_token(IDENTIFIER))
3638: return true;
3639: Token xsp;
3640: while (true) {
3641: xsp = jj_scanpos;
3642: if (jj_3R_218()) {
3643: jj_scanpos = xsp;
3644: break;
3645: }
3646: }
3647: return false;
3648: }
3649:
3650: final private boolean jj_3R_197() {
3651: if (jj_3R_208())
3652: return true;
3653: Token xsp;
3654: xsp = jj_scanpos;
3655: if (jj_3R_209())
3656: jj_scanpos = xsp;
3657: return false;
3658: }
3659:
3660: final private boolean jj_3R_196() {
3661: Token xsp;
3662: xsp = jj_scanpos;
3663: if (jj_scan_token(47)) {
3664: jj_scanpos = xsp;
3665: if (jj_scan_token(46)) {
3666: jj_scanpos = xsp;
3667: if (jj_scan_token(45)) {
3668: jj_scanpos = xsp;
3669: if (jj_scan_token(50)) {
3670: jj_scanpos = xsp;
3671: if (jj_scan_token(29)) {
3672: jj_scanpos = xsp;
3673: if (jj_scan_token(57)) {
3674: jj_scanpos = xsp;
3675: if (jj_scan_token(61))
3676: return true;
3677: }
3678: }
3679: }
3680: }
3681: }
3682: }
3683: return false;
3684: }
3685:
3686: final private boolean jj_3_9() {
3687: if (jj_3R_48())
3688: return true;
3689: return false;
3690: }
3691:
3692: final private boolean jj_3R_179() {
3693: Token xsp;
3694: while (true) {
3695: xsp = jj_scanpos;
3696: if (jj_3R_196()) {
3697: jj_scanpos = xsp;
3698: break;
3699: }
3700: }
3701: if (jj_3R_62())
3702: return true;
3703: if (jj_3R_197())
3704: return true;
3705: while (true) {
3706: xsp = jj_scanpos;
3707: if (jj_3R_198()) {
3708: jj_scanpos = xsp;
3709: break;
3710: }
3711: }
3712: if (jj_scan_token(SEMICOLON))
3713: return true;
3714: return false;
3715: }
3716:
3717: final private boolean jj_3R_50() {
3718: Token xsp;
3719: xsp = jj_scanpos;
3720: if (jj_scan_token(50)) {
3721: jj_scanpos = xsp;
3722: if (jj_scan_token(13)) {
3723: jj_scanpos = xsp;
3724: if (jj_scan_token(29)) {
3725: jj_scanpos = xsp;
3726: if (jj_scan_token(47)) {
3727: jj_scanpos = xsp;
3728: if (jj_scan_token(46)) {
3729: jj_scanpos = xsp;
3730: if (jj_scan_token(45)) {
3731: jj_scanpos = xsp;
3732: if (jj_scan_token(63))
3733: return true;
3734: }
3735: }
3736: }
3737: }
3738: }
3739: }
3740: return false;
3741: }
3742:
3743: final private boolean jj_3R_203() {
3744: if (jj_scan_token(EXTENDS))
3745: return true;
3746: if (jj_3R_206())
3747: return true;
3748: return false;
3749: }
3750:
3751: final private boolean jj_3_8() {
3752: Token xsp;
3753: while (true) {
3754: xsp = jj_scanpos;
3755: if (jj_3R_50()) {
3756: jj_scanpos = xsp;
3757: break;
3758: }
3759: }
3760: if (jj_scan_token(INTERFACE))
3761: return true;
3762: return false;
3763: }
3764:
3765: final private boolean jj_3R_49() {
3766: Token xsp;
3767: xsp = jj_scanpos;
3768: if (jj_scan_token(50)) {
3769: jj_scanpos = xsp;
3770: if (jj_scan_token(13)) {
3771: jj_scanpos = xsp;
3772: if (jj_scan_token(29)) {
3773: jj_scanpos = xsp;
3774: if (jj_scan_token(47)) {
3775: jj_scanpos = xsp;
3776: if (jj_scan_token(46)) {
3777: jj_scanpos = xsp;
3778: if (jj_scan_token(45)) {
3779: jj_scanpos = xsp;
3780: if (jj_scan_token(63))
3781: return true;
3782: }
3783: }
3784: }
3785: }
3786: }
3787: }
3788: return false;
3789: }
3790:
3791: final private boolean jj_3_7() {
3792: Token xsp;
3793: while (true) {
3794: xsp = jj_scanpos;
3795: if (jj_3R_49()) {
3796: jj_scanpos = xsp;
3797: break;
3798: }
3799: }
3800: if (jj_scan_token(CLASS))
3801: return true;
3802: return false;
3803: }
3804:
3805: final private boolean jj_3R_224() {
3806: if (jj_3R_179())
3807: return true;
3808: return false;
3809: }
3810:
3811: final private boolean jj_3R_223() {
3812: if (jj_3R_178())
3813: return true;
3814: return false;
3815: }
3816:
3817: final private boolean jj_3R_222() {
3818: if (jj_3R_176())
3819: return true;
3820: return false;
3821: }
3822:
3823: final private boolean jj_3R_214() {
3824: Token xsp;
3825: xsp = jj_scanpos;
3826: if (jj_3R_221()) {
3827: jj_scanpos = xsp;
3828: if (jj_3R_222()) {
3829: jj_scanpos = xsp;
3830: if (jj_3R_223()) {
3831: jj_scanpos = xsp;
3832: if (jj_3R_224()) {
3833: jj_scanpos = xsp;
3834: if (jj_scan_token(82))
3835: return true;
3836: }
3837: }
3838: }
3839: }
3840: return false;
3841: }
3842:
3843: final private boolean jj_3R_221() {
3844: if (jj_3R_175())
3845: return true;
3846: return false;
3847: }
3848:
3849: final private boolean jj_3R_204() {
3850: if (jj_3R_214())
3851: return true;
3852: return false;
3853: }
3854:
3855: final private boolean jj_3R_107() {
3856: if (jj_scan_token(INTERFACE))
3857: return true;
3858: if (jj_scan_token(IDENTIFIER))
3859: return true;
3860: Token xsp;
3861: xsp = jj_scanpos;
3862: if (jj_3R_203())
3863: jj_scanpos = xsp;
3864: if (jj_scan_token(LBRACE))
3865: return true;
3866: while (true) {
3867: xsp = jj_scanpos;
3868: if (jj_3R_204()) {
3869: jj_scanpos = xsp;
3870: break;
3871: }
3872: }
3873: if (jj_scan_token(RBRACE))
3874: return true;
3875: return false;
3876: }
3877:
3878: final private boolean jj_3R_186() {
3879: Token xsp;
3880: xsp = jj_scanpos;
3881: if (jj_scan_token(50)) {
3882: jj_scanpos = xsp;
3883: if (jj_scan_token(13)) {
3884: jj_scanpos = xsp;
3885: if (jj_scan_token(29)) {
3886: jj_scanpos = xsp;
3887: if (jj_scan_token(47)) {
3888: jj_scanpos = xsp;
3889: if (jj_scan_token(46)) {
3890: jj_scanpos = xsp;
3891: if (jj_scan_token(45)) {
3892: jj_scanpos = xsp;
3893: if (jj_scan_token(63))
3894: return true;
3895: }
3896: }
3897: }
3898: }
3899: }
3900: }
3901: return false;
3902: }
3903:
3904: final private boolean jj_3R_176() {
3905: Token xsp;
3906: while (true) {
3907: xsp = jj_scanpos;
3908: if (jj_3R_186()) {
3909: jj_scanpos = xsp;
3910: break;
3911: }
3912: }
3913: if (jj_3R_107())
3914: return true;
3915: return false;
3916: }
3917:
3918: final private boolean jj_3R_64() {
3919: Token xsp;
3920: xsp = jj_scanpos;
3921: if (jj_scan_token(47)) {
3922: jj_scanpos = xsp;
3923: if (jj_scan_token(46)) {
3924: jj_scanpos = xsp;
3925: if (jj_scan_token(45)) {
3926: jj_scanpos = xsp;
3927: if (jj_scan_token(50)) {
3928: jj_scanpos = xsp;
3929: if (jj_scan_token(13)) {
3930: jj_scanpos = xsp;
3931: if (jj_scan_token(29)) {
3932: jj_scanpos = xsp;
3933: if (jj_scan_token(41)) {
3934: jj_scanpos = xsp;
3935: if (jj_scan_token(53)) {
3936: jj_scanpos = xsp;
3937: if (jj_scan_token(63))
3938: return true;
3939: }
3940: }
3941: }
3942: }
3943: }
3944: }
3945: }
3946: }
3947: return false;
3948: }
3949:
3950: final private boolean jj_3R_48() {
3951: Token xsp;
3952: while (true) {
3953: xsp = jj_scanpos;
3954: if (jj_3R_64()) {
3955: jj_scanpos = xsp;
3956: break;
3957: }
3958: }
3959: if (jj_3R_58())
3960: return true;
3961: if (jj_scan_token(IDENTIFIER))
3962: return true;
3963: if (jj_scan_token(LPAREN))
3964: return true;
3965: return false;
3966: }
3967:
3968: final private boolean jj_3_6() {
3969: if (jj_3R_48())
3970: return true;
3971: return false;
3972: }
3973:
3974: final private boolean jj_3R_46() {
3975: Token xsp;
3976: xsp = jj_scanpos;
3977: if (jj_scan_token(47)) {
3978: jj_scanpos = xsp;
3979: if (jj_scan_token(46)) {
3980: jj_scanpos = xsp;
3981: if (jj_scan_token(45))
3982: return true;
3983: }
3984: }
3985: return false;
3986: }
3987:
3988: final private boolean jj_3_5() {
3989: Token xsp;
3990: xsp = jj_scanpos;
3991: if (jj_3R_46())
3992: jj_scanpos = xsp;
3993: if (jj_3R_47())
3994: return true;
3995: if (jj_scan_token(LPAREN))
3996: return true;
3997: return false;
3998: }
3999:
4000: final private boolean jj_3R_45() {
4001: Token xsp;
4002: xsp = jj_scanpos;
4003: if (jj_scan_token(50)) {
4004: jj_scanpos = xsp;
4005: if (jj_scan_token(13)) {
4006: jj_scanpos = xsp;
4007: if (jj_scan_token(29)) {
4008: jj_scanpos = xsp;
4009: if (jj_scan_token(47)) {
4010: jj_scanpos = xsp;
4011: if (jj_scan_token(46)) {
4012: jj_scanpos = xsp;
4013: if (jj_scan_token(45)) {
4014: jj_scanpos = xsp;
4015: if (jj_scan_token(63))
4016: return true;
4017: }
4018: }
4019: }
4020: }
4021: }
4022: }
4023: return false;
4024: }
4025:
4026: final private boolean jj_3_4() {
4027: Token xsp;
4028: while (true) {
4029: xsp = jj_scanpos;
4030: if (jj_3R_45()) {
4031: jj_scanpos = xsp;
4032: break;
4033: }
4034: }
4035: if (jj_scan_token(INTERFACE))
4036: return true;
4037: return false;
4038: }
4039:
4040: final private boolean jj_3R_202() {
4041: if (jj_scan_token(IMPLEMENTS))
4042: return true;
4043: if (jj_3R_206())
4044: return true;
4045: return false;
4046: }
4047:
4048: final private boolean jj_3R_44() {
4049: Token xsp;
4050: xsp = jj_scanpos;
4051: if (jj_scan_token(50)) {
4052: jj_scanpos = xsp;
4053: if (jj_scan_token(13)) {
4054: jj_scanpos = xsp;
4055: if (jj_scan_token(29)) {
4056: jj_scanpos = xsp;
4057: if (jj_scan_token(47)) {
4058: jj_scanpos = xsp;
4059: if (jj_scan_token(46)) {
4060: jj_scanpos = xsp;
4061: if (jj_scan_token(45)) {
4062: jj_scanpos = xsp;
4063: if (jj_scan_token(63))
4064: return true;
4065: }
4066: }
4067: }
4068: }
4069: }
4070: }
4071: return false;
4072: }
4073:
4074: final private boolean jj_3R_172() {
4075: if (jj_3R_179())
4076: return true;
4077: return false;
4078: }
4079:
4080: final private boolean jj_3_3() {
4081: Token xsp;
4082: while (true) {
4083: xsp = jj_scanpos;
4084: if (jj_3R_44()) {
4085: jj_scanpos = xsp;
4086: break;
4087: }
4088: }
4089: if (jj_scan_token(CLASS))
4090: return true;
4091: return false;
4092: }
4093:
4094: final private boolean jj_3R_171() {
4095: if (jj_3R_178())
4096: return true;
4097: return false;
4098: }
4099:
4100: final private boolean jj_3R_170() {
4101: if (jj_3R_177())
4102: return true;
4103: return false;
4104: }
4105:
4106: final private boolean jj_3R_169() {
4107: if (jj_3R_176())
4108: return true;
4109: return false;
4110: }
4111:
4112: final private boolean jj_3R_168() {
4113: if (jj_3R_175())
4114: return true;
4115: return false;
4116: }
4117:
4118: final private boolean jj_3_2() {
4119: if (jj_3R_43())
4120: return true;
4121: return false;
4122: }
4123:
4124: final private boolean jj_3R_165() {
4125: Token xsp;
4126: xsp = jj_scanpos;
4127: if (jj_3_2()) {
4128: jj_scanpos = xsp;
4129: if (jj_3R_168()) {
4130: jj_scanpos = xsp;
4131: if (jj_3R_169()) {
4132: jj_scanpos = xsp;
4133: if (jj_3R_170()) {
4134: jj_scanpos = xsp;
4135: if (jj_3R_171()) {
4136: jj_scanpos = xsp;
4137: if (jj_3R_172()) {
4138: jj_scanpos = xsp;
4139: if (jj_scan_token(82))
4140: return true;
4141: }
4142: }
4143: }
4144: }
4145: }
4146: }
4147: return false;
4148: }
4149:
4150: final private boolean jj_3R_201() {
4151: if (jj_scan_token(EXTENDS))
4152: return true;
4153: if (jj_3R_47())
4154: return true;
4155: return false;
4156: }
4157:
4158: final private boolean jj_3R_185() {
4159: Token xsp;
4160: xsp = jj_scanpos;
4161: if (jj_scan_token(50)) {
4162: jj_scanpos = xsp;
4163: if (jj_scan_token(13)) {
4164: jj_scanpos = xsp;
4165: if (jj_scan_token(29)) {
4166: jj_scanpos = xsp;
4167: if (jj_scan_token(47)) {
4168: jj_scanpos = xsp;
4169: if (jj_scan_token(46)) {
4170: jj_scanpos = xsp;
4171: if (jj_scan_token(45)) {
4172: jj_scanpos = xsp;
4173: if (jj_scan_token(63))
4174: return true;
4175: }
4176: }
4177: }
4178: }
4179: }
4180: }
4181: return false;
4182: }
4183:
4184: final private boolean jj_3R_162() {
4185: if (jj_3R_165())
4186: return true;
4187: return false;
4188: }
4189:
4190: final private boolean jj_3R_175() {
4191: Token xsp;
4192: while (true) {
4193: xsp = jj_scanpos;
4194: if (jj_3R_185()) {
4195: jj_scanpos = xsp;
4196: break;
4197: }
4198: }
4199: if (jj_3R_106())
4200: return true;
4201: return false;
4202: }
4203:
4204: final private boolean jj_3R_158() {
4205: if (jj_scan_token(LBRACE))
4206: return true;
4207: Token xsp;
4208: while (true) {
4209: xsp = jj_scanpos;
4210: if (jj_3R_162()) {
4211: jj_scanpos = xsp;
4212: break;
4213: }
4214: }
4215: if (jj_scan_token(RBRACE))
4216: return true;
4217: return false;
4218: }
4219:
4220: final private boolean jj_3R_106() {
4221: if (jj_scan_token(CLASS))
4222: return true;
4223: if (jj_scan_token(IDENTIFIER))
4224: return true;
4225: Token xsp;
4226: xsp = jj_scanpos;
4227: if (jj_3R_201())
4228: jj_scanpos = xsp;
4229: xsp = jj_scanpos;
4230: if (jj_3R_202())
4231: jj_scanpos = xsp;
4232: if (jj_3R_158())
4233: return true;
4234: return false;
4235: }
4236:
4237: final private boolean jj_3R_236() {
4238: if (jj_scan_token(COLON))
4239: return true;
4240: if (jj_3R_60())
4241: return true;
4242: return false;
4243: }
4244:
4245: final private boolean jj_3R_42() {
4246: Token xsp;
4247: xsp = jj_scanpos;
4248: if (jj_scan_token(13)) {
4249: jj_scanpos = xsp;
4250: if (jj_scan_token(29)) {
4251: jj_scanpos = xsp;
4252: if (jj_scan_token(47)) {
4253: jj_scanpos = xsp;
4254: if (jj_scan_token(63))
4255: return true;
4256: }
4257: }
4258: }
4259: return false;
4260: }
4261:
4262: final private boolean jj_3_1() {
4263: Token xsp;
4264: while (true) {
4265: xsp = jj_scanpos;
4266: if (jj_3R_42()) {
4267: jj_scanpos = xsp;
4268: break;
4269: }
4270: }
4271: if (jj_scan_token(CLASS))
4272: return true;
4273: return false;
4274: }
4275:
4276: final private boolean jj_3R_140() {
4277: if (jj_scan_token(ASSERT))
4278: return true;
4279: if (jj_3R_60())
4280: return true;
4281: Token xsp;
4282: xsp = jj_scanpos;
4283: if (jj_3R_236())
4284: jj_scanpos = xsp;
4285: if (jj_scan_token(SEMICOLON))
4286: return true;
4287: return false;
4288: }
4289:
4290: final private boolean jj_3R_235() {
4291: if (jj_scan_token(FINALLY))
4292: return true;
4293: if (jj_3R_63())
4294: return true;
4295: return false;
4296: }
4297:
4298: final private boolean jj_3R_234() {
4299: if (jj_scan_token(CATCH))
4300: return true;
4301: if (jj_scan_token(LPAREN))
4302: return true;
4303: if (jj_3R_215())
4304: return true;
4305: if (jj_scan_token(RPAREN))
4306: return true;
4307: if (jj_3R_63())
4308: return true;
4309: return false;
4310: }
4311:
4312: final private boolean jj_3R_139() {
4313: if (jj_scan_token(TRY))
4314: return true;
4315: if (jj_3R_63())
4316: return true;
4317: Token xsp;
4318: while (true) {
4319: xsp = jj_scanpos;
4320: if (jj_3R_234()) {
4321: jj_scanpos = xsp;
4322: break;
4323: }
4324: }
4325: xsp = jj_scanpos;
4326: if (jj_3R_235())
4327: jj_scanpos = xsp;
4328: return false;
4329: }
4330:
4331: final private boolean jj_3R_138() {
4332: if (jj_scan_token(SYNCHRONIZED))
4333: return true;
4334: if (jj_scan_token(LPAREN))
4335: return true;
4336: if (jj_3R_60())
4337: return true;
4338: if (jj_scan_token(RPAREN))
4339: return true;
4340: if (jj_3R_63())
4341: return true;
4342: return false;
4343: }
4344:
4345: final private boolean jj_3R_232() {
4346: if (jj_3R_242())
4347: return true;
4348: return false;
4349: }
4350:
4351: final private boolean jj_3R_233() {
4352: if (jj_3R_60())
4353: return true;
4354: return false;
4355: }
4356:
4357: final private boolean jj_3R_137() {
4358: if (jj_scan_token(THROW))
4359: return true;
4360: if (jj_3R_60())
4361: return true;
4362: if (jj_scan_token(SEMICOLON))
4363: return true;
4364: return false;
4365: }
4366:
4367: final private boolean jj_3R_249() {
4368: if (jj_scan_token(COMMA))
4369: return true;
4370: if (jj_3R_128())
4371: return true;
4372: return false;
4373: }
4374:
4375: final private boolean jj_3R_136() {
4376: if (jj_scan_token(RETURN))
4377: return true;
4378: Token xsp;
4379: xsp = jj_scanpos;
4380: if (jj_3R_233())
4381: jj_scanpos = xsp;
4382: if (jj_scan_token(SEMICOLON))
4383: return true;
4384: return false;
4385: }
4386:
4387: final private boolean jj_3R_135() {
4388: if (jj_scan_token(CONTINUE))
4389: return true;
4390: Token xsp;
4391: xsp = jj_scanpos;
4392: if (jj_scan_token(73))
4393: jj_scanpos = xsp;
4394: if (jj_scan_token(SEMICOLON))
4395: return true;
4396: return false;
4397: }
4398:
4399: final private boolean jj_3R_231() {
4400: if (jj_3R_60())
4401: return true;
4402: return false;
4403: }
4404:
4405: final private boolean jj_3R_134() {
4406: if (jj_scan_token(BREAK))
4407: return true;
4408: Token xsp;
4409: xsp = jj_scanpos;
4410: if (jj_scan_token(73))
4411: jj_scanpos = xsp;
4412: if (jj_scan_token(SEMICOLON))
4413: return true;
4414: return false;
4415: }
4416:
4417: final private boolean jj_3R_229() {
4418: if (jj_scan_token(ELSE))
4419: return true;
4420: if (jj_3R_105())
4421: return true;
4422: return false;
4423: }
4424:
4425: final private boolean jj_3R_242() {
4426: if (jj_3R_248())
4427: return true;
4428: return false;
4429: }
4430:
4431: final private boolean jj_3_30() {
4432: Token xsp;
4433: xsp = jj_scanpos;
4434: if (jj_scan_token(29))
4435: jj_scanpos = xsp;
4436: if (jj_3R_62())
4437: return true;
4438: if (jj_scan_token(IDENTIFIER))
4439: return true;
4440: return false;
4441: }
4442:
4443: final private boolean jj_3R_248() {
4444: if (jj_3R_128())
4445: return true;
4446: Token xsp;
4447: while (true) {
4448: xsp = jj_scanpos;
4449: if (jj_3R_249()) {
4450: jj_scanpos = xsp;
4451: break;
4452: }
4453: }
4454: return false;
4455: }
4456:
4457: final private boolean jj_3R_230() {
4458: if (jj_3R_241())
4459: return true;
4460: return false;
4461: }
4462:
4463: final private boolean jj_3R_247() {
4464: if (jj_3R_248())
4465: return true;
4466: return false;
4467: }
4468:
4469: final private boolean jj_3R_246() {
4470: if (jj_3R_104())
4471: return true;
4472: return false;
4473: }
4474:
4475: final private boolean jj_3R_241() {
4476: Token xsp;
4477: xsp = jj_scanpos;
4478: if (jj_3R_246()) {
4479: jj_scanpos = xsp;
4480: if (jj_3R_247())
4481: return true;
4482: }
4483: return false;
4484: }
4485:
4486: final private boolean jj_3R_133() {
4487: if (jj_scan_token(FOR))
4488: return true;
4489: if (jj_scan_token(LPAREN))
4490: return true;
4491: Token xsp;
4492: xsp = jj_scanpos;
4493: if (jj_3R_230())
4494: jj_scanpos = xsp;
4495: if (jj_scan_token(SEMICOLON))
4496: return true;
4497: xsp = jj_scanpos;
4498: if (jj_3R_231())
4499: jj_scanpos = xsp;
4500: if (jj_scan_token(SEMICOLON))
4501: return true;
4502: xsp = jj_scanpos;
4503: if (jj_3R_232())
4504: jj_scanpos = xsp;
4505: if (jj_scan_token(RPAREN))
4506: return true;
4507: if (jj_3R_105())
4508: return true;
4509: return false;
4510: }
4511:
4512: final private boolean jj_3R_132() {
4513: if (jj_scan_token(DO))
4514: return true;
4515: if (jj_3R_105())
4516: return true;
4517: if (jj_scan_token(WHILE))
4518: return true;
4519: if (jj_scan_token(LPAREN))
4520: return true;
4521: if (jj_3R_60())
4522: return true;
4523: if (jj_scan_token(RPAREN))
4524: return true;
4525: if (jj_scan_token(SEMICOLON))
4526: return true;
4527: return false;
4528: }
4529:
4530: final private boolean jj_3R_131() {
4531: if (jj_scan_token(WHILE))
4532: return true;
4533: if (jj_scan_token(LPAREN))
4534: return true;
4535: if (jj_3R_60())
4536: return true;
4537: if (jj_scan_token(RPAREN))
4538: return true;
4539: if (jj_3R_105())
4540: return true;
4541: return false;
4542: }
4543:
4544: final private boolean jj_3R_130() {
4545: if (jj_scan_token(IF))
4546: return true;
4547: if (jj_scan_token(LPAREN))
4548: return true;
4549: if (jj_3R_60())
4550: return true;
4551: if (jj_scan_token(RPAREN))
4552: return true;
4553: if (jj_3R_105())
4554: return true;
4555: Token xsp;
4556: xsp = jj_scanpos;
4557: if (jj_3R_229())
4558: jj_scanpos = xsp;
4559: return false;
4560: }
4561:
4562: final private boolean jj_3R_240() {
4563: if (jj_3R_93())
4564: return true;
4565: return false;
4566: }
4567:
4568: final private boolean jj_3R_245() {
4569: if (jj_scan_token(_DEFAULT))
4570: return true;
4571: if (jj_scan_token(COLON))
4572: return true;
4573: return false;
4574: }
4575:
4576: final private boolean jj_3R_227() {
4577: if (jj_scan_token(COMMA))
4578: return true;
4579: if (jj_3R_197())
4580: return true;
4581: return false;
4582: }
4583:
4584: final private boolean jj_3R_239() {
4585: Token xsp;
4586: xsp = jj_scanpos;
4587: if (jj_3R_244()) {
4588: jj_scanpos = xsp;
4589: if (jj_3R_245())
4590: return true;
4591: }
4592: return false;
4593: }
4594:
4595: final private boolean jj_3R_244() {
4596: if (jj_scan_token(CASE))
4597: return true;
4598: if (jj_3R_60())
4599: return true;
4600: if (jj_scan_token(COLON))
4601: return true;
4602: return false;
4603: }
4604:
4605: final private boolean jj_3R_228() {
4606: if (jj_3R_239())
4607: return true;
4608: Token xsp;
4609: while (true) {
4610: xsp = jj_scanpos;
4611: if (jj_3R_240()) {
4612: jj_scanpos = xsp;
4613: break;
4614: }
4615: }
4616: return false;
4617: }
4618:
4619: final private boolean jj_3R_129() {
4620: if (jj_scan_token(SWITCH))
4621: return true;
4622: if (jj_scan_token(LPAREN))
4623: return true;
4624: if (jj_3R_60())
4625: return true;
4626: if (jj_scan_token(RPAREN))
4627: return true;
4628: if (jj_scan_token(LBRACE))
4629: return true;
4630: Token xsp;
4631: while (true) {
4632: xsp = jj_scanpos;
4633: if (jj_3R_228()) {
4634: jj_scanpos = xsp;
4635: break;
4636: }
4637: }
4638: if (jj_scan_token(RBRACE))
4639: return true;
4640: return false;
4641: }
4642:
4643: final private boolean jj_3R_243() {
4644: if (jj_3R_110())
4645: return true;
4646: if (jj_3R_60())
4647: return true;
4648: return false;
4649: }
4650:
4651: final private boolean jj_3R_238() {
4652: Token xsp;
4653: xsp = jj_scanpos;
4654: if (jj_scan_token(98)) {
4655: jj_scanpos = xsp;
4656: if (jj_scan_token(99)) {
4657: jj_scanpos = xsp;
4658: if (jj_3R_243())
4659: return true;
4660: }
4661: }
4662: return false;
4663: }
4664:
4665: final private boolean jj_3R_145() {
4666: if (jj_3R_53())
4667: return true;
4668: Token xsp;
4669: xsp = jj_scanpos;
4670: if (jj_3R_238())
4671: jj_scanpos = xsp;
4672: return false;
4673: }
4674:
4675: final private boolean jj_3R_144() {
4676: if (jj_3R_152())
4677: return true;
4678: return false;
4679: }
4680:
4681: final private boolean jj_3R_128() {
4682: Token xsp;
4683: xsp = jj_scanpos;
4684: if (jj_3R_143()) {
4685: jj_scanpos = xsp;
4686: if (jj_3R_144()) {
4687: jj_scanpos = xsp;
4688: if (jj_3R_145())
4689: return true;
4690: }
4691: }
4692: return false;
4693: }
4694:
4695: final private boolean jj_3R_143() {
4696: if (jj_3R_151())
4697: return true;
4698: return false;
4699: }
4700:
4701: final private boolean jj_3R_104() {
4702: Token xsp;
4703: xsp = jj_scanpos;
4704: if (jj_scan_token(29))
4705: jj_scanpos = xsp;
4706: if (jj_3R_62())
4707: return true;
4708: if (jj_3R_197())
4709: return true;
4710: while (true) {
4711: xsp = jj_scanpos;
4712: if (jj_3R_227()) {
4713: jj_scanpos = xsp;
4714: break;
4715: }
4716: }
4717: return false;
4718: }
4719:
4720: final private boolean jj_3_29() {
4721: Token xsp;
4722: xsp = jj_scanpos;
4723: if (jj_scan_token(29))
4724: jj_scanpos = xsp;
4725: if (jj_3R_62())
4726: return true;
4727: if (jj_scan_token(IDENTIFIER))
4728: return true;
4729: return false;
4730: }
4731:
4732: final private boolean jj_3R_100() {
4733: if (jj_3R_107())
4734: return true;
4735: return false;
4736: }
4737:
4738: final private boolean jj_3R_99() {
4739: if (jj_3R_106())
4740: return true;
4741: return false;
4742: }
4743:
4744: final private boolean jj_3R_98() {
4745: if (jj_3R_105())
4746: return true;
4747: return false;
4748: }
4749:
4750: final private boolean jj_3R_97() {
4751: if (jj_3R_104())
4752: return true;
4753: if (jj_scan_token(SEMICOLON))
4754: return true;
4755: return false;
4756: }
4757:
4758: final private boolean jj_3R_93() {
4759: Token xsp;
4760: xsp = jj_scanpos;
4761: if (jj_3R_97()) {
4762: jj_scanpos = xsp;
4763: if (jj_3R_98()) {
4764: jj_scanpos = xsp;
4765: if (jj_3R_99()) {
4766: jj_scanpos = xsp;
4767: if (jj_3R_100())
4768: return true;
4769: }
4770: }
4771: }
4772: return false;
4773: }
4774:
4775: final private boolean jj_3R_82() {
4776: if (jj_3R_93())
4777: return true;
4778: return false;
4779: }
4780:
4781: final private boolean jj_3R_63() {
4782: if (jj_scan_token(LBRACE))
4783: return true;
4784: Token xsp;
4785: while (true) {
4786: xsp = jj_scanpos;
4787: if (jj_3R_82()) {
4788: jj_scanpos = xsp;
4789: break;
4790: }
4791: }
4792: if (jj_scan_token(RBRACE))
4793: return true;
4794: return false;
4795: }
4796:
4797: final private boolean jj_3R_61() {
4798: if (jj_scan_token(IDENTIFIER))
4799: return true;
4800: if (jj_scan_token(COLON))
4801: return true;
4802: if (jj_3R_105())
4803: return true;
4804: return false;
4805: }
4806:
4807: final private boolean jj_3R_125() {
4808: if (jj_3R_140())
4809: return true;
4810: return false;
4811: }
4812:
4813: final private boolean jj_3R_124() {
4814: if (jj_3R_139())
4815: return true;
4816: return false;
4817: }
4818:
4819: final private boolean jj_3_26() {
4820: if (jj_scan_token(LBRACKET))
4821: return true;
4822: if (jj_scan_token(RBRACKET))
4823: return true;
4824: return false;
4825: }
4826:
4827: final private boolean jj_3R_123() {
4828: if (jj_3R_138())
4829: return true;
4830: return false;
4831: }
4832:
4833: final private boolean jj_3R_122() {
4834: if (jj_3R_137())
4835: return true;
4836: return false;
4837: }
4838:
4839: final private boolean jj_3R_121() {
4840: if (jj_3R_136())
4841: return true;
4842: return false;
4843: }
4844:
4845: final private boolean jj_3R_120() {
4846: if (jj_3R_135())
4847: return true;
4848: return false;
4849: }
4850:
4851: final private boolean jj_3R_119() {
4852: if (jj_3R_134())
4853: return true;
4854: return false;
4855: }
4856:
4857: final private boolean jj_3R_118() {
4858: if (jj_3R_133())
4859: return true;
4860: return false;
4861: }
4862:
4863: final private boolean jj_3R_117() {
4864: if (jj_3R_132())
4865: return true;
4866: return false;
4867: }
4868:
4869: final private boolean jj_3R_116() {
4870: if (jj_3R_131())
4871: return true;
4872: return false;
4873: }
4874:
4875: final private boolean jj_3R_115() {
4876: if (jj_3R_130())
4877: return true;
4878: return false;
4879: }
4880:
4881: final private boolean jj_3R_114() {
4882: if (jj_3R_129())
4883: return true;
4884: return false;
4885: }
4886:
4887: final private boolean jj_3R_113() {
4888: if (jj_3R_128())
4889: return true;
4890: if (jj_scan_token(SEMICOLON))
4891: return true;
4892: return false;
4893: }
4894:
4895: final private boolean jj_3R_112() {
4896: if (jj_3R_63())
4897: return true;
4898: return false;
4899: }
4900:
4901: final private boolean jj_3R_105() {
4902: Token xsp;
4903: xsp = jj_scanpos;
4904: if (jj_3_28()) {
4905: jj_scanpos = xsp;
4906: if (jj_3R_112()) {
4907: jj_scanpos = xsp;
4908: if (jj_scan_token(82)) {
4909: jj_scanpos = xsp;
4910: if (jj_3R_113()) {
4911: jj_scanpos = xsp;
4912: if (jj_3R_114()) {
4913: jj_scanpos = xsp;
4914: if (jj_3R_115()) {
4915: jj_scanpos = xsp;
4916: if (jj_3R_116()) {
4917: jj_scanpos = xsp;
4918: if (jj_3R_117()) {
4919: jj_scanpos = xsp;
4920: if (jj_3R_118()) {
4921: jj_scanpos = xsp;
4922: if (jj_3R_119()) {
4923: jj_scanpos = xsp;
4924: if (jj_3R_120()) {
4925: jj_scanpos = xsp;
4926: if (jj_3R_121()) {
4927: jj_scanpos = xsp;
4928: if (jj_3R_122()) {
4929: jj_scanpos = xsp;
4930: if (jj_3R_123()) {
4931: jj_scanpos = xsp;
4932: if (jj_3R_124()) {
4933: jj_scanpos = xsp;
4934: if (jj_3R_125())
4935: return true;
4936: }
4937: }
4938: }
4939: }
4940: }
4941: }
4942: }
4943: }
4944: }
4945: }
4946: }
4947: }
4948: }
4949: }
4950: }
4951: return false;
4952: }
4953:
4954: final private boolean jj_3_28() {
4955: if (jj_3R_61())
4956: return true;
4957: return false;
4958: }
4959:
4960: final private boolean jj_3R_154() {
4961: if (jj_3R_158())
4962: return true;
4963: return false;
4964: }
4965:
4966: final private boolean jj_3R_157() {
4967: if (jj_scan_token(LBRACKET))
4968: return true;
4969: if (jj_scan_token(RBRACKET))
4970: return true;
4971: return false;
4972: }
4973:
4974: final private boolean jj_3_25() {
4975: if (jj_scan_token(LBRACKET))
4976: return true;
4977: if (jj_3R_60())
4978: return true;
4979: if (jj_scan_token(RBRACKET))
4980: return true;
4981: return false;
4982: }
4983:
4984: final private boolean jj_3R_153() {
4985: Token xsp;
4986: if (jj_3R_157())
4987: return true;
4988: while (true) {
4989: xsp = jj_scanpos;
4990: if (jj_3R_157()) {
4991: jj_scanpos = xsp;
4992: break;
4993: }
4994: }
4995: if (jj_3R_83())
4996: return true;
4997: return false;
4998: }
4999:
5000: final private boolean jj_3_27() {
5001: Token xsp;
5002: if (jj_3_25())
5003: return true;
5004: while (true) {
5005: xsp = jj_scanpos;
5006: if (jj_3_25()) {
5007: jj_scanpos = xsp;
5008: break;
5009: }
5010: }
5011: while (true) {
5012: xsp = jj_scanpos;
5013: if (jj_3_26()) {
5014: jj_scanpos = xsp;
5015: break;
5016: }
5017: }
5018: return false;
5019: }
5020:
5021: final private boolean jj_3R_146() {
5022: Token xsp;
5023: xsp = jj_scanpos;
5024: if (jj_3_27()) {
5025: jj_scanpos = xsp;
5026: if (jj_3R_153())
5027: return true;
5028: }
5029: return false;
5030: }
5031:
5032: final private boolean jj_3R_148() {
5033: if (jj_3R_54())
5034: return true;
5035: Token xsp;
5036: xsp = jj_scanpos;
5037: if (jj_3R_154())
5038: jj_scanpos = xsp;
5039: return false;
5040: }
5041:
5042: final private boolean jj_3R_95() {
5043: if (jj_scan_token(COMMA))
5044: return true;
5045: if (jj_3R_60())
5046: return true;
5047: return false;
5048: }
5049:
5050: final private boolean jj_3R_147() {
5051: if (jj_3R_146())
5052: return true;
5053: return false;
5054: }
5055:
5056: final private boolean jj_3R_77() {
5057: if (jj_scan_token(NEW))
5058: return true;
5059: if (jj_3R_47())
5060: return true;
5061: Token xsp;
5062: xsp = jj_scanpos;
5063: if (jj_3R_147()) {
5064: jj_scanpos = xsp;
5065: if (jj_3R_148())
5066: return true;
5067: }
5068: return false;
5069: }
5070:
5071: final private boolean jj_3_24() {
5072: if (jj_scan_token(NEW))
5073: return true;
5074: if (jj_3R_56())
5075: return true;
5076: if (jj_3R_146())
5077: return true;
5078: return false;
5079: }
5080:
5081: final private boolean jj_3R_59() {
5082: Token xsp;
5083: xsp = jj_scanpos;
5084: if (jj_3_24()) {
5085: jj_scanpos = xsp;
5086: if (jj_3R_77())
5087: return true;
5088: }
5089: return false;
5090: }
5091:
5092: final private boolean jj_3R_90() {
5093: if (jj_3R_60())
5094: return true;
5095: Token xsp;
5096: while (true) {
5097: xsp = jj_scanpos;
5098: if (jj_3R_95()) {
5099: jj_scanpos = xsp;
5100: break;
5101: }
5102: }
5103: return false;
5104: }
5105:
5106: final private boolean jj_3R_70() {
5107: if (jj_3R_90())
5108: return true;
5109: return false;
5110: }
5111:
5112: final private boolean jj_3R_54() {
5113: if (jj_scan_token(LPAREN))
5114: return true;
5115: Token xsp;
5116: xsp = jj_scanpos;
5117: if (jj_3R_70())
5118: jj_scanpos = xsp;
5119: if (jj_scan_token(RPAREN))
5120: return true;
5121: return false;
5122: }
5123:
5124: final private boolean jj_3R_108() {
5125: Token xsp;
5126: xsp = jj_scanpos;
5127: if (jj_scan_token(58)) {
5128: jj_scanpos = xsp;
5129: if (jj_scan_token(28))
5130: return true;
5131: }
5132: return false;
5133: }
5134:
5135: final private boolean jj_3R_91() {
5136: if (jj_3R_94())
5137: return true;
5138: return false;
5139: }
5140:
5141: final private boolean jj_3R_101() {
5142: if (jj_3R_108())
5143: return true;
5144: return false;
5145: }
5146:
5147: final private boolean jj_3R_94() {
5148: Token xsp;
5149: xsp = jj_scanpos;
5150: if (jj_scan_token(65)) {
5151: jj_scanpos = xsp;
5152: if (jj_scan_token(69)) {
5153: jj_scanpos = xsp;
5154: if (jj_scan_token(71)) {
5155: jj_scanpos = xsp;
5156: if (jj_scan_token(72)) {
5157: jj_scanpos = xsp;
5158: if (jj_3R_101()) {
5159: jj_scanpos = xsp;
5160: if (jj_scan_token(43))
5161: return true;
5162: }
5163: }
5164: }
5165: }
5166: }
5167: return false;
5168: }
5169:
5170: final private boolean jj_3R_75() {
5171: if (jj_3R_54())
5172: return true;
5173: return false;
5174: }
5175:
5176: final private boolean jj_3R_74() {
5177: if (jj_scan_token(DOT))
5178: return true;
5179: if (jj_scan_token(IDENTIFIER))
5180: return true;
5181: return false;
5182: }
5183:
5184: final private boolean jj_3R_73() {
5185: if (jj_scan_token(LBRACKET))
5186: return true;
5187: if (jj_3R_60())
5188: return true;
5189: if (jj_scan_token(RBRACKET))
5190: return true;
5191: return false;
5192: }
5193:
5194: final private boolean jj_3_23() {
5195: if (jj_scan_token(DOT))
5196: return true;
5197: if (jj_3R_59())
5198: return true;
5199: return false;
5200: }
5201:
5202: final private boolean jj_3_22() {
5203: if (jj_scan_token(DOT))
5204: return true;
5205: if (jj_scan_token(SUPER))
5206: return true;
5207: return false;
5208: }
5209:
5210: final private boolean jj_3_21() {
5211: if (jj_scan_token(DOT))
5212: return true;
5213: if (jj_scan_token(THIS))
5214: return true;
5215: return false;
5216: }
5217:
5218: final private boolean jj_3R_57() {
5219: Token xsp;
5220: xsp = jj_scanpos;
5221: if (jj_3_21()) {
5222: jj_scanpos = xsp;
5223: if (jj_3_22()) {
5224: jj_scanpos = xsp;
5225: if (jj_3_23()) {
5226: jj_scanpos = xsp;
5227: if (jj_3R_73()) {
5228: jj_scanpos = xsp;
5229: if (jj_3R_74()) {
5230: jj_scanpos = xsp;
5231: if (jj_3R_75())
5232: return true;
5233: }
5234: }
5235: }
5236: }
5237: }
5238: return false;
5239: }
5240:
5241: final private boolean jj_3_20() {
5242: if (jj_3R_58())
5243: return true;
5244: if (jj_scan_token(DOT))
5245: return true;
5246: if (jj_scan_token(CLASS))
5247: return true;
5248: return false;
5249: }
5250:
5251: final private boolean jj_3R_89() {
5252: if (jj_3R_47())
5253: return true;
5254: return false;
5255: }
5256:
5257: final private boolean jj_3_19() {
5258: if (jj_3R_57())
5259: return true;
5260: return false;
5261: }
5262:
5263: final private boolean jj_3R_88() {
5264: if (jj_3R_58())
5265: return true;
5266: if (jj_scan_token(DOT))
5267: return true;
5268: if (jj_scan_token(CLASS))
5269: return true;
5270: return false;
5271: }
5272:
5273: final private boolean jj_3R_87() {
5274: if (jj_3R_59())
5275: return true;
5276: return false;
5277: }
5278:
5279: final private boolean jj_3R_86() {
5280: if (jj_scan_token(LPAREN))
5281: return true;
5282: if (jj_3R_60())
5283: return true;
5284: if (jj_scan_token(RPAREN))
5285: return true;
5286: return false;
5287: }
5288:
5289: final private boolean jj_3R_85() {
5290: if (jj_scan_token(SUPER))
5291: return true;
5292: if (jj_scan_token(DOT))
5293: return true;
5294: if (jj_scan_token(IDENTIFIER))
5295: return true;
5296: return false;
5297: }
5298:
5299: final private boolean jj_3R_237() {
5300: Token xsp;
5301: xsp = jj_scanpos;
5302: if (jj_scan_token(98)) {
5303: jj_scanpos = xsp;
5304: if (jj_scan_token(99))
5305: return true;
5306: }
5307: return false;
5308: }
5309:
5310: final private boolean jj_3R_84() {
5311: if (jj_3R_94())
5312: return true;
5313: return false;
5314: }
5315:
5316: final private boolean jj_3R_69() {
5317: Token xsp;
5318: xsp = jj_scanpos;
5319: if (jj_3R_84()) {
5320: jj_scanpos = xsp;
5321: if (jj_scan_token(54)) {
5322: jj_scanpos = xsp;
5323: if (jj_3R_85()) {
5324: jj_scanpos = xsp;
5325: if (jj_3R_86()) {
5326: jj_scanpos = xsp;
5327: if (jj_3R_87()) {
5328: jj_scanpos = xsp;
5329: if (jj_3R_88()) {
5330: jj_scanpos = xsp;
5331: if (jj_3R_89())
5332: return true;
5333: }
5334: }
5335: }
5336: }
5337: }
5338: }
5339: return false;
5340: }
5341:
5342: final private boolean jj_3_18() {
5343: if (jj_scan_token(LPAREN))
5344: return true;
5345: if (jj_3R_56())
5346: return true;
5347: return false;
5348: }
5349:
5350: final private boolean jj_3R_53() {
5351: if (jj_3R_69())
5352: return true;
5353: Token xsp;
5354: while (true) {
5355: xsp = jj_scanpos;
5356: if (jj_3_19()) {
5357: jj_scanpos = xsp;
5358: break;
5359: }
5360: }
5361: return false;
5362: }
5363:
5364: final private boolean jj_3R_226() {
5365: if (jj_scan_token(LPAREN))
5366: return true;
5367: if (jj_3R_62())
5368: return true;
5369: if (jj_scan_token(RPAREN))
5370: return true;
5371: if (jj_3R_200())
5372: return true;
5373: return false;
5374: }
5375:
5376: final private boolean jj_3R_219() {
5377: Token xsp;
5378: xsp = jj_scanpos;
5379: if (jj_3R_225()) {
5380: jj_scanpos = xsp;
5381: if (jj_3R_226())
5382: return true;
5383: }
5384: return false;
5385: }
5386:
5387: final private boolean jj_3R_225() {
5388: if (jj_scan_token(LPAREN))
5389: return true;
5390: if (jj_3R_62())
5391: return true;
5392: if (jj_scan_token(RPAREN))
5393: return true;
5394: if (jj_3R_174())
5395: return true;
5396: return false;
5397: }
5398:
5399: final private boolean jj_3_17() {
5400: if (jj_scan_token(LPAREN))
5401: return true;
5402: if (jj_3R_47())
5403: return true;
5404: if (jj_scan_token(LBRACKET))
5405: return true;
5406: return false;
5407: }
5408:
5409: final private boolean jj_3R_220() {
5410: if (jj_3R_53())
5411: return true;
5412: Token xsp;
5413: xsp = jj_scanpos;
5414: if (jj_3R_237())
5415: jj_scanpos = xsp;
5416: return false;
5417: }
5418:
5419: final private boolean jj_3R_72() {
5420: if (jj_scan_token(LPAREN))
5421: return true;
5422: if (jj_3R_47())
5423: return true;
5424: if (jj_scan_token(RPAREN))
5425: return true;
5426: Token xsp;
5427: xsp = jj_scanpos;
5428: if (jj_scan_token(89)) {
5429: jj_scanpos = xsp;
5430: if (jj_scan_token(88)) {
5431: jj_scanpos = xsp;
5432: if (jj_scan_token(76)) {
5433: jj_scanpos = xsp;
5434: if (jj_scan_token(73)) {
5435: jj_scanpos = xsp;
5436: if (jj_scan_token(54)) {
5437: jj_scanpos = xsp;
5438: if (jj_scan_token(51)) {
5439: jj_scanpos = xsp;
5440: if (jj_scan_token(42)) {
5441: jj_scanpos = xsp;
5442: if (jj_3R_91())
5443: return true;
5444: }
5445: }
5446: }
5447: }
5448: }
5449: }
5450: }
5451: return false;
5452: }
5453:
5454: final private boolean jj_3R_71() {
5455: if (jj_scan_token(LPAREN))
5456: return true;
5457: if (jj_3R_47())
5458: return true;
5459: if (jj_scan_token(LBRACKET))
5460: return true;
5461: if (jj_scan_token(RBRACKET))
5462: return true;
5463: return false;
5464: }
5465:
5466: final private boolean jj_3_16() {
5467: if (jj_scan_token(LPAREN))
5468: return true;
5469: if (jj_3R_56())
5470: return true;
5471: return false;
5472: }
5473:
5474: final private boolean jj_3R_55() {
5475: Token xsp;
5476: xsp = jj_scanpos;
5477: if (jj_3_16()) {
5478: jj_scanpos = xsp;
5479: if (jj_3R_71()) {
5480: jj_scanpos = xsp;
5481: if (jj_3R_72())
5482: return true;
5483: }
5484: }
5485: return false;
5486: }
5487:
5488: final private boolean jj_3_15() {
5489: if (jj_3R_55())
5490: return true;
5491: return false;
5492: }
5493:
5494: final private boolean jj_3R_213() {
5495: if (jj_3R_220())
5496: return true;
5497: return false;
5498: }
5499:
5500: final private boolean jj_3R_212() {
5501: if (jj_3R_219())
5502: return true;
5503: return false;
5504: }
5505:
5506: final private boolean jj_3R_200() {
5507: Token xsp;
5508: xsp = jj_scanpos;
5509: if (jj_3R_211()) {
5510: jj_scanpos = xsp;
5511: if (jj_3R_212()) {
5512: jj_scanpos = xsp;
5513: if (jj_3R_213())
5514: return true;
5515: }
5516: }
5517: return false;
5518: }
5519:
5520: final private boolean jj_3R_211() {
5521: Token xsp;
5522: xsp = jj_scanpos;
5523: if (jj_scan_token(89)) {
5524: jj_scanpos = xsp;
5525: if (jj_scan_token(88))
5526: return true;
5527: }
5528: if (jj_3R_174())
5529: return true;
5530: return false;
5531: }
5532:
5533: final private boolean jj_3R_152() {
5534: if (jj_scan_token(DECR))
5535: return true;
5536: if (jj_3R_53())
5537: return true;
5538: return false;
5539: }
5540:
5541: final private boolean jj_3R_199() {
5542: Token xsp;
5543: xsp = jj_scanpos;
5544: if (jj_scan_token(100)) {
5545: jj_scanpos = xsp;
5546: if (jj_scan_token(101))
5547: return true;
5548: }
5549: if (jj_3R_167())
5550: return true;
5551: return false;
5552: }
5553:
5554: final private boolean jj_3R_210() {
5555: Token xsp;
5556: xsp = jj_scanpos;
5557: if (jj_scan_token(102)) {
5558: jj_scanpos = xsp;
5559: if (jj_scan_token(103)) {
5560: jj_scanpos = xsp;
5561: if (jj_scan_token(107))
5562: return true;
5563: }
5564: }
5565: if (jj_3R_174())
5566: return true;
5567: return false;
5568: }
5569:
5570: final private boolean jj_3R_151() {
5571: if (jj_scan_token(INCR))
5572: return true;
5573: if (jj_3R_53())
5574: return true;
5575: return false;
5576: }
5577:
5578: final private boolean jj_3R_184() {
5579: if (jj_3R_200())
5580: return true;
5581: return false;
5582: }
5583:
5584: final private boolean jj_3R_180() {
5585: Token xsp;
5586: xsp = jj_scanpos;
5587: if (jj_scan_token(108)) {
5588: jj_scanpos = xsp;
5589: if (jj_scan_token(109)) {
5590: jj_scanpos = xsp;
5591: if (jj_scan_token(110))
5592: return true;
5593: }
5594: }
5595: if (jj_3R_164())
5596: return true;
5597: return false;
5598: }
5599:
5600: final private boolean jj_3R_183() {
5601: if (jj_3R_152())
5602: return true;
5603: return false;
5604: }
5605:
5606: final private boolean jj_3R_182() {
5607: if (jj_3R_151())
5608: return true;
5609: return false;
5610: }
5611:
5612: final private boolean jj_3R_174() {
5613: Token xsp;
5614: xsp = jj_scanpos;
5615: if (jj_3R_181()) {
5616: jj_scanpos = xsp;
5617: if (jj_3R_182()) {
5618: jj_scanpos = xsp;
5619: if (jj_3R_183()) {
5620: jj_scanpos = xsp;
5621: if (jj_3R_184())
5622: return true;
5623: }
5624: }
5625: }
5626: return false;
5627: }
5628:
5629: final private boolean jj_3R_181() {
5630: Token xsp;
5631: xsp = jj_scanpos;
5632: if (jj_scan_token(100)) {
5633: jj_scanpos = xsp;
5634: if (jj_scan_token(101))
5635: return true;
5636: }
5637: if (jj_3R_174())
5638: return true;
5639: return false;
5640: }
5641:
5642: final private boolean jj_3R_173() {
5643: Token xsp;
5644: xsp = jj_scanpos;
5645: if (jj_scan_token(87)) {
5646: jj_scanpos = xsp;
5647: if (jj_scan_token(86)) {
5648: jj_scanpos = xsp;
5649: if (jj_scan_token(93)) {
5650: jj_scanpos = xsp;
5651: if (jj_scan_token(94))
5652: return true;
5653: }
5654: }
5655: }
5656: if (jj_3R_160())
5657: return true;
5658: return false;
5659: }
5660:
5661: final private boolean jj_3R_166() {
5662: if (jj_scan_token(INSTANCEOF))
5663: return true;
5664: if (jj_3R_62())
5665: return true;
5666: return false;
5667: }
5668:
5669: final private boolean jj_3R_167() {
5670: if (jj_3R_174())
5671: return true;
5672: Token xsp;
5673: while (true) {
5674: xsp = jj_scanpos;
5675: if (jj_3R_210()) {
5676: jj_scanpos = xsp;
5677: break;
5678: }
5679: }
5680: return false;
5681: }
5682:
5683: final private boolean jj_3R_163() {
5684: Token xsp;
5685: xsp = jj_scanpos;
5686: if (jj_scan_token(92)) {
5687: jj_scanpos = xsp;
5688: if (jj_scan_token(95))
5689: return true;
5690: }
5691: if (jj_3R_150())
5692: return true;
5693: return false;
5694: }
5695:
5696: final private boolean jj_3R_164() {
5697: if (jj_3R_167())
5698: return true;
5699: Token xsp;
5700: while (true) {
5701: xsp = jj_scanpos;
5702: if (jj_3R_199()) {
5703: jj_scanpos = xsp;
5704: break;
5705: }
5706: }
5707: return false;
5708: }
5709:
5710: final private boolean jj_3R_160() {
5711: if (jj_3R_164())
5712: return true;
5713: Token xsp;
5714: while (true) {
5715: xsp = jj_scanpos;
5716: if (jj_3R_180()) {
5717: jj_scanpos = xsp;
5718: break;
5719: }
5720: }
5721: return false;
5722: }
5723:
5724: final private boolean jj_3R_159() {
5725: if (jj_scan_token(BIT_AND))
5726: return true;
5727: if (jj_3R_142())
5728: return true;
5729: return false;
5730: }
5731:
5732: final private boolean jj_3R_156() {
5733: if (jj_3R_160())
5734: return true;
5735: Token xsp;
5736: while (true) {
5737: xsp = jj_scanpos;
5738: if (jj_3R_173()) {
5739: jj_scanpos = xsp;
5740: break;
5741: }
5742: }
5743: return false;
5744: }
5745:
5746: final private boolean jj_3R_149() {
5747: if (jj_scan_token(BIT_OR))
5748: return true;
5749: if (jj_3R_111())
5750: return true;
5751: return false;
5752: }
5753:
5754: final private boolean jj_3R_150() {
5755: if (jj_3R_156())
5756: return true;
5757: Token xsp;
5758: xsp = jj_scanpos;
5759: if (jj_3R_166())
5760: jj_scanpos = xsp;
5761: return false;
5762: }
5763:
5764: final private boolean jj_3R_155() {
5765: if (jj_scan_token(XOR))
5766: return true;
5767: if (jj_3R_127())
5768: return true;
5769: return false;
5770: }
5771:
5772: final private boolean jj_3R_141() {
5773: if (jj_scan_token(SC_AND))
5774: return true;
5775: if (jj_3R_103())
5776: return true;
5777: return false;
5778: }
5779:
5780: final private boolean jj_3R_142() {
5781: if (jj_3R_150())
5782: return true;
5783: Token xsp;
5784: while (true) {
5785: xsp = jj_scanpos;
5786: if (jj_3R_163()) {
5787: jj_scanpos = xsp;
5788: break;
5789: }
5790: }
5791: return false;
5792: }
5793:
5794: final private boolean jj_3R_126() {
5795: if (jj_scan_token(SC_OR))
5796: return true;
5797: if (jj_3R_96())
5798: return true;
5799: return false;
5800: }
5801:
5802: final private boolean jj_3R_127() {
5803: if (jj_3R_142())
5804: return true;
5805: Token xsp;
5806: while (true) {
5807: xsp = jj_scanpos;
5808: if (jj_3R_159()) {
5809: jj_scanpos = xsp;
5810: break;
5811: }
5812: }
5813: return false;
5814: }
5815:
5816: final private boolean jj_3R_109() {
5817: if (jj_scan_token(HOOK))
5818: return true;
5819: if (jj_3R_60())
5820: return true;
5821: if (jj_scan_token(COLON))
5822: return true;
5823: if (jj_3R_78())
5824: return true;
5825: return false;
5826: }
5827:
5828: final private boolean jj_3R_111() {
5829: if (jj_3R_127())
5830: return true;
5831: Token xsp;
5832: while (true) {
5833: xsp = jj_scanpos;
5834: if (jj_3R_155()) {
5835: jj_scanpos = xsp;
5836: break;
5837: }
5838: }
5839: return false;
5840: }
5841:
5842: final private boolean jj_3R_103() {
5843: if (jj_3R_111())
5844: return true;
5845: Token xsp;
5846: while (true) {
5847: xsp = jj_scanpos;
5848: if (jj_3R_149()) {
5849: jj_scanpos = xsp;
5850: break;
5851: }
5852: }
5853: return false;
5854: }
5855:
5856: final private boolean jj_3R_96() {
5857: if (jj_3R_103())
5858: return true;
5859: Token xsp;
5860: while (true) {
5861: xsp = jj_scanpos;
5862: if (jj_3R_141()) {
5863: jj_scanpos = xsp;
5864: break;
5865: }
5866: }
5867: return false;
5868: }
5869:
5870: final private boolean jj_3R_92() {
5871: if (jj_3R_96())
5872: return true;
5873: Token xsp;
5874: while (true) {
5875: xsp = jj_scanpos;
5876: if (jj_3R_126()) {
5877: jj_scanpos = xsp;
5878: break;
5879: }
5880: }
5881: return false;
5882: }
5883:
5884: final private boolean jj_3R_78() {
5885: if (jj_3R_92())
5886: return true;
5887: Token xsp;
5888: xsp = jj_scanpos;
5889: if (jj_3R_109())
5890: jj_scanpos = xsp;
5891: return false;
5892: }
5893:
5894: final private boolean jj_3R_110() {
5895: Token xsp;
5896: xsp = jj_scanpos;
5897: if (jj_scan_token(85)) {
5898: jj_scanpos = xsp;
5899: if (jj_scan_token(113)) {
5900: jj_scanpos = xsp;
5901: if (jj_scan_token(114)) {
5902: jj_scanpos = xsp;
5903: if (jj_scan_token(118)) {
5904: jj_scanpos = xsp;
5905: if (jj_scan_token(111)) {
5906: jj_scanpos = xsp;
5907: if (jj_scan_token(112)) {
5908: jj_scanpos = xsp;
5909: if (jj_scan_token(119)) {
5910: jj_scanpos = xsp;
5911: if (jj_scan_token(120)) {
5912: jj_scanpos = xsp;
5913: if (jj_scan_token(121)) {
5914: jj_scanpos = xsp;
5915: if (jj_scan_token(115)) {
5916: jj_scanpos = xsp;
5917: if (jj_scan_token(117)) {
5918: jj_scanpos = xsp;
5919: if (jj_scan_token(116))
5920: return true;
5921: }
5922: }
5923: }
5924: }
5925: }
5926: }
5927: }
5928: }
5929: }
5930: }
5931: }
5932: return false;
5933: }
5934:
5935: public JavaParserTokenManager token_source;
5936: JavaCharStream jj_input_stream;
5937: public Token token, jj_nt;
5938: private int jj_ntk;
5939: private Token jj_scanpos, jj_lastpos;
5940: private int jj_la;
5941: public boolean lookingAhead = false;
5942: private boolean jj_semLA;
5943: private int jj_gen;
5944: final private int[] jj_la1 = new int[113];
5945: static private int[] jj_la1_0;
5946: static private int[] jj_la1_1;
5947: static private int[] jj_la1_2;
5948: static private int[] jj_la1_3;
5949: static {
5950: jj_la1_0();
5951: jj_la1_1();
5952: jj_la1_2();
5953: jj_la1_3();
5954: }
5955:
5956: private static void jj_la1_0() {
5957: jj_la1_0 = new int[] { 0x0, 0x0, 0x20102000, 0x0, 0x2000,
5958: 0x20002000, 0x20002000, 0x8000000, 0x0, 0xa2196000,
5959: 0x20002000, 0x20002000, 0xa2094000, 0x20002000,
5960: 0x20002000, 0x2000, 0x2000, 0x20002000, 0x20002000,
5961: 0x8000000, 0xa2196000, 0xa2094000, 0x20000000,
5962: 0x20000000, 0x0, 0x0, 0x0, 0x92094000, 0x92094000, 0x0,
5963: 0x20002000, 0x20002000, 0x0, 0x0, 0x0, 0x0, 0xa2094000,
5964: 0x20000000, 0x0, 0x0, 0x0, 0xb359c000, 0x92094000, 0x0,
5965: 0x82094000, 0x0, 0x82094000, 0x82094000, 0x0, 0x0, 0x0,
5966: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
5967: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x92094000, 0x0,
5968: 0x0, 0x92094000, 0x10000000, 0x0, 0x0, 0x0, 0x0,
5969: 0x10000000, 0x0, 0x0, 0x10000000, 0x10000000,
5970: 0x92094000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x9349c000,
5971: 0xb359c000, 0x9359c000, 0x20000000, 0x0, 0x0, 0x0,
5972: 0x92094000, 0x820000, 0xb359c000, 0x820000, 0x4000000,
5973: 0xb2094000, 0x92094000, 0x92094000, 0x92094000, 0x0,
5974: 0x0, 0x0, 0x92094000, 0x40000, 0x40000000, 0x0, };
5975: }
5976:
5977: private static void jj_la1_1() {
5978: jj_la1_1 = new int[] { 0x1000, 0x10, 0x80008080, 0x0,
5979: 0x80008080, 0x80008000, 0x80008000, 0x0, 0x8,
5980: 0xb226e3c0, 0x8004e000, 0x8004e000, 0x2206e140,
5981: 0x8024e200, 0x8024e200, 0x80008000, 0x80008000,
5982: 0x8004e000, 0x8004e000, 0x0, 0xb226e3c0, 0x2206e140,
5983: 0x2204e000, 0x2204e000, 0x0, 0x0, 0x0, 0x144a0d40,
5984: 0x144a0d40, 0x0, 0x8024e200, 0x8024e200, 0x1000000,
5985: 0x0, 0x0, 0x0, 0x20140, 0x0, 0xe000, 0xe000, 0x1000000,
5986: 0x5cfb0dc5, 0x144a0d40, 0x40000, 0x20140, 0x0, 0x20140,
5987: 0x10020140, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
5988: 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
5989: 0x0, 0x0, 0x144a0d40, 0x0, 0x0, 0x144a0d40, 0x4480c00,
5990: 0x0, 0x0, 0x0, 0x0, 0x4480c00, 0x0, 0x0, 0x4000800,
5991: 0x4000000, 0x144a0d40, 0x0, 0x0, 0x0, 0x400, 0x0, 0x0,
5992: 0x5cfb0d45, 0x5cfb0dc5, 0x5cfb0dc5, 0x0, 0x0, 0x0, 0x0,
5993: 0x144a0d40, 0x0, 0x5cfb0dc5, 0x0, 0x0, 0x144a0d40,
5994: 0x144a0d40, 0x144a0d40, 0x144a0d40, 0x0, 0x0, 0x0,
5995: 0x144a0d40, 0x0, 0x0, 0x0, };
5996: }
5997:
5998: private static void jj_la1_2() {
5999: jj_la1_2 = new int[] { 0x0, 0x0, 0x40000, 0x100000, 0x40000,
6000: 0x0, 0x0, 0x0, 0x0, 0x44200, 0x0, 0x0, 0x40200, 0x0,
6001: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x40200, 0x40200, 0x0,
6002: 0x0, 0x80000, 0x200000, 0x10000, 0x30053a2, 0x30053a2,
6003: 0x80000, 0x0, 0x0, 0x0, 0x44000, 0x10000, 0x80000,
6004: 0x200, 0x0, 0x0, 0x0, 0x0, 0x453a3, 0x13a2, 0x0, 0x200,
6005: 0x10000, 0x0, 0x200, 0x80000, 0x200000, 0x200000,
6006: 0x4000000, 0x0, 0x0, 0x0, 0x0, 0x0, 0x90000000,
6007: 0x90000000, 0x0, 0x60c00000, 0x60c00000, 0x0, 0x0, 0x0,
6008: 0x0, 0x0, 0x0, 0x0, 0x30013a2, 0x3000000, 0x3000000,
6009: 0x13a2, 0x30013a2, 0x1000, 0x0, 0x0, 0x1000, 0x11a2,
6010: 0x200, 0x111000, 0x1a2, 0x0, 0x30013a2, 0x80000,
6011: 0x4000, 0x11000, 0x0, 0x10000, 0x10000, 0x453a3,
6012: 0x453a3, 0x453a3, 0x0, 0x80000, 0x200000, 0x200000,
6013: 0x13a2, 0x0, 0x453a3, 0x0, 0x0, 0x13a2, 0x30013a2,
6014: 0x13a2, 0x13a2, 0x80000, 0x200, 0x200, 0x30013a2, 0x0,
6015: 0x0, 0x8000000, };
6016: }
6017:
6018: private static void jj_la1_3() {
6019: jj_la1_3 = new int[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6020: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6021: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x3c,
6022: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
6023: 0x0, 0xc, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3ff8000,
6024: 0x3ff8000, 0x0, 0x1, 0x2, 0x200, 0x400, 0x100, 0x0,
6025: 0x0, 0x0, 0x0, 0x0, 0x7000, 0x7000, 0x30, 0x30, 0x8c0,
6026: 0x8c0, 0x30, 0x3c, 0x0, 0x0, 0x0, 0x0, 0x0, 0xc, 0xc,
6027: 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, 0x0,
6028: 0x0, 0x0, 0xc, 0xc, 0xc, 0x0, 0x0, 0x3ff800c,
6029: 0x3ff800c, 0xc, 0x0, 0xc, 0x0, 0x0, 0xc, 0x3c, 0xc,
6030: 0xc, 0x0, 0x0, 0x0, 0x3c, 0x0, 0x0, 0x0, };
6031: }
6032:
6033: final private JJCalls[] jj_2_rtns = new JJCalls[30];
6034: private boolean jj_rescan = false;
6035: private int jj_gc = 0;
6036:
6037: public JavaParser(java.io.InputStream stream) {
6038: this (stream, null);
6039: }
6040:
6041: public JavaParser(java.io.InputStream stream, String encoding) {
6042: try {
6043: jj_input_stream = new JavaCharStream(stream, encoding, 1, 1);
6044: } catch (java.io.UnsupportedEncodingException e) {
6045: throw new RuntimeException(e);
6046: }
6047: token_source = new JavaParserTokenManager(jj_input_stream);
6048: token = new Token();
6049: jj_ntk = -1;
6050: jj_gen = 0;
6051: for (int i = 0; i < 113; i++)
6052: jj_la1[i] = -1;
6053: for (int i = 0; i < jj_2_rtns.length; i++)
6054: jj_2_rtns[i] = new JJCalls();
6055: }
6056:
6057: public void ReInit(java.io.InputStream stream) {
6058: ReInit(stream, null);
6059: }
6060:
6061: public void ReInit(java.io.InputStream stream, String encoding) {
6062: try {
6063: jj_input_stream.ReInit(stream, encoding, 1, 1);
6064: } catch (java.io.UnsupportedEncodingException e) {
6065: throw new RuntimeException(e);
6066: }
6067: token_source.ReInit(jj_input_stream);
6068: token = new Token();
6069: jj_ntk = -1;
6070: jj_gen = 0;
6071: for (int i = 0; i < 113; i++)
6072: jj_la1[i] = -1;
6073: for (int i = 0; i < jj_2_rtns.length; i++)
6074: jj_2_rtns[i] = new JJCalls();
6075: }
6076:
6077: public JavaParser(java.io.Reader stream) {
6078: jj_input_stream = new JavaCharStream(stream, 1, 1);
6079: token_source = new JavaParserTokenManager(jj_input_stream);
6080: token = new Token();
6081: jj_ntk = -1;
6082: jj_gen = 0;
6083: for (int i = 0; i < 113; i++)
6084: jj_la1[i] = -1;
6085: for (int i = 0; i < jj_2_rtns.length; i++)
6086: jj_2_rtns[i] = new JJCalls();
6087: }
6088:
6089: public void ReInit(java.io.Reader stream) {
6090: jj_input_stream.ReInit(stream, 1, 1);
6091: token_source.ReInit(jj_input_stream);
6092: token = new Token();
6093: jj_ntk = -1;
6094: jj_gen = 0;
6095: for (int i = 0; i < 113; i++)
6096: jj_la1[i] = -1;
6097: for (int i = 0; i < jj_2_rtns.length; i++)
6098: jj_2_rtns[i] = new JJCalls();
6099: }
6100:
6101: public JavaParser(JavaParserTokenManager tm) {
6102: token_source = tm;
6103: token = new Token();
6104: jj_ntk = -1;
6105: jj_gen = 0;
6106: for (int i = 0; i < 113; i++)
6107: jj_la1[i] = -1;
6108: for (int i = 0; i < jj_2_rtns.length; i++)
6109: jj_2_rtns[i] = new JJCalls();
6110: }
6111:
6112: public void ReInit(JavaParserTokenManager tm) {
6113: token_source = tm;
6114: token = new Token();
6115: jj_ntk = -1;
6116: jj_gen = 0;
6117: for (int i = 0; i < 113; i++)
6118: jj_la1[i] = -1;
6119: for (int i = 0; i < jj_2_rtns.length; i++)
6120: jj_2_rtns[i] = new JJCalls();
6121: }
6122:
6123: final private Token jj_consume_token(int kind)
6124: throws ParseException {
6125: Token oldToken;
6126: if ((oldToken = token).next != null)
6127: token = token.next;
6128: else
6129: token = token.next = token_source.getNextToken();
6130: jj_ntk = -1;
6131: if (token.kind == kind) {
6132: jj_gen++;
6133: if (++jj_gc > 100) {
6134: jj_gc = 0;
6135: for (int i = 0; i < jj_2_rtns.length; i++) {
6136: JJCalls c = jj_2_rtns[i];
6137: while (c != null) {
6138: if (c.gen < jj_gen)
6139: c.first = null;
6140: c = c.next;
6141: }
6142: }
6143: }
6144: return token;
6145: }
6146: token = oldToken;
6147: jj_kind = kind;
6148: throw generateParseException();
6149: }
6150:
6151: static private final class LookaheadSuccess extends java.lang.Error {
6152: }
6153:
6154: final private LookaheadSuccess jj_ls = new LookaheadSuccess();
6155:
6156: final private boolean jj_scan_token(int kind) {
6157: if (jj_scanpos == jj_lastpos) {
6158: jj_la--;
6159: if (jj_scanpos.next == null) {
6160: jj_lastpos = jj_scanpos = jj_scanpos.next = token_source
6161: .getNextToken();
6162: } else {
6163: jj_lastpos = jj_scanpos = jj_scanpos.next;
6164: }
6165: } else {
6166: jj_scanpos = jj_scanpos.next;
6167: }
6168: if (jj_rescan) {
6169: int i = 0;
6170: Token tok = token;
6171: while (tok != null && tok != jj_scanpos) {
6172: i++;
6173: tok = tok.next;
6174: }
6175: if (tok != null)
6176: jj_add_error_token(kind, i);
6177: }
6178: if (jj_scanpos.kind != kind)
6179: return true;
6180: if (jj_la == 0 && jj_scanpos == jj_lastpos)
6181: throw jj_ls;
6182: return false;
6183: }
6184:
6185: final public Token getNextToken() {
6186: if (token.next != null)
6187: token = token.next;
6188: else
6189: token = token.next = token_source.getNextToken();
6190: jj_ntk = -1;
6191: jj_gen++;
6192: return token;
6193: }
6194:
6195: final public Token getToken(int index) {
6196: Token t = lookingAhead ? jj_scanpos : token;
6197: for (int i = 0; i < index; i++) {
6198: if (t.next != null)
6199: t = t.next;
6200: else
6201: t = t.next = token_source.getNextToken();
6202: }
6203: return t;
6204: }
6205:
6206: final private int jj_ntk() {
6207: if ((jj_nt = token.next) == null)
6208: return (jj_ntk = (token.next = token_source.getNextToken()).kind);
6209: else
6210: return (jj_ntk = jj_nt.kind);
6211: }
6212:
6213: private java.util.Vector jj_expentries = new java.util.Vector();
6214: private int[] jj_expentry;
6215: private int jj_kind = -1;
6216: private int[] jj_lasttokens = new int[100];
6217: private int jj_endpos;
6218:
6219: private void jj_add_error_token(int kind, int pos) {
6220: if (pos >= 100)
6221: return;
6222: if (pos == jj_endpos + 1) {
6223: jj_lasttokens[jj_endpos++] = kind;
6224: } else if (jj_endpos != 0) {
6225: jj_expentry = new int[jj_endpos];
6226: for (int i = 0; i < jj_endpos; i++) {
6227: jj_expentry[i] = jj_lasttokens[i];
6228: }
6229: boolean exists = false;
6230: for (java.util.Enumeration e = jj_expentries.elements(); e
6231: .hasMoreElements();) {
6232: int[] oldentry = (int[]) (e.nextElement());
6233: if (oldentry.length == jj_expentry.length) {
6234: exists = true;
6235: for (int i = 0; i < jj_expentry.length; i++) {
6236: if (oldentry[i] != jj_expentry[i]) {
6237: exists = false;
6238: break;
6239: }
6240: }
6241: if (exists)
6242: break;
6243: }
6244: }
6245: if (!exists)
6246: jj_expentries.addElement(jj_expentry);
6247: if (pos != 0)
6248: jj_lasttokens[(jj_endpos = pos) - 1] = kind;
6249: }
6250: }
6251:
6252: public ParseException generateParseException() {
6253: jj_expentries.removeAllElements();
6254: boolean[] la1tokens = new boolean[122];
6255: for (int i = 0; i < 122; i++) {
6256: la1tokens[i] = false;
6257: }
6258: if (jj_kind >= 0) {
6259: la1tokens[jj_kind] = true;
6260: jj_kind = -1;
6261: }
6262: for (int i = 0; i < 113; i++) {
6263: if (jj_la1[i] == jj_gen) {
6264: for (int j = 0; j < 32; j++) {
6265: if ((jj_la1_0[i] & (1 << j)) != 0) {
6266: la1tokens[j] = true;
6267: }
6268: if ((jj_la1_1[i] & (1 << j)) != 0) {
6269: la1tokens[32 + j] = true;
6270: }
6271: if ((jj_la1_2[i] & (1 << j)) != 0) {
6272: la1tokens[64 + j] = true;
6273: }
6274: if ((jj_la1_3[i] & (1 << j)) != 0) {
6275: la1tokens[96 + j] = true;
6276: }
6277: }
6278: }
6279: }
6280: for (int i = 0; i < 122; i++) {
6281: if (la1tokens[i]) {
6282: jj_expentry = new int[1];
6283: jj_expentry[0] = i;
6284: jj_expentries.addElement(jj_expentry);
6285: }
6286: }
6287: jj_endpos = 0;
6288: jj_rescan_token();
6289: jj_add_error_token(0, 0);
6290: int[][] exptokseq = new int[jj_expentries.size()][];
6291: for (int i = 0; i < jj_expentries.size(); i++) {
6292: exptokseq[i] = (int[]) jj_expentries.elementAt(i);
6293: }
6294: return new ParseException(token, exptokseq, tokenImage);
6295: }
6296:
6297: final public void enable_tracing() {
6298: }
6299:
6300: final public void disable_tracing() {
6301: }
6302:
6303: final private void jj_rescan_token() {
6304: jj_rescan = true;
6305: for (int i = 0; i < 30; i++) {
6306: try {
6307: JJCalls p = jj_2_rtns[i];
6308: do {
6309: if (p.gen > jj_gen) {
6310: jj_la = p.arg;
6311: jj_lastpos = jj_scanpos = p.first;
6312: switch (i) {
6313: case 0:
6314: jj_3_1();
6315: break;
6316: case 1:
6317: jj_3_2();
6318: break;
6319: case 2:
6320: jj_3_3();
6321: break;
6322: case 3:
6323: jj_3_4();
6324: break;
6325: case 4:
6326: jj_3_5();
6327: break;
6328: case 5:
6329: jj_3_6();
6330: break;
6331: case 6:
6332: jj_3_7();
6333: break;
6334: case 7:
6335: jj_3_8();
6336: break;
6337: case 8:
6338: jj_3_9();
6339: break;
6340: case 9:
6341: jj_3_10();
6342: break;
6343: case 10:
6344: jj_3_11();
6345: break;
6346: case 11:
6347: jj_3_12();
6348: break;
6349: case 12:
6350: jj_3_13();
6351: break;
6352: case 13:
6353: jj_3_14();
6354: break;
6355: case 14:
6356: jj_3_15();
6357: break;
6358: case 15:
6359: jj_3_16();
6360: break;
6361: case 16:
6362: jj_3_17();
6363: break;
6364: case 17:
6365: jj_3_18();
6366: break;
6367: case 18:
6368: jj_3_19();
6369: break;
6370: case 19:
6371: jj_3_20();
6372: break;
6373: case 20:
6374: jj_3_21();
6375: break;
6376: case 21:
6377: jj_3_22();
6378: break;
6379: case 22:
6380: jj_3_23();
6381: break;
6382: case 23:
6383: jj_3_24();
6384: break;
6385: case 24:
6386: jj_3_25();
6387: break;
6388: case 25:
6389: jj_3_26();
6390: break;
6391: case 26:
6392: jj_3_27();
6393: break;
6394: case 27:
6395: jj_3_28();
6396: break;
6397: case 28:
6398: jj_3_29();
6399: break;
6400: case 29:
6401: jj_3_30();
6402: break;
6403: }
6404: }
6405: p = p.next;
6406: } while (p != null);
6407: } catch (LookaheadSuccess ls) {
6408: }
6409: }
6410: jj_rescan = false;
6411: }
6412:
6413: final private void jj_save(int index, int xla) {
6414: JJCalls p = jj_2_rtns[index];
6415: while (p.gen > jj_gen) {
6416: if (p.next == null) {
6417: p = p.next = new JJCalls();
6418: break;
6419: }
6420: p = p.next;
6421: }
6422: p.gen = jj_gen + xla - jj_la;
6423: p.first = token;
6424: p.arg = xla;
6425: }
6426:
6427: static final class JJCalls {
6428: int gen;
6429: Token first;
6430: int arg;
6431: JJCalls next;
6432: }
6433:
6434: }
|