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