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