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