0001: // $ANTLR 2.7.5 (20050128): "java.g" -> "JavaRecognizer.java"$
0002:
0003: package xtc.lang.antlr;
0004:
0005: import antlr.TokenBuffer;
0006: import antlr.TokenStreamException;
0007: import antlr.TokenStreamIOException;
0008: import antlr.ANTLRException;
0009: import antlr.LLkParser;
0010: import antlr.Token;
0011: import antlr.TokenStream;
0012: import antlr.RecognitionException;
0013: import antlr.NoViableAltException;
0014: import antlr.MismatchedTokenException;
0015: import antlr.SemanticException;
0016: import antlr.ParserSharedInputState;
0017: import antlr.collections.impl.BitSet;
0018:
0019: public class JavaRecognizer extends antlr.LLkParser implements
0020: JavaTokenTypes {
0021:
0022: protected JavaRecognizer(TokenBuffer tokenBuf, int k) {
0023: super (tokenBuf, k);
0024: tokenNames = _tokenNames;
0025: }
0026:
0027: public JavaRecognizer(TokenBuffer tokenBuf) {
0028: this (tokenBuf, 2);
0029: }
0030:
0031: protected JavaRecognizer(TokenStream lexer, int k) {
0032: super (lexer, k);
0033: tokenNames = _tokenNames;
0034: }
0035:
0036: public JavaRecognizer(TokenStream lexer) {
0037: this (lexer, 2);
0038: }
0039:
0040: public JavaRecognizer(ParserSharedInputState state) {
0041: super (state, 2);
0042: tokenNames = _tokenNames;
0043: }
0044:
0045: public final void compilationUnit() throws RecognitionException,
0046: TokenStreamException {
0047:
0048: {
0049: switch (LA(1)) {
0050: case LITERAL_package: {
0051: packageDefinition();
0052: break;
0053: }
0054: case EOF:
0055: case FINAL:
0056: case ABSTRACT:
0057: case STRICTFP:
0058: case SEMI:
0059: case LITERAL_import:
0060: case LITERAL_private:
0061: case LITERAL_public:
0062: case LITERAL_protected:
0063: case LITERAL_static:
0064: case LITERAL_transient:
0065: case LITERAL_native:
0066: case LITERAL_threadsafe:
0067: case LITERAL_synchronized:
0068: case LITERAL_volatile:
0069: case LITERAL_class:
0070: case LITERAL_interface: {
0071: break;
0072: }
0073: default: {
0074: throw new NoViableAltException(LT(1), getFilename());
0075: }
0076: }
0077: }
0078: {
0079: _loop4: do {
0080: if ((LA(1) == LITERAL_import)) {
0081: importDefinition();
0082: } else {
0083: break _loop4;
0084: }
0085:
0086: } while (true);
0087: }
0088: {
0089: _loop6: do {
0090: if ((_tokenSet_0.member(LA(1)))) {
0091: typeDefinition();
0092: } else {
0093: break _loop6;
0094: }
0095:
0096: } while (true);
0097: }
0098: match(Token.EOF_TYPE);
0099: }
0100:
0101: public final void packageDefinition() throws RecognitionException,
0102: TokenStreamException {
0103:
0104: try { // for error handling
0105: match(LITERAL_package);
0106: identifier();
0107: match(SEMI);
0108: } catch (RecognitionException ex) {
0109: if (inputState.guessing == 0) {
0110: reportError(ex);
0111: recover(ex, _tokenSet_1);
0112: } else {
0113: throw ex;
0114: }
0115: }
0116: }
0117:
0118: public final void importDefinition() throws RecognitionException,
0119: TokenStreamException {
0120:
0121: try { // for error handling
0122: match(LITERAL_import);
0123: identifierStar();
0124: match(SEMI);
0125: } catch (RecognitionException ex) {
0126: if (inputState.guessing == 0) {
0127: reportError(ex);
0128: recover(ex, _tokenSet_1);
0129: } else {
0130: throw ex;
0131: }
0132: }
0133: }
0134:
0135: public final void typeDefinition() throws RecognitionException,
0136: TokenStreamException {
0137:
0138: try { // for error handling
0139: switch (LA(1)) {
0140: case FINAL:
0141: case ABSTRACT:
0142: case STRICTFP:
0143: case LITERAL_private:
0144: case LITERAL_public:
0145: case LITERAL_protected:
0146: case LITERAL_static:
0147: case LITERAL_transient:
0148: case LITERAL_native:
0149: case LITERAL_threadsafe:
0150: case LITERAL_synchronized:
0151: case LITERAL_volatile:
0152: case LITERAL_class:
0153: case LITERAL_interface: {
0154: modifiers();
0155: {
0156: switch (LA(1)) {
0157: case LITERAL_class: {
0158: classDefinition();
0159: break;
0160: }
0161: case LITERAL_interface: {
0162: interfaceDefinition();
0163: break;
0164: }
0165: default: {
0166: throw new NoViableAltException(LT(1),
0167: getFilename());
0168: }
0169: }
0170: }
0171: break;
0172: }
0173: case SEMI: {
0174: match(SEMI);
0175: break;
0176: }
0177: default: {
0178: throw new NoViableAltException(LT(1), getFilename());
0179: }
0180: }
0181: } catch (RecognitionException ex) {
0182: if (inputState.guessing == 0) {
0183: reportError(ex);
0184: recover(ex, _tokenSet_2);
0185: } else {
0186: throw ex;
0187: }
0188: }
0189: }
0190:
0191: public final void identifier() throws RecognitionException,
0192: TokenStreamException {
0193:
0194: match(IDENT);
0195: {
0196: _loop23: do {
0197: if ((LA(1) == DOT)) {
0198: match(DOT);
0199: match(IDENT);
0200: } else {
0201: break _loop23;
0202: }
0203:
0204: } while (true);
0205: }
0206: }
0207:
0208: public final void identifierStar() throws RecognitionException,
0209: TokenStreamException {
0210:
0211: match(IDENT);
0212: {
0213: _loop26: do {
0214: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
0215: match(DOT);
0216: match(IDENT);
0217: } else {
0218: break _loop26;
0219: }
0220:
0221: } while (true);
0222: }
0223: {
0224: switch (LA(1)) {
0225: case DOT: {
0226: match(DOT);
0227: match(STAR);
0228: break;
0229: }
0230: case SEMI: {
0231: break;
0232: }
0233: default: {
0234: throw new NoViableAltException(LT(1), getFilename());
0235: }
0236: }
0237: }
0238: }
0239:
0240: public final void modifiers() throws RecognitionException,
0241: TokenStreamException {
0242:
0243: {
0244: _loop30: do {
0245: if ((_tokenSet_3.member(LA(1)))) {
0246: modifier();
0247: } else {
0248: break _loop30;
0249: }
0250:
0251: } while (true);
0252: }
0253: }
0254:
0255: public final void classDefinition() throws RecognitionException,
0256: TokenStreamException {
0257:
0258: match(LITERAL_class);
0259: match(IDENT);
0260: super ClassClause();
0261: implements Clause();
0262: classBlock();
0263: }
0264:
0265: public final void interfaceDefinition()
0266: throws RecognitionException, TokenStreamException {
0267:
0268: match(LITERAL_interface);
0269: match(IDENT);
0270: interfaceExtends();
0271: classBlock();
0272: }
0273:
0274: /** A declaration is the creation of a reference or primitive-type variable
0275: * Create a separate Type/Var tree for each var in the var list.
0276: */
0277: public final void declaration() throws RecognitionException,
0278: TokenStreamException {
0279:
0280: modifiers();
0281: typeSpec();
0282: variableDefinitions();
0283: }
0284:
0285: public final void typeSpec() throws RecognitionException,
0286: TokenStreamException {
0287:
0288: switch (LA(1)) {
0289: case IDENT: {
0290: classTypeSpec();
0291: break;
0292: }
0293: case LITERAL_void:
0294: case LITERAL_boolean:
0295: case LITERAL_byte:
0296: case LITERAL_char:
0297: case LITERAL_short:
0298: case LITERAL_int:
0299: case LITERAL_float:
0300: case LITERAL_long:
0301: case LITERAL_double: {
0302: builtInTypeSpec();
0303: break;
0304: }
0305: default: {
0306: throw new NoViableAltException(LT(1), getFilename());
0307: }
0308: }
0309: }
0310:
0311: public final void variableDefinitions()
0312: throws RecognitionException, TokenStreamException {
0313:
0314: variableDeclarator();
0315: {
0316: _loop59: do {
0317: if ((LA(1) == COMMA)) {
0318: match(COMMA);
0319: variableDeclarator();
0320: } else {
0321: break _loop59;
0322: }
0323:
0324: } while (true);
0325: }
0326: }
0327:
0328: public final void classTypeSpec() throws RecognitionException,
0329: TokenStreamException {
0330:
0331: identifier();
0332: {
0333: _loop15: do {
0334: if ((LA(1) == LBRACK)) {
0335: match(LBRACK);
0336: match(RBRACK);
0337: } else {
0338: break _loop15;
0339: }
0340:
0341: } while (true);
0342: }
0343: }
0344:
0345: public final void builtInTypeSpec() throws RecognitionException,
0346: TokenStreamException {
0347:
0348: builtInType();
0349: {
0350: _loop18: do {
0351: if ((LA(1) == LBRACK)) {
0352: match(LBRACK);
0353: match(RBRACK);
0354: } else {
0355: break _loop18;
0356: }
0357:
0358: } while (true);
0359: }
0360: }
0361:
0362: public final void builtInType() throws RecognitionException,
0363: TokenStreamException {
0364:
0365: switch (LA(1)) {
0366: case LITERAL_void: {
0367: match(LITERAL_void);
0368: break;
0369: }
0370: case LITERAL_boolean: {
0371: match(LITERAL_boolean);
0372: break;
0373: }
0374: case LITERAL_byte: {
0375: match(LITERAL_byte);
0376: break;
0377: }
0378: case LITERAL_char: {
0379: match(LITERAL_char);
0380: break;
0381: }
0382: case LITERAL_short: {
0383: match(LITERAL_short);
0384: break;
0385: }
0386: case LITERAL_int: {
0387: match(LITERAL_int);
0388: break;
0389: }
0390: case LITERAL_float: {
0391: match(LITERAL_float);
0392: break;
0393: }
0394: case LITERAL_long: {
0395: match(LITERAL_long);
0396: break;
0397: }
0398: case LITERAL_double: {
0399: match(LITERAL_double);
0400: break;
0401: }
0402: default: {
0403: throw new NoViableAltException(LT(1), getFilename());
0404: }
0405: }
0406: }
0407:
0408: public final void type() throws RecognitionException,
0409: TokenStreamException {
0410:
0411: switch (LA(1)) {
0412: case IDENT: {
0413: identifier();
0414: break;
0415: }
0416: case LITERAL_void:
0417: case LITERAL_boolean:
0418: case LITERAL_byte:
0419: case LITERAL_char:
0420: case LITERAL_short:
0421: case LITERAL_int:
0422: case LITERAL_float:
0423: case LITERAL_long:
0424: case LITERAL_double: {
0425: builtInType();
0426: break;
0427: }
0428: default: {
0429: throw new NoViableAltException(LT(1), getFilename());
0430: }
0431: }
0432: }
0433:
0434: public final void modifier() throws RecognitionException,
0435: TokenStreamException {
0436:
0437: switch (LA(1)) {
0438: case LITERAL_private: {
0439: match(LITERAL_private);
0440: break;
0441: }
0442: case LITERAL_public: {
0443: match(LITERAL_public);
0444: break;
0445: }
0446: case LITERAL_protected: {
0447: match(LITERAL_protected);
0448: break;
0449: }
0450: case LITERAL_static: {
0451: match(LITERAL_static);
0452: break;
0453: }
0454: case LITERAL_transient: {
0455: match(LITERAL_transient);
0456: break;
0457: }
0458: case FINAL: {
0459: match(FINAL);
0460: break;
0461: }
0462: case ABSTRACT: {
0463: match(ABSTRACT);
0464: break;
0465: }
0466: case LITERAL_native: {
0467: match(LITERAL_native);
0468: break;
0469: }
0470: case LITERAL_threadsafe: {
0471: match(LITERAL_threadsafe);
0472: break;
0473: }
0474: case LITERAL_synchronized: {
0475: match(LITERAL_synchronized);
0476: break;
0477: }
0478: case LITERAL_volatile: {
0479: match(LITERAL_volatile);
0480: break;
0481: }
0482: case STRICTFP: {
0483: match(STRICTFP);
0484: break;
0485: }
0486: default: {
0487: throw new NoViableAltException(LT(1), getFilename());
0488: }
0489: }
0490: }
0491:
0492: public final void super ClassClause() throws RecognitionException,
0493: TokenStreamException {
0494:
0495: {
0496: switch (LA(1)) {
0497: case LITERAL_extends: {
0498: match(LITERAL_extends);
0499: identifier();
0500: break;
0501: }
0502: case LCURLY:
0503: case LITERAL_implements : {
0504: break;
0505: }
0506: default: {
0507: throw new NoViableAltException(LT(1), getFilename());
0508: }
0509: }
0510: }
0511: }
0512:
0513: public final void implements Clause() throws RecognitionException,
0514: TokenStreamException {
0515:
0516: {
0517: switch (LA(1)) {
0518: case LITERAL_implements : {
0519: match(LITERAL_implements );
0520: identifier();
0521: {
0522: _loop46: do {
0523: if ((LA(1) == COMMA)) {
0524: match(COMMA);
0525: identifier();
0526: } else {
0527: break _loop46;
0528: }
0529:
0530: } while (true);
0531: }
0532: break;
0533: }
0534: case LCURLY: {
0535: break;
0536: }
0537: default: {
0538: throw new NoViableAltException(LT(1), getFilename());
0539: }
0540: }
0541: }
0542: }
0543:
0544: public final void classBlock() throws RecognitionException,
0545: TokenStreamException {
0546:
0547: match(LCURLY);
0548: {
0549: _loop38: do {
0550: switch (LA(1)) {
0551: case FINAL:
0552: case ABSTRACT:
0553: case STRICTFP:
0554: case LITERAL_void:
0555: case LITERAL_boolean:
0556: case LITERAL_byte:
0557: case LITERAL_char:
0558: case LITERAL_short:
0559: case LITERAL_int:
0560: case LITERAL_float:
0561: case LITERAL_long:
0562: case LITERAL_double:
0563: case IDENT:
0564: case LITERAL_private:
0565: case LITERAL_public:
0566: case LITERAL_protected:
0567: case LITERAL_static:
0568: case LITERAL_transient:
0569: case LITERAL_native:
0570: case LITERAL_threadsafe:
0571: case LITERAL_synchronized:
0572: case LITERAL_volatile:
0573: case LITERAL_class:
0574: case LITERAL_interface:
0575: case LCURLY: {
0576: field();
0577: break;
0578: }
0579: case SEMI: {
0580: match(SEMI);
0581: break;
0582: }
0583: default: {
0584: break _loop38;
0585: }
0586: }
0587: } while (true);
0588: }
0589: match(RCURLY);
0590: }
0591:
0592: public final void interfaceExtends() throws RecognitionException,
0593: TokenStreamException {
0594:
0595: {
0596: switch (LA(1)) {
0597: case LITERAL_extends: {
0598: match(LITERAL_extends);
0599: identifier();
0600: {
0601: _loop42: do {
0602: if ((LA(1) == COMMA)) {
0603: match(COMMA);
0604: identifier();
0605: } else {
0606: break _loop42;
0607: }
0608:
0609: } while (true);
0610: }
0611: break;
0612: }
0613: case LCURLY: {
0614: break;
0615: }
0616: default: {
0617: throw new NoViableAltException(LT(1), getFilename());
0618: }
0619: }
0620: }
0621: }
0622:
0623: public final void field() throws RecognitionException,
0624: TokenStreamException {
0625:
0626: if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
0627: modifiers();
0628: {
0629: switch (LA(1)) {
0630: case LITERAL_class: {
0631: classDefinition();
0632: break;
0633: }
0634: case LITERAL_interface: {
0635: interfaceDefinition();
0636: break;
0637: }
0638: default:
0639: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
0640: ctorHead();
0641: constructorBody();
0642: } else if (((LA(1) >= LITERAL_void && LA(1) <= IDENT))
0643: && (_tokenSet_6.member(LA(2)))) {
0644: typeSpec();
0645: {
0646: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
0647: match(IDENT);
0648: match(LPAREN);
0649: parameterDeclarationList();
0650: match(RPAREN);
0651: declaratorBrackets();
0652: {
0653: switch (LA(1)) {
0654: case LITERAL_throws: {
0655: throwsClause();
0656: break;
0657: }
0658: case SEMI:
0659: case LCURLY: {
0660: break;
0661: }
0662: default: {
0663: throw new NoViableAltException(
0664: LT(1), getFilename());
0665: }
0666: }
0667: }
0668: {
0669: switch (LA(1)) {
0670: case LCURLY: {
0671: compoundStatement();
0672: break;
0673: }
0674: case SEMI: {
0675: match(SEMI);
0676: break;
0677: }
0678: default: {
0679: throw new NoViableAltException(
0680: LT(1), getFilename());
0681: }
0682: }
0683: }
0684: } else if ((LA(1) == IDENT)
0685: && (_tokenSet_7.member(LA(2)))) {
0686: variableDefinitions();
0687: match(SEMI);
0688: } else {
0689: throw new NoViableAltException(LT(1),
0690: getFilename());
0691: }
0692:
0693: }
0694: } else {
0695: throw new NoViableAltException(LT(1),
0696: getFilename());
0697: }
0698: }
0699: }
0700: } else if ((LA(1) == LITERAL_static) && (LA(2) == LCURLY)) {
0701: match(LITERAL_static);
0702: compoundStatement();
0703: } else if ((LA(1) == LCURLY)) {
0704: compoundStatement();
0705: } else {
0706: throw new NoViableAltException(LT(1), getFilename());
0707: }
0708:
0709: }
0710:
0711: public final void ctorHead() throws RecognitionException,
0712: TokenStreamException {
0713:
0714: match(IDENT);
0715: match(LPAREN);
0716: parameterDeclarationList();
0717: match(RPAREN);
0718: {
0719: switch (LA(1)) {
0720: case LITERAL_throws: {
0721: throwsClause();
0722: break;
0723: }
0724: case LCURLY: {
0725: break;
0726: }
0727: default: {
0728: throw new NoViableAltException(LT(1), getFilename());
0729: }
0730: }
0731: }
0732: }
0733:
0734: public final void constructorBody() throws RecognitionException,
0735: TokenStreamException {
0736:
0737: match(LCURLY);
0738: {
0739: if ((LA(1) == LITERAL_this || LA(1) == LITERAL_super )
0740: && (LA(2) == LPAREN)) {
0741: explicitConstructorInvocation();
0742: } else if ((_tokenSet_8.member(LA(1)))
0743: && (_tokenSet_9.member(LA(2)))) {
0744: } else {
0745: throw new NoViableAltException(LT(1), getFilename());
0746: }
0747:
0748: }
0749: {
0750: _loop55: do {
0751: if ((_tokenSet_10.member(LA(1)))) {
0752: statement();
0753: } else {
0754: break _loop55;
0755: }
0756:
0757: } while (true);
0758: }
0759: match(RCURLY);
0760: }
0761:
0762: public final void parameterDeclarationList()
0763: throws RecognitionException, TokenStreamException {
0764:
0765: {
0766: switch (LA(1)) {
0767: case FINAL:
0768: case LITERAL_void:
0769: case LITERAL_boolean:
0770: case LITERAL_byte:
0771: case LITERAL_char:
0772: case LITERAL_short:
0773: case LITERAL_int:
0774: case LITERAL_float:
0775: case LITERAL_long:
0776: case LITERAL_double:
0777: case IDENT: {
0778: parameterDeclaration();
0779: {
0780: _loop80: do {
0781: if ((LA(1) == COMMA)) {
0782: match(COMMA);
0783: parameterDeclaration();
0784: } else {
0785: break _loop80;
0786: }
0787:
0788: } while (true);
0789: }
0790: break;
0791: }
0792: case RPAREN: {
0793: break;
0794: }
0795: default: {
0796: throw new NoViableAltException(LT(1), getFilename());
0797: }
0798: }
0799: }
0800: }
0801:
0802: public final void declaratorBrackets() throws RecognitionException,
0803: TokenStreamException {
0804:
0805: {
0806: _loop63: do {
0807: if ((LA(1) == LBRACK)) {
0808: match(LBRACK);
0809: match(RBRACK);
0810: } else {
0811: break _loop63;
0812: }
0813:
0814: } while (true);
0815: }
0816: }
0817:
0818: public final void throwsClause() throws RecognitionException,
0819: TokenStreamException {
0820:
0821: match(LITERAL_throws);
0822: identifier();
0823: {
0824: _loop76: do {
0825: if ((LA(1) == COMMA)) {
0826: match(COMMA);
0827: identifier();
0828: } else {
0829: break _loop76;
0830: }
0831:
0832: } while (true);
0833: }
0834: }
0835:
0836: public final void compoundStatement() throws RecognitionException,
0837: TokenStreamException {
0838:
0839: match(LCURLY);
0840: {
0841: _loop86: do {
0842: if ((_tokenSet_10.member(LA(1)))) {
0843: statement();
0844: } else {
0845: break _loop86;
0846: }
0847:
0848: } while (true);
0849: }
0850: match(RCURLY);
0851: }
0852:
0853: /** Catch obvious constructor calls, but not the expr.super(...) calls */
0854: public final void explicitConstructorInvocation()
0855: throws RecognitionException, TokenStreamException {
0856:
0857: switch (LA(1)) {
0858: case LITERAL_this : {
0859: match(LITERAL_this );
0860: match(LPAREN);
0861: argList();
0862: match(RPAREN);
0863: match(SEMI);
0864: break;
0865: }
0866: case LITERAL_super : {
0867: match(LITERAL_super );
0868: match(LPAREN);
0869: argList();
0870: match(RPAREN);
0871: match(SEMI);
0872: break;
0873: }
0874: default: {
0875: throw new NoViableAltException(LT(1), getFilename());
0876: }
0877: }
0878: }
0879:
0880: public final void statement() throws RecognitionException,
0881: TokenStreamException {
0882:
0883: switch (LA(1)) {
0884: case LCURLY: {
0885: compoundStatement();
0886: break;
0887: }
0888: case LITERAL_if: {
0889: match(LITERAL_if);
0890: match(LPAREN);
0891: expression();
0892: match(RPAREN);
0893: statement();
0894: {
0895: if ((LA(1) == LITERAL_else)
0896: && (_tokenSet_10.member(LA(2)))) {
0897: match(LITERAL_else);
0898: statement();
0899: } else if ((_tokenSet_11.member(LA(1)))
0900: && (_tokenSet_12.member(LA(2)))) {
0901: } else {
0902: throw new NoViableAltException(LT(1), getFilename());
0903: }
0904:
0905: }
0906: break;
0907: }
0908: case LITERAL_for: {
0909: match(LITERAL_for);
0910: match(LPAREN);
0911: forInit();
0912: match(SEMI);
0913: forCond();
0914: match(SEMI);
0915: forIter();
0916: match(RPAREN);
0917: statement();
0918: break;
0919: }
0920: case LITERAL_while: {
0921: match(LITERAL_while);
0922: match(LPAREN);
0923: expression();
0924: match(RPAREN);
0925: statement();
0926: break;
0927: }
0928: case LITERAL_do: {
0929: match(LITERAL_do);
0930: statement();
0931: match(LITERAL_while);
0932: match(LPAREN);
0933: expression();
0934: match(RPAREN);
0935: match(SEMI);
0936: break;
0937: }
0938: case LITERAL_break: {
0939: match(LITERAL_break);
0940: {
0941: switch (LA(1)) {
0942: case IDENT: {
0943: match(IDENT);
0944: break;
0945: }
0946: case SEMI: {
0947: break;
0948: }
0949: default: {
0950: throw new NoViableAltException(LT(1), getFilename());
0951: }
0952: }
0953: }
0954: match(SEMI);
0955: break;
0956: }
0957: case LITERAL_continue: {
0958: match(LITERAL_continue);
0959: {
0960: switch (LA(1)) {
0961: case IDENT: {
0962: match(IDENT);
0963: break;
0964: }
0965: case SEMI: {
0966: break;
0967: }
0968: default: {
0969: throw new NoViableAltException(LT(1), getFilename());
0970: }
0971: }
0972: }
0973: match(SEMI);
0974: break;
0975: }
0976: case LITERAL_return: {
0977: match(LITERAL_return);
0978: {
0979: switch (LA(1)) {
0980: case LITERAL_void:
0981: case LITERAL_boolean:
0982: case LITERAL_byte:
0983: case LITERAL_char:
0984: case LITERAL_short:
0985: case LITERAL_int:
0986: case LITERAL_float:
0987: case LITERAL_long:
0988: case LITERAL_double:
0989: case IDENT:
0990: case LPAREN:
0991: case LITERAL_this :
0992: case LITERAL_super :
0993: case PLUS:
0994: case MINUS:
0995: case INC:
0996: case DEC:
0997: case BNOT:
0998: case LNOT:
0999: case LITERAL_true:
1000: case LITERAL_false:
1001: case LITERAL_null:
1002: case LITERAL_new:
1003: case NUM_INT:
1004: case CHAR_LITERAL:
1005: case STRING_LITERAL:
1006: case NUM_FLOAT:
1007: case NUM_LONG:
1008: case NUM_DOUBLE: {
1009: expression();
1010: break;
1011: }
1012: case SEMI: {
1013: break;
1014: }
1015: default: {
1016: throw new NoViableAltException(LT(1), getFilename());
1017: }
1018: }
1019: }
1020: match(SEMI);
1021: break;
1022: }
1023: case LITERAL_switch: {
1024: match(LITERAL_switch);
1025: match(LPAREN);
1026: expression();
1027: match(RPAREN);
1028: match(LCURLY);
1029: {
1030: _loop95: do {
1031: if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default)) {
1032: casesGroup();
1033: } else {
1034: break _loop95;
1035: }
1036:
1037: } while (true);
1038: }
1039: match(RCURLY);
1040: break;
1041: }
1042: case LITERAL_try: {
1043: tryBlock();
1044: break;
1045: }
1046: case LITERAL_throw: {
1047: match(LITERAL_throw);
1048: expression();
1049: match(SEMI);
1050: break;
1051: }
1052: case SEMI: {
1053: match(SEMI);
1054: break;
1055: }
1056: default:
1057: boolean synPredMatched89 = false;
1058: if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14
1059: .member(LA(2))))) {
1060: int _m89 = mark();
1061: synPredMatched89 = true;
1062: inputState.guessing++;
1063: try {
1064: {
1065: declaration();
1066: }
1067: } catch (RecognitionException pe) {
1068: synPredMatched89 = false;
1069: }
1070: rewind(_m89);
1071: inputState.guessing--;
1072: }
1073: if (synPredMatched89) {
1074: declaration();
1075: match(SEMI);
1076: } else if ((_tokenSet_15.member(LA(1)))
1077: && (_tokenSet_16.member(LA(2)))) {
1078: expression();
1079: match(SEMI);
1080: } else if ((_tokenSet_17.member(LA(1)))
1081: && (_tokenSet_18.member(LA(2)))) {
1082: modifiers();
1083: classDefinition();
1084: } else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
1085: match(IDENT);
1086: match(COLON);
1087: statement();
1088: } else if ((LA(1) == LITERAL_synchronized)
1089: && (LA(2) == LPAREN)) {
1090: match(LITERAL_synchronized);
1091: match(LPAREN);
1092: expression();
1093: match(RPAREN);
1094: compoundStatement();
1095: } else {
1096: throw new NoViableAltException(LT(1), getFilename());
1097: }
1098: }
1099: }
1100:
1101: public final void argList() throws RecognitionException,
1102: TokenStreamException {
1103:
1104: {
1105: switch (LA(1)) {
1106: case LITERAL_void:
1107: case LITERAL_boolean:
1108: case LITERAL_byte:
1109: case LITERAL_char:
1110: case LITERAL_short:
1111: case LITERAL_int:
1112: case LITERAL_float:
1113: case LITERAL_long:
1114: case LITERAL_double:
1115: case IDENT:
1116: case LPAREN:
1117: case LITERAL_this :
1118: case LITERAL_super :
1119: case PLUS:
1120: case MINUS:
1121: case INC:
1122: case DEC:
1123: case BNOT:
1124: case LNOT:
1125: case LITERAL_true:
1126: case LITERAL_false:
1127: case LITERAL_null:
1128: case LITERAL_new:
1129: case NUM_INT:
1130: case CHAR_LITERAL:
1131: case STRING_LITERAL:
1132: case NUM_FLOAT:
1133: case NUM_LONG:
1134: case NUM_DOUBLE: {
1135: expressionList();
1136: break;
1137: }
1138: case RPAREN: {
1139: break;
1140: }
1141: default: {
1142: throw new NoViableAltException(LT(1), getFilename());
1143: }
1144: }
1145: }
1146: }
1147:
1148: /** Declaration of a variable. This can be a class/instance variable,
1149: * or a local variable in a method
1150: * It can also include possible initialization.
1151: */
1152: public final void variableDeclarator() throws RecognitionException,
1153: TokenStreamException {
1154:
1155: match(IDENT);
1156: declaratorBrackets();
1157: varInitializer();
1158: }
1159:
1160: public final void varInitializer() throws RecognitionException,
1161: TokenStreamException {
1162:
1163: {
1164: switch (LA(1)) {
1165: case ASSIGN: {
1166: match(ASSIGN);
1167: initializer();
1168: break;
1169: }
1170: case SEMI:
1171: case COMMA: {
1172: break;
1173: }
1174: default: {
1175: throw new NoViableAltException(LT(1), getFilename());
1176: }
1177: }
1178: }
1179: }
1180:
1181: public final void initializer() throws RecognitionException,
1182: TokenStreamException {
1183:
1184: switch (LA(1)) {
1185: case LITERAL_void:
1186: case LITERAL_boolean:
1187: case LITERAL_byte:
1188: case LITERAL_char:
1189: case LITERAL_short:
1190: case LITERAL_int:
1191: case LITERAL_float:
1192: case LITERAL_long:
1193: case LITERAL_double:
1194: case IDENT:
1195: case LPAREN:
1196: case LITERAL_this :
1197: case LITERAL_super :
1198: case PLUS:
1199: case MINUS:
1200: case INC:
1201: case DEC:
1202: case BNOT:
1203: case LNOT:
1204: case LITERAL_true:
1205: case LITERAL_false:
1206: case LITERAL_null:
1207: case LITERAL_new:
1208: case NUM_INT:
1209: case CHAR_LITERAL:
1210: case STRING_LITERAL:
1211: case NUM_FLOAT:
1212: case NUM_LONG:
1213: case NUM_DOUBLE: {
1214: expression();
1215: break;
1216: }
1217: case LCURLY: {
1218: arrayInitializer();
1219: break;
1220: }
1221: default: {
1222: throw new NoViableAltException(LT(1), getFilename());
1223: }
1224: }
1225: }
1226:
1227: public final void arrayInitializer() throws RecognitionException,
1228: TokenStreamException {
1229:
1230: match(LCURLY);
1231: {
1232: switch (LA(1)) {
1233: case LITERAL_void:
1234: case LITERAL_boolean:
1235: case LITERAL_byte:
1236: case LITERAL_char:
1237: case LITERAL_short:
1238: case LITERAL_int:
1239: case LITERAL_float:
1240: case LITERAL_long:
1241: case LITERAL_double:
1242: case IDENT:
1243: case LCURLY:
1244: case LPAREN:
1245: case LITERAL_this :
1246: case LITERAL_super :
1247: case PLUS:
1248: case MINUS:
1249: case INC:
1250: case DEC:
1251: case BNOT:
1252: case LNOT:
1253: case LITERAL_true:
1254: case LITERAL_false:
1255: case LITERAL_null:
1256: case LITERAL_new:
1257: case NUM_INT:
1258: case CHAR_LITERAL:
1259: case STRING_LITERAL:
1260: case NUM_FLOAT:
1261: case NUM_LONG:
1262: case NUM_DOUBLE: {
1263: initializer();
1264: {
1265: _loop69: do {
1266: if ((LA(1) == COMMA)
1267: && (_tokenSet_19.member(LA(2)))) {
1268: match(COMMA);
1269: initializer();
1270: } else {
1271: break _loop69;
1272: }
1273:
1274: } while (true);
1275: }
1276: {
1277: switch (LA(1)) {
1278: case COMMA: {
1279: match(COMMA);
1280: break;
1281: }
1282: case RCURLY: {
1283: break;
1284: }
1285: default: {
1286: throw new NoViableAltException(LT(1),
1287: getFilename());
1288: }
1289: }
1290: }
1291: break;
1292: }
1293: case RCURLY: {
1294: break;
1295: }
1296: default: {
1297: throw new NoViableAltException(LT(1), getFilename());
1298: }
1299: }
1300: }
1301: match(RCURLY);
1302: }
1303:
1304: public final void expression() throws RecognitionException,
1305: TokenStreamException {
1306:
1307: assignmentExpression();
1308: }
1309:
1310: public final void parameterDeclaration()
1311: throws RecognitionException, TokenStreamException {
1312:
1313: parameterModifier();
1314: typeSpec();
1315: match(IDENT);
1316: declaratorBrackets();
1317: }
1318:
1319: public final void parameterModifier() throws RecognitionException,
1320: TokenStreamException {
1321:
1322: {
1323: switch (LA(1)) {
1324: case FINAL: {
1325: match(FINAL);
1326: break;
1327: }
1328: case LITERAL_void:
1329: case LITERAL_boolean:
1330: case LITERAL_byte:
1331: case LITERAL_char:
1332: case LITERAL_short:
1333: case LITERAL_int:
1334: case LITERAL_float:
1335: case LITERAL_long:
1336: case LITERAL_double:
1337: case IDENT: {
1338: break;
1339: }
1340: default: {
1341: throw new NoViableAltException(LT(1), getFilename());
1342: }
1343: }
1344: }
1345: }
1346:
1347: public final void forInit() throws RecognitionException,
1348: TokenStreamException {
1349:
1350: {
1351: boolean synPredMatched107 = false;
1352: if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14
1353: .member(LA(2))))) {
1354: int _m107 = mark();
1355: synPredMatched107 = true;
1356: inputState.guessing++;
1357: try {
1358: {
1359: declaration();
1360: }
1361: } catch (RecognitionException pe) {
1362: synPredMatched107 = false;
1363: }
1364: rewind(_m107);
1365: inputState.guessing--;
1366: }
1367: if (synPredMatched107) {
1368: declaration();
1369: } else if ((_tokenSet_15.member(LA(1)))
1370: && (_tokenSet_20.member(LA(2)))) {
1371: expressionList();
1372: } else if ((LA(1) == SEMI)) {
1373: } else {
1374: throw new NoViableAltException(LT(1), getFilename());
1375: }
1376:
1377: }
1378: }
1379:
1380: public final void forCond() throws RecognitionException,
1381: TokenStreamException {
1382:
1383: {
1384: switch (LA(1)) {
1385: case LITERAL_void:
1386: case LITERAL_boolean:
1387: case LITERAL_byte:
1388: case LITERAL_char:
1389: case LITERAL_short:
1390: case LITERAL_int:
1391: case LITERAL_float:
1392: case LITERAL_long:
1393: case LITERAL_double:
1394: case IDENT:
1395: case LPAREN:
1396: case LITERAL_this :
1397: case LITERAL_super :
1398: case PLUS:
1399: case MINUS:
1400: case INC:
1401: case DEC:
1402: case BNOT:
1403: case LNOT:
1404: case LITERAL_true:
1405: case LITERAL_false:
1406: case LITERAL_null:
1407: case LITERAL_new:
1408: case NUM_INT:
1409: case CHAR_LITERAL:
1410: case STRING_LITERAL:
1411: case NUM_FLOAT:
1412: case NUM_LONG:
1413: case NUM_DOUBLE: {
1414: expression();
1415: break;
1416: }
1417: case SEMI: {
1418: break;
1419: }
1420: default: {
1421: throw new NoViableAltException(LT(1), getFilename());
1422: }
1423: }
1424: }
1425: }
1426:
1427: public final void forIter() throws RecognitionException,
1428: TokenStreamException {
1429:
1430: {
1431: switch (LA(1)) {
1432: case LITERAL_void:
1433: case LITERAL_boolean:
1434: case LITERAL_byte:
1435: case LITERAL_char:
1436: case LITERAL_short:
1437: case LITERAL_int:
1438: case LITERAL_float:
1439: case LITERAL_long:
1440: case LITERAL_double:
1441: case IDENT:
1442: case LPAREN:
1443: case LITERAL_this :
1444: case LITERAL_super :
1445: case PLUS:
1446: case MINUS:
1447: case INC:
1448: case DEC:
1449: case BNOT:
1450: case LNOT:
1451: case LITERAL_true:
1452: case LITERAL_false:
1453: case LITERAL_null:
1454: case LITERAL_new:
1455: case NUM_INT:
1456: case CHAR_LITERAL:
1457: case STRING_LITERAL:
1458: case NUM_FLOAT:
1459: case NUM_LONG:
1460: case NUM_DOUBLE: {
1461: expressionList();
1462: break;
1463: }
1464: case RPAREN: {
1465: break;
1466: }
1467: default: {
1468: throw new NoViableAltException(LT(1), getFilename());
1469: }
1470: }
1471: }
1472: }
1473:
1474: public final void casesGroup() throws RecognitionException,
1475: TokenStreamException {
1476:
1477: {
1478: int _cnt98 = 0;
1479: _loop98: do {
1480: if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default)
1481: && (_tokenSet_21.member(LA(2)))) {
1482: aCase();
1483: } else {
1484: if (_cnt98 >= 1) {
1485: break _loop98;
1486: } else {
1487: throw new NoViableAltException(LT(1),
1488: getFilename());
1489: }
1490: }
1491:
1492: _cnt98++;
1493: } while (true);
1494: }
1495: caseSList();
1496: }
1497:
1498: public final void tryBlock() throws RecognitionException,
1499: TokenStreamException {
1500:
1501: match(LITERAL_try);
1502: compoundStatement();
1503: {
1504: _loop114: do {
1505: if ((LA(1) == LITERAL_catch)) {
1506: handler();
1507: } else {
1508: break _loop114;
1509: }
1510:
1511: } while (true);
1512: }
1513: {
1514: switch (LA(1)) {
1515: case LITERAL_finally: {
1516: finallyClause();
1517: break;
1518: }
1519: case FINAL:
1520: case ABSTRACT:
1521: case STRICTFP:
1522: case SEMI:
1523: case LITERAL_void:
1524: case LITERAL_boolean:
1525: case LITERAL_byte:
1526: case LITERAL_char:
1527: case LITERAL_short:
1528: case LITERAL_int:
1529: case LITERAL_float:
1530: case LITERAL_long:
1531: case LITERAL_double:
1532: case IDENT:
1533: case LITERAL_private:
1534: case LITERAL_public:
1535: case LITERAL_protected:
1536: case LITERAL_static:
1537: case LITERAL_transient:
1538: case LITERAL_native:
1539: case LITERAL_threadsafe:
1540: case LITERAL_synchronized:
1541: case LITERAL_volatile:
1542: case LITERAL_class:
1543: case LCURLY:
1544: case RCURLY:
1545: case LPAREN:
1546: case LITERAL_this :
1547: case LITERAL_super :
1548: case LITERAL_if:
1549: case LITERAL_else:
1550: case LITERAL_for:
1551: case LITERAL_while:
1552: case LITERAL_do:
1553: case LITERAL_break:
1554: case LITERAL_continue:
1555: case LITERAL_return:
1556: case LITERAL_switch:
1557: case LITERAL_throw:
1558: case LITERAL_case:
1559: case LITERAL_default:
1560: case LITERAL_try:
1561: case PLUS:
1562: case MINUS:
1563: case INC:
1564: case DEC:
1565: case BNOT:
1566: case LNOT:
1567: case LITERAL_true:
1568: case LITERAL_false:
1569: case LITERAL_null:
1570: case LITERAL_new:
1571: case NUM_INT:
1572: case CHAR_LITERAL:
1573: case STRING_LITERAL:
1574: case NUM_FLOAT:
1575: case NUM_LONG:
1576: case NUM_DOUBLE: {
1577: break;
1578: }
1579: default: {
1580: throw new NoViableAltException(LT(1), getFilename());
1581: }
1582: }
1583: }
1584: }
1585:
1586: public final void aCase() throws RecognitionException,
1587: TokenStreamException {
1588:
1589: {
1590: switch (LA(1)) {
1591: case LITERAL_case: {
1592: match(LITERAL_case);
1593: expression();
1594: break;
1595: }
1596: case LITERAL_default: {
1597: match(LITERAL_default);
1598: break;
1599: }
1600: default: {
1601: throw new NoViableAltException(LT(1), getFilename());
1602: }
1603: }
1604: }
1605: match(COLON);
1606: }
1607:
1608: public final void caseSList() throws RecognitionException,
1609: TokenStreamException {
1610:
1611: {
1612: _loop103: do {
1613: if ((_tokenSet_10.member(LA(1)))) {
1614: statement();
1615: } else {
1616: break _loop103;
1617: }
1618:
1619: } while (true);
1620: }
1621: }
1622:
1623: public final void expressionList() throws RecognitionException,
1624: TokenStreamException {
1625:
1626: expression();
1627: {
1628: _loop121: do {
1629: if ((LA(1) == COMMA)) {
1630: match(COMMA);
1631: expression();
1632: } else {
1633: break _loop121;
1634: }
1635:
1636: } while (true);
1637: }
1638: }
1639:
1640: public final void handler() throws RecognitionException,
1641: TokenStreamException {
1642:
1643: match(LITERAL_catch);
1644: match(LPAREN);
1645: parameterDeclaration();
1646: match(RPAREN);
1647: compoundStatement();
1648: }
1649:
1650: public final void finallyClause() throws RecognitionException,
1651: TokenStreamException {
1652:
1653: match(LITERAL_finally);
1654: compoundStatement();
1655: }
1656:
1657: public final void assignmentExpression()
1658: throws RecognitionException, TokenStreamException {
1659:
1660: conditionalExpression();
1661: {
1662: switch (LA(1)) {
1663: case ASSIGN:
1664: case PLUS_ASSIGN:
1665: case MINUS_ASSIGN:
1666: case STAR_ASSIGN:
1667: case DIV_ASSIGN:
1668: case MOD_ASSIGN:
1669: case SR_ASSIGN:
1670: case BSR_ASSIGN:
1671: case SL_ASSIGN:
1672: case BAND_ASSIGN:
1673: case BXOR_ASSIGN:
1674: case BOR_ASSIGN: {
1675: {
1676: switch (LA(1)) {
1677: case ASSIGN: {
1678: match(ASSIGN);
1679: break;
1680: }
1681: case PLUS_ASSIGN: {
1682: match(PLUS_ASSIGN);
1683: break;
1684: }
1685: case MINUS_ASSIGN: {
1686: match(MINUS_ASSIGN);
1687: break;
1688: }
1689: case STAR_ASSIGN: {
1690: match(STAR_ASSIGN);
1691: break;
1692: }
1693: case DIV_ASSIGN: {
1694: match(DIV_ASSIGN);
1695: break;
1696: }
1697: case MOD_ASSIGN: {
1698: match(MOD_ASSIGN);
1699: break;
1700: }
1701: case SR_ASSIGN: {
1702: match(SR_ASSIGN);
1703: break;
1704: }
1705: case BSR_ASSIGN: {
1706: match(BSR_ASSIGN);
1707: break;
1708: }
1709: case SL_ASSIGN: {
1710: match(SL_ASSIGN);
1711: break;
1712: }
1713: case BAND_ASSIGN: {
1714: match(BAND_ASSIGN);
1715: break;
1716: }
1717: case BXOR_ASSIGN: {
1718: match(BXOR_ASSIGN);
1719: break;
1720: }
1721: case BOR_ASSIGN: {
1722: match(BOR_ASSIGN);
1723: break;
1724: }
1725: default: {
1726: throw new NoViableAltException(LT(1),
1727: getFilename());
1728: }
1729: }
1730: }
1731: assignmentExpression();
1732: break;
1733: }
1734: case SEMI:
1735: case RBRACK:
1736: case RCURLY:
1737: case COMMA:
1738: case RPAREN:
1739: case COLON: {
1740: break;
1741: }
1742: default: {
1743: throw new NoViableAltException(LT(1), getFilename());
1744: }
1745: }
1746: }
1747: }
1748:
1749: public final void conditionalExpression()
1750: throws RecognitionException, TokenStreamException {
1751:
1752: logicalOrExpression();
1753: {
1754: switch (LA(1)) {
1755: case QUESTION: {
1756: match(QUESTION);
1757: assignmentExpression();
1758: match(COLON);
1759: conditionalExpression();
1760: break;
1761: }
1762: case SEMI:
1763: case RBRACK:
1764: case RCURLY:
1765: case COMMA:
1766: case RPAREN:
1767: case ASSIGN:
1768: case COLON:
1769: case PLUS_ASSIGN:
1770: case MINUS_ASSIGN:
1771: case STAR_ASSIGN:
1772: case DIV_ASSIGN:
1773: case MOD_ASSIGN:
1774: case SR_ASSIGN:
1775: case BSR_ASSIGN:
1776: case SL_ASSIGN:
1777: case BAND_ASSIGN:
1778: case BXOR_ASSIGN:
1779: case BOR_ASSIGN: {
1780: break;
1781: }
1782: default: {
1783: throw new NoViableAltException(LT(1), getFilename());
1784: }
1785: }
1786: }
1787: }
1788:
1789: public final void logicalOrExpression()
1790: throws RecognitionException, TokenStreamException {
1791:
1792: logicalAndExpression();
1793: {
1794: _loop129: do {
1795: if ((LA(1) == LOR)) {
1796: match(LOR);
1797: logicalAndExpression();
1798: } else {
1799: break _loop129;
1800: }
1801:
1802: } while (true);
1803: }
1804: }
1805:
1806: public final void logicalAndExpression()
1807: throws RecognitionException, TokenStreamException {
1808:
1809: inclusiveOrExpression();
1810: {
1811: _loop132: do {
1812: if ((LA(1) == LAND)) {
1813: match(LAND);
1814: inclusiveOrExpression();
1815: } else {
1816: break _loop132;
1817: }
1818:
1819: } while (true);
1820: }
1821: }
1822:
1823: public final void inclusiveOrExpression()
1824: throws RecognitionException, TokenStreamException {
1825:
1826: exclusiveOrExpression();
1827: {
1828: _loop135: do {
1829: if ((LA(1) == BOR)) {
1830: match(BOR);
1831: exclusiveOrExpression();
1832: } else {
1833: break _loop135;
1834: }
1835:
1836: } while (true);
1837: }
1838: }
1839:
1840: public final void exclusiveOrExpression()
1841: throws RecognitionException, TokenStreamException {
1842:
1843: andExpression();
1844: {
1845: _loop138: do {
1846: if ((LA(1) == BXOR)) {
1847: match(BXOR);
1848: andExpression();
1849: } else {
1850: break _loop138;
1851: }
1852:
1853: } while (true);
1854: }
1855: }
1856:
1857: public final void andExpression() throws RecognitionException,
1858: TokenStreamException {
1859:
1860: equalityExpression();
1861: {
1862: _loop141: do {
1863: if ((LA(1) == BAND)) {
1864: match(BAND);
1865: equalityExpression();
1866: } else {
1867: break _loop141;
1868: }
1869:
1870: } while (true);
1871: }
1872: }
1873:
1874: public final void equalityExpression() throws RecognitionException,
1875: TokenStreamException {
1876:
1877: relationalExpression();
1878: {
1879: _loop145: do {
1880: if ((LA(1) == NOT_EQUAL || LA(1) == EQUAL)) {
1881: {
1882: switch (LA(1)) {
1883: case NOT_EQUAL: {
1884: match(NOT_EQUAL);
1885: break;
1886: }
1887: case EQUAL: {
1888: match(EQUAL);
1889: break;
1890: }
1891: default: {
1892: throw new NoViableAltException(LT(1),
1893: getFilename());
1894: }
1895: }
1896: }
1897: relationalExpression();
1898: } else {
1899: break _loop145;
1900: }
1901:
1902: } while (true);
1903: }
1904: }
1905:
1906: public final void relationalExpression()
1907: throws RecognitionException, TokenStreamException {
1908:
1909: shiftExpression();
1910: {
1911: switch (LA(1)) {
1912: case SEMI:
1913: case RBRACK:
1914: case RCURLY:
1915: case COMMA:
1916: case RPAREN:
1917: case ASSIGN:
1918: case COLON:
1919: case PLUS_ASSIGN:
1920: case MINUS_ASSIGN:
1921: case STAR_ASSIGN:
1922: case DIV_ASSIGN:
1923: case MOD_ASSIGN:
1924: case SR_ASSIGN:
1925: case BSR_ASSIGN:
1926: case SL_ASSIGN:
1927: case BAND_ASSIGN:
1928: case BXOR_ASSIGN:
1929: case BOR_ASSIGN:
1930: case QUESTION:
1931: case LOR:
1932: case LAND:
1933: case BOR:
1934: case BXOR:
1935: case BAND:
1936: case NOT_EQUAL:
1937: case EQUAL:
1938: case LT:
1939: case GT:
1940: case LE:
1941: case GE: {
1942: {
1943: _loop150: do {
1944: if (((LA(1) >= LT && LA(1) <= GE))) {
1945: {
1946: switch (LA(1)) {
1947: case LT: {
1948: match(LT);
1949: break;
1950: }
1951: case GT: {
1952: match(GT);
1953: break;
1954: }
1955: case LE: {
1956: match(LE);
1957: break;
1958: }
1959: case GE: {
1960: match(GE);
1961: break;
1962: }
1963: default: {
1964: throw new NoViableAltException(
1965: LT(1), getFilename());
1966: }
1967: }
1968: }
1969: shiftExpression();
1970: } else {
1971: break _loop150;
1972: }
1973:
1974: } while (true);
1975: }
1976: break;
1977: }
1978: case LITERAL_instanceof : {
1979: match(LITERAL_instanceof );
1980: typeSpec();
1981: break;
1982: }
1983: default: {
1984: throw new NoViableAltException(LT(1), getFilename());
1985: }
1986: }
1987: }
1988: }
1989:
1990: public final void shiftExpression() throws RecognitionException,
1991: TokenStreamException {
1992:
1993: additiveExpression();
1994: {
1995: _loop154: do {
1996: if (((LA(1) >= SL && LA(1) <= BSR))) {
1997: {
1998: switch (LA(1)) {
1999: case SL: {
2000: match(SL);
2001: break;
2002: }
2003: case SR: {
2004: match(SR);
2005: break;
2006: }
2007: case BSR: {
2008: match(BSR);
2009: break;
2010: }
2011: default: {
2012: throw new NoViableAltException(LT(1),
2013: getFilename());
2014: }
2015: }
2016: }
2017: additiveExpression();
2018: } else {
2019: break _loop154;
2020: }
2021:
2022: } while (true);
2023: }
2024: }
2025:
2026: public final void additiveExpression() throws RecognitionException,
2027: TokenStreamException {
2028:
2029: multiplicativeExpression();
2030: {
2031: _loop158: do {
2032: if ((LA(1) == PLUS || LA(1) == MINUS)) {
2033: {
2034: switch (LA(1)) {
2035: case PLUS: {
2036: match(PLUS);
2037: break;
2038: }
2039: case MINUS: {
2040: match(MINUS);
2041: break;
2042: }
2043: default: {
2044: throw new NoViableAltException(LT(1),
2045: getFilename());
2046: }
2047: }
2048: }
2049: multiplicativeExpression();
2050: } else {
2051: break _loop158;
2052: }
2053:
2054: } while (true);
2055: }
2056: }
2057:
2058: public final void multiplicativeExpression()
2059: throws RecognitionException, TokenStreamException {
2060:
2061: unaryExpression();
2062: {
2063: _loop162: do {
2064: if ((_tokenSet_22.member(LA(1)))) {
2065: {
2066: switch (LA(1)) {
2067: case STAR: {
2068: match(STAR);
2069: break;
2070: }
2071: case DIV: {
2072: match(DIV);
2073: break;
2074: }
2075: case MOD: {
2076: match(MOD);
2077: break;
2078: }
2079: default: {
2080: throw new NoViableAltException(LT(1),
2081: getFilename());
2082: }
2083: }
2084: }
2085: unaryExpression();
2086: } else {
2087: break _loop162;
2088: }
2089:
2090: } while (true);
2091: }
2092: }
2093:
2094: public final void unaryExpression() throws RecognitionException,
2095: TokenStreamException {
2096:
2097: switch (LA(1)) {
2098: case INC: {
2099: match(INC);
2100: unaryExpression();
2101: break;
2102: }
2103: case DEC: {
2104: match(DEC);
2105: unaryExpression();
2106: break;
2107: }
2108: case MINUS: {
2109: match(MINUS);
2110: unaryExpression();
2111: break;
2112: }
2113: case PLUS: {
2114: match(PLUS);
2115: unaryExpression();
2116: break;
2117: }
2118: case LITERAL_void:
2119: case LITERAL_boolean:
2120: case LITERAL_byte:
2121: case LITERAL_char:
2122: case LITERAL_short:
2123: case LITERAL_int:
2124: case LITERAL_float:
2125: case LITERAL_long:
2126: case LITERAL_double:
2127: case IDENT:
2128: case LPAREN:
2129: case LITERAL_this :
2130: case LITERAL_super :
2131: case BNOT:
2132: case LNOT:
2133: case LITERAL_true:
2134: case LITERAL_false:
2135: case LITERAL_null:
2136: case LITERAL_new:
2137: case NUM_INT:
2138: case CHAR_LITERAL:
2139: case STRING_LITERAL:
2140: case NUM_FLOAT:
2141: case NUM_LONG:
2142: case NUM_DOUBLE: {
2143: unaryExpressionNotPlusMinus();
2144: break;
2145: }
2146: default: {
2147: throw new NoViableAltException(LT(1), getFilename());
2148: }
2149: }
2150: }
2151:
2152: public final void unaryExpressionNotPlusMinus()
2153: throws RecognitionException, TokenStreamException {
2154:
2155: switch (LA(1)) {
2156: case BNOT: {
2157: match(BNOT);
2158: unaryExpression();
2159: break;
2160: }
2161: case LNOT: {
2162: match(LNOT);
2163: unaryExpression();
2164: break;
2165: }
2166: default:
2167: boolean synPredMatched166 = false;
2168: if (((LA(1) == LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
2169: int _m166 = mark();
2170: synPredMatched166 = true;
2171: inputState.guessing++;
2172: try {
2173: {
2174: match(LPAREN);
2175: builtInTypeSpec();
2176: match(RPAREN);
2177: }
2178: } catch (RecognitionException pe) {
2179: synPredMatched166 = false;
2180: }
2181: rewind(_m166);
2182: inputState.guessing--;
2183: }
2184: if (synPredMatched166) {
2185: match(LPAREN);
2186: builtInTypeSpec();
2187: match(RPAREN);
2188: unaryExpression();
2189: } else {
2190: boolean synPredMatched168 = false;
2191: if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
2192: int _m168 = mark();
2193: synPredMatched168 = true;
2194: inputState.guessing++;
2195: try {
2196: {
2197: match(LPAREN);
2198: classTypeSpec();
2199: match(RPAREN);
2200: unaryExpressionNotPlusMinus();
2201: }
2202: } catch (RecognitionException pe) {
2203: synPredMatched168 = false;
2204: }
2205: rewind(_m168);
2206: inputState.guessing--;
2207: }
2208: if (synPredMatched168) {
2209: match(LPAREN);
2210: classTypeSpec();
2211: match(RPAREN);
2212: unaryExpressionNotPlusMinus();
2213: } else if ((_tokenSet_23.member(LA(1)))
2214: && (_tokenSet_24.member(LA(2)))) {
2215: postfixExpression();
2216: } else {
2217: throw new NoViableAltException(LT(1), getFilename());
2218: }
2219: }
2220: }
2221: }
2222:
2223: public final void postfixExpression() throws RecognitionException,
2224: TokenStreamException {
2225:
2226: primaryExpression();
2227: {
2228: _loop174: do {
2229: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
2230: match(DOT);
2231: match(IDENT);
2232: {
2233: switch (LA(1)) {
2234: case LPAREN: {
2235: match(LPAREN);
2236: argList();
2237: match(RPAREN);
2238: break;
2239: }
2240: case SEMI:
2241: case LBRACK:
2242: case RBRACK:
2243: case DOT:
2244: case STAR:
2245: case RCURLY:
2246: case COMMA:
2247: case RPAREN:
2248: case ASSIGN:
2249: case COLON:
2250: case PLUS_ASSIGN:
2251: case MINUS_ASSIGN:
2252: case STAR_ASSIGN:
2253: case DIV_ASSIGN:
2254: case MOD_ASSIGN:
2255: case SR_ASSIGN:
2256: case BSR_ASSIGN:
2257: case SL_ASSIGN:
2258: case BAND_ASSIGN:
2259: case BXOR_ASSIGN:
2260: case BOR_ASSIGN:
2261: case QUESTION:
2262: case LOR:
2263: case LAND:
2264: case BOR:
2265: case BXOR:
2266: case BAND:
2267: case NOT_EQUAL:
2268: case EQUAL:
2269: case LT:
2270: case GT:
2271: case LE:
2272: case GE:
2273: case LITERAL_instanceof :
2274: case SL:
2275: case SR:
2276: case BSR:
2277: case PLUS:
2278: case MINUS:
2279: case DIV:
2280: case MOD:
2281: case INC:
2282: case DEC: {
2283: break;
2284: }
2285: default: {
2286: throw new NoViableAltException(LT(1),
2287: getFilename());
2288: }
2289: }
2290: }
2291: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_this )) {
2292: match(DOT);
2293: match(LITERAL_this );
2294: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_super )) {
2295: match(DOT);
2296: match(LITERAL_super );
2297: {
2298: switch (LA(1)) {
2299: case LPAREN: {
2300: match(LPAREN);
2301: argList();
2302: match(RPAREN);
2303: break;
2304: }
2305: case DOT: {
2306: match(DOT);
2307: match(IDENT);
2308: {
2309: switch (LA(1)) {
2310: case LPAREN: {
2311: match(LPAREN);
2312: argList();
2313: match(RPAREN);
2314: break;
2315: }
2316: case SEMI:
2317: case LBRACK:
2318: case RBRACK:
2319: case DOT:
2320: case STAR:
2321: case RCURLY:
2322: case COMMA:
2323: case RPAREN:
2324: case ASSIGN:
2325: case COLON:
2326: case PLUS_ASSIGN:
2327: case MINUS_ASSIGN:
2328: case STAR_ASSIGN:
2329: case DIV_ASSIGN:
2330: case MOD_ASSIGN:
2331: case SR_ASSIGN:
2332: case BSR_ASSIGN:
2333: case SL_ASSIGN:
2334: case BAND_ASSIGN:
2335: case BXOR_ASSIGN:
2336: case BOR_ASSIGN:
2337: case QUESTION:
2338: case LOR:
2339: case LAND:
2340: case BOR:
2341: case BXOR:
2342: case BAND:
2343: case NOT_EQUAL:
2344: case EQUAL:
2345: case LT:
2346: case GT:
2347: case LE:
2348: case GE:
2349: case LITERAL_instanceof :
2350: case SL:
2351: case SR:
2352: case BSR:
2353: case PLUS:
2354: case MINUS:
2355: case DIV:
2356: case MOD:
2357: case INC:
2358: case DEC: {
2359: break;
2360: }
2361: default: {
2362: throw new NoViableAltException(
2363: LT(1), getFilename());
2364: }
2365: }
2366: }
2367: break;
2368: }
2369: default: {
2370: throw new NoViableAltException(LT(1),
2371: getFilename());
2372: }
2373: }
2374: }
2375: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_new)) {
2376: match(DOT);
2377: newExpression();
2378: } else if ((LA(1) == LBRACK)) {
2379: match(LBRACK);
2380: expression();
2381: match(RBRACK);
2382: } else {
2383: break _loop174;
2384: }
2385:
2386: } while (true);
2387: }
2388: {
2389: switch (LA(1)) {
2390: case INC: {
2391: match(INC);
2392: break;
2393: }
2394: case DEC: {
2395: match(DEC);
2396: break;
2397: }
2398: case SEMI:
2399: case RBRACK:
2400: case STAR:
2401: case RCURLY:
2402: case COMMA:
2403: case RPAREN:
2404: case ASSIGN:
2405: case COLON:
2406: case PLUS_ASSIGN:
2407: case MINUS_ASSIGN:
2408: case STAR_ASSIGN:
2409: case DIV_ASSIGN:
2410: case MOD_ASSIGN:
2411: case SR_ASSIGN:
2412: case BSR_ASSIGN:
2413: case SL_ASSIGN:
2414: case BAND_ASSIGN:
2415: case BXOR_ASSIGN:
2416: case BOR_ASSIGN:
2417: case QUESTION:
2418: case LOR:
2419: case LAND:
2420: case BOR:
2421: case BXOR:
2422: case BAND:
2423: case NOT_EQUAL:
2424: case EQUAL:
2425: case LT:
2426: case GT:
2427: case LE:
2428: case GE:
2429: case LITERAL_instanceof :
2430: case SL:
2431: case SR:
2432: case BSR:
2433: case PLUS:
2434: case MINUS:
2435: case DIV:
2436: case MOD: {
2437: break;
2438: }
2439: default: {
2440: throw new NoViableAltException(LT(1), getFilename());
2441: }
2442: }
2443: }
2444: }
2445:
2446: public final void primaryExpression() throws RecognitionException,
2447: TokenStreamException {
2448:
2449: switch (LA(1)) {
2450: case IDENT: {
2451: identPrimary();
2452: {
2453: if ((LA(1) == DOT) && (LA(2) == LITERAL_class)) {
2454: match(DOT);
2455: match(LITERAL_class);
2456: } else if ((_tokenSet_25.member(LA(1)))
2457: && (_tokenSet_26.member(LA(2)))) {
2458: } else {
2459: throw new NoViableAltException(LT(1), getFilename());
2460: }
2461:
2462: }
2463: break;
2464: }
2465: case NUM_INT:
2466: case CHAR_LITERAL:
2467: case STRING_LITERAL:
2468: case NUM_FLOAT:
2469: case NUM_LONG:
2470: case NUM_DOUBLE: {
2471: constant();
2472: break;
2473: }
2474: case LITERAL_true: {
2475: match(LITERAL_true);
2476: break;
2477: }
2478: case LITERAL_false: {
2479: match(LITERAL_false);
2480: break;
2481: }
2482: case LITERAL_null: {
2483: match(LITERAL_null);
2484: break;
2485: }
2486: case LITERAL_new: {
2487: newExpression();
2488: break;
2489: }
2490: case LITERAL_this : {
2491: match(LITERAL_this );
2492: break;
2493: }
2494: case LITERAL_super : {
2495: match(LITERAL_super );
2496: break;
2497: }
2498: case LPAREN: {
2499: match(LPAREN);
2500: assignmentExpression();
2501: match(RPAREN);
2502: break;
2503: }
2504: case LITERAL_void:
2505: case LITERAL_boolean:
2506: case LITERAL_byte:
2507: case LITERAL_char:
2508: case LITERAL_short:
2509: case LITERAL_int:
2510: case LITERAL_float:
2511: case LITERAL_long:
2512: case LITERAL_double: {
2513: builtInType();
2514: {
2515: _loop179: do {
2516: if ((LA(1) == LBRACK)) {
2517: match(LBRACK);
2518: match(RBRACK);
2519: } else {
2520: break _loop179;
2521: }
2522:
2523: } while (true);
2524: }
2525: match(DOT);
2526: match(LITERAL_class);
2527: break;
2528: }
2529: default: {
2530: throw new NoViableAltException(LT(1), getFilename());
2531: }
2532: }
2533: }
2534:
2535: /** object instantiation.
2536: * Trees are built as illustrated by the following input/tree pairs:
2537: *
2538: * new T()
2539: *
2540: * new
2541: * |
2542: * T -- ELIST
2543: * |
2544: * arg1 -- arg2 -- .. -- argn
2545: *
2546: * new int[]
2547: *
2548: * new
2549: * |
2550: * int -- ARRAY_DECLARATOR
2551: *
2552: * new int[] {1,2}
2553: *
2554: * new
2555: * |
2556: * int -- ARRAY_DECLARATOR -- ARRAY_INIT
2557: * |
2558: * EXPR -- EXPR
2559: * | |
2560: * 1 2
2561: *
2562: * new int[3]
2563: * new
2564: * |
2565: * int -- ARRAY_DECLARATOR
2566: * |
2567: * EXPR
2568: * |
2569: * 3
2570: *
2571: * new int[1][2]
2572: *
2573: * new
2574: * |
2575: * int -- ARRAY_DECLARATOR
2576: * |
2577: * ARRAY_DECLARATOR -- EXPR
2578: * | |
2579: * EXPR 1
2580: * |
2581: * 2
2582: *
2583: */
2584: public final void newExpression() throws RecognitionException,
2585: TokenStreamException {
2586:
2587: match(LITERAL_new);
2588: type();
2589: {
2590: switch (LA(1)) {
2591: case LPAREN: {
2592: match(LPAREN);
2593: argList();
2594: match(RPAREN);
2595: {
2596: switch (LA(1)) {
2597: case LCURLY: {
2598: classBlock();
2599: break;
2600: }
2601: case SEMI:
2602: case LBRACK:
2603: case RBRACK:
2604: case DOT:
2605: case STAR:
2606: case RCURLY:
2607: case COMMA:
2608: case RPAREN:
2609: case ASSIGN:
2610: case COLON:
2611: case PLUS_ASSIGN:
2612: case MINUS_ASSIGN:
2613: case STAR_ASSIGN:
2614: case DIV_ASSIGN:
2615: case MOD_ASSIGN:
2616: case SR_ASSIGN:
2617: case BSR_ASSIGN:
2618: case SL_ASSIGN:
2619: case BAND_ASSIGN:
2620: case BXOR_ASSIGN:
2621: case BOR_ASSIGN:
2622: case QUESTION:
2623: case LOR:
2624: case LAND:
2625: case BOR:
2626: case BXOR:
2627: case BAND:
2628: case NOT_EQUAL:
2629: case EQUAL:
2630: case LT:
2631: case GT:
2632: case LE:
2633: case GE:
2634: case LITERAL_instanceof :
2635: case SL:
2636: case SR:
2637: case BSR:
2638: case PLUS:
2639: case MINUS:
2640: case DIV:
2641: case MOD:
2642: case INC:
2643: case DEC: {
2644: break;
2645: }
2646: default: {
2647: throw new NoViableAltException(LT(1),
2648: getFilename());
2649: }
2650: }
2651: }
2652: break;
2653: }
2654: case LBRACK: {
2655: newArrayDeclarator();
2656: {
2657: switch (LA(1)) {
2658: case LCURLY: {
2659: arrayInitializer();
2660: break;
2661: }
2662: case SEMI:
2663: case LBRACK:
2664: case RBRACK:
2665: case DOT:
2666: case STAR:
2667: case RCURLY:
2668: case COMMA:
2669: case RPAREN:
2670: case ASSIGN:
2671: case COLON:
2672: case PLUS_ASSIGN:
2673: case MINUS_ASSIGN:
2674: case STAR_ASSIGN:
2675: case DIV_ASSIGN:
2676: case MOD_ASSIGN:
2677: case SR_ASSIGN:
2678: case BSR_ASSIGN:
2679: case SL_ASSIGN:
2680: case BAND_ASSIGN:
2681: case BXOR_ASSIGN:
2682: case BOR_ASSIGN:
2683: case QUESTION:
2684: case LOR:
2685: case LAND:
2686: case BOR:
2687: case BXOR:
2688: case BAND:
2689: case NOT_EQUAL:
2690: case EQUAL:
2691: case LT:
2692: case GT:
2693: case LE:
2694: case GE:
2695: case LITERAL_instanceof :
2696: case SL:
2697: case SR:
2698: case BSR:
2699: case PLUS:
2700: case MINUS:
2701: case DIV:
2702: case MOD:
2703: case INC:
2704: case DEC: {
2705: break;
2706: }
2707: default: {
2708: throw new NoViableAltException(LT(1),
2709: getFilename());
2710: }
2711: }
2712: }
2713: break;
2714: }
2715: default: {
2716: throw new NoViableAltException(LT(1), getFilename());
2717: }
2718: }
2719: }
2720: }
2721:
2722: /** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
2723: * and a.b.c.class refs. Also this(...) and super(...). Match
2724: * this or super.
2725: */
2726: public final void identPrimary() throws RecognitionException,
2727: TokenStreamException {
2728:
2729: match(IDENT);
2730: {
2731: _loop182: do {
2732: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
2733: match(DOT);
2734: match(IDENT);
2735: } else {
2736: break _loop182;
2737: }
2738:
2739: } while (true);
2740: }
2741: {
2742: if ((LA(1) == LPAREN)) {
2743: {
2744: match(LPAREN);
2745: argList();
2746: match(RPAREN);
2747: }
2748: } else if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
2749: {
2750: int _cnt186 = 0;
2751: _loop186: do {
2752: if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
2753: match(LBRACK);
2754: match(RBRACK);
2755: } else {
2756: if (_cnt186 >= 1) {
2757: break _loop186;
2758: } else {
2759: throw new NoViableAltException(LT(1),
2760: getFilename());
2761: }
2762: }
2763:
2764: _cnt186++;
2765: } while (true);
2766: }
2767: } else if ((_tokenSet_25.member(LA(1)))
2768: && (_tokenSet_26.member(LA(2)))) {
2769: } else {
2770: throw new NoViableAltException(LT(1), getFilename());
2771: }
2772:
2773: }
2774: }
2775:
2776: public final void constant() throws RecognitionException,
2777: TokenStreamException {
2778:
2779: switch (LA(1)) {
2780: case NUM_INT: {
2781: match(NUM_INT);
2782: break;
2783: }
2784: case CHAR_LITERAL: {
2785: match(CHAR_LITERAL);
2786: break;
2787: }
2788: case STRING_LITERAL: {
2789: match(STRING_LITERAL);
2790: break;
2791: }
2792: case NUM_FLOAT: {
2793: match(NUM_FLOAT);
2794: break;
2795: }
2796: case NUM_LONG: {
2797: match(NUM_LONG);
2798: break;
2799: }
2800: case NUM_DOUBLE: {
2801: match(NUM_DOUBLE);
2802: break;
2803: }
2804: default: {
2805: throw new NoViableAltException(LT(1), getFilename());
2806: }
2807: }
2808: }
2809:
2810: public final void newArrayDeclarator() throws RecognitionException,
2811: TokenStreamException {
2812:
2813: {
2814: int _cnt196 = 0;
2815: _loop196: do {
2816: if ((LA(1) == LBRACK) && (_tokenSet_27.member(LA(2)))) {
2817: match(LBRACK);
2818: {
2819: switch (LA(1)) {
2820: case LITERAL_void:
2821: case LITERAL_boolean:
2822: case LITERAL_byte:
2823: case LITERAL_char:
2824: case LITERAL_short:
2825: case LITERAL_int:
2826: case LITERAL_float:
2827: case LITERAL_long:
2828: case LITERAL_double:
2829: case IDENT:
2830: case LPAREN:
2831: case LITERAL_this :
2832: case LITERAL_super :
2833: case PLUS:
2834: case MINUS:
2835: case INC:
2836: case DEC:
2837: case BNOT:
2838: case LNOT:
2839: case LITERAL_true:
2840: case LITERAL_false:
2841: case LITERAL_null:
2842: case LITERAL_new:
2843: case NUM_INT:
2844: case CHAR_LITERAL:
2845: case STRING_LITERAL:
2846: case NUM_FLOAT:
2847: case NUM_LONG:
2848: case NUM_DOUBLE: {
2849: expression();
2850: break;
2851: }
2852: case RBRACK: {
2853: break;
2854: }
2855: default: {
2856: throw new NoViableAltException(LT(1),
2857: getFilename());
2858: }
2859: }
2860: }
2861: match(RBRACK);
2862: } else {
2863: if (_cnt196 >= 1) {
2864: break _loop196;
2865: } else {
2866: throw new NoViableAltException(LT(1),
2867: getFilename());
2868: }
2869: }
2870:
2871: _cnt196++;
2872: } while (true);
2873: }
2874: }
2875:
2876: public static final String[] _tokenNames = { "<0>", "EOF", "<2>",
2877: "NULL_TREE_LOOKAHEAD", "BLOCK", "MODIFIERS", "OBJBLOCK",
2878: "SLIST", "CTOR_DEF", "METHOD_DEF", "VARIABLE_DEF",
2879: "INSTANCE_INIT", "STATIC_INIT", "TYPE", "CLASS_DEF",
2880: "INTERFACE_DEF", "PACKAGE_DEF", "ARRAY_DECLARATOR",
2881: "EXTENDS_CLAUSE", "IMPLEMENTS_CLAUSE", "PARAMETERS",
2882: "PARAMETER_DEF", "LABELED_STAT", "TYPECAST", "INDEX_OP",
2883: "POST_INC", "POST_DEC", "METHOD_CALL", "EXPR",
2884: "ARRAY_INIT", "IMPORT", "UNARY_MINUS", "UNARY_PLUS",
2885: "CASE_GROUP", "ELIST", "FOR_INIT", "FOR_CONDITION",
2886: "FOR_ITERATOR", "EMPTY_STAT", "\"final\"", "\"abstract\"",
2887: "\"strictfp\"", "SUPER_CTOR_CALL", "CTOR_CALL",
2888: "\"package\"", "SEMI", "\"import\"", "LBRACK", "RBRACK",
2889: "\"void\"", "\"boolean\"", "\"byte\"", "\"char\"",
2890: "\"short\"", "\"int\"", "\"float\"", "\"long\"",
2891: "\"double\"", "IDENT", "DOT", "STAR", "\"private\"",
2892: "\"public\"", "\"protected\"", "\"static\"",
2893: "\"transient\"", "\"native\"", "\"threadsafe\"",
2894: "\"synchronized\"", "\"volatile\"", "\"class\"",
2895: "\"extends\"", "\"interface\"", "LCURLY", "RCURLY",
2896: "COMMA", "\"implements\"", "LPAREN", "RPAREN", "\"this\"",
2897: "\"super\"", "ASSIGN", "\"throws\"", "COLON", "\"if\"",
2898: "\"else\"", "\"for\"", "\"while\"", "\"do\"", "\"break\"",
2899: "\"continue\"", "\"return\"", "\"switch\"", "\"throw\"",
2900: "\"case\"", "\"default\"", "\"try\"", "\"finally\"",
2901: "\"catch\"", "PLUS_ASSIGN", "MINUS_ASSIGN", "STAR_ASSIGN",
2902: "DIV_ASSIGN", "MOD_ASSIGN", "SR_ASSIGN", "BSR_ASSIGN",
2903: "SL_ASSIGN", "BAND_ASSIGN", "BXOR_ASSIGN", "BOR_ASSIGN",
2904: "QUESTION", "LOR", "LAND", "BOR", "BXOR", "BAND",
2905: "NOT_EQUAL", "EQUAL", "LT", "GT", "LE", "GE",
2906: "\"instanceof\"", "SL", "SR", "BSR", "PLUS", "MINUS",
2907: "DIV", "MOD", "INC", "DEC", "BNOT", "LNOT", "\"true\"",
2908: "\"false\"", "\"null\"", "\"new\"", "NUM_INT",
2909: "CHAR_LITERAL", "STRING_LITERAL", "NUM_FLOAT", "NUM_LONG",
2910: "NUM_DOUBLE", "WS", "SL_COMMENT", "ML_COMMENT", "ESC",
2911: "HEX_DIGIT", "VOCAB", "EXPONENT", "FLOAT_SUFFIX" };
2912:
2913: private static final long[] mk_tokenSet_0() {
2914: long[] data = { -2305803976550907904L, 383L, 0L, 0L };
2915: return data;
2916: }
2917:
2918: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
2919:
2920: private static final long[] mk_tokenSet_1() {
2921: long[] data = { -2305733607806730238L, 383L, 0L, 0L };
2922: return data;
2923: }
2924:
2925: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
2926:
2927: private static final long[] mk_tokenSet_2() {
2928: long[] data = { -2305803976550907902L, 383L, 0L, 0L };
2929: return data;
2930: }
2931:
2932: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
2933:
2934: private static final long[] mk_tokenSet_3() {
2935: long[] data = { -2305839160922996736L, 63L, 0L, 0L };
2936: return data;
2937: }
2938:
2939: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
2940:
2941: private static final long[] mk_tokenSet_4() {
2942: long[] data = { -1729941358572994560L, 383L, 0L, 0L };
2943: return data;
2944: }
2945:
2946: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
2947:
2948: private static final long[] mk_tokenSet_5() {
2949: long[] data = { -1153339868781215744L, 8575L, 0L, 0L };
2950: return data;
2951: }
2952:
2953: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
2954:
2955: private static final long[] mk_tokenSet_6() {
2956: long[] data = { 864831865943490560L, 0L, 0L };
2957: return data;
2958: }
2959:
2960: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
2961:
2962: private static final long[] mk_tokenSet_7() {
2963: long[] data = { 175921860444160L, 133120L, 0L, 0L };
2964: return data;
2965: }
2966:
2967: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
2968:
2969: private static final long[] mk_tokenSet_8() {
2970: long[] data = { -1729906174200905728L, -4611686013061716353L,
2971: 65532L, 0L, 0L, 0L };
2972: return data;
2973: }
2974:
2975: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
2976:
2977: private static final long[] mk_tokenSet_9() {
2978: long[] data = { -383179802279936L, -28993411201L, 65535L, 0L,
2979: 0L, 0L };
2980: return data;
2981: }
2982:
2983: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
2984:
2985: private static final long[] mk_tokenSet_10() {
2986: long[] data = { -1729906174200905728L, -4611686013061717377L,
2987: 65532L, 0L, 0L, 0L };
2988: return data;
2989: }
2990:
2991: public static final BitSet _tokenSet_10 = new BitSet(
2992: mk_tokenSet_10());
2993:
2994: private static final long[] mk_tokenSet_11() {
2995: long[] data = { -1729906174200905728L, -4611686009838393729L,
2996: 65532L, 0L, 0L, 0L };
2997: return data;
2998: }
2999:
3000: public static final BitSet _tokenSet_11 = new BitSet(
3001: mk_tokenSet_11());
3002:
3003: private static final long[] mk_tokenSet_12() {
3004: long[] data = { -383179802279936L, -284801L, 65535L, 0L, 0L, 0L };
3005: return data;
3006: }
3007:
3008: public static final BitSet _tokenSet_12 = new BitSet(
3009: mk_tokenSet_12());
3010:
3011: private static final long[] mk_tokenSet_13() {
3012: long[] data = { -1729941358572994560L, 63L, 0L, 0L };
3013: return data;
3014: }
3015:
3016: public static final BitSet _tokenSet_13 = new BitSet(
3017: mk_tokenSet_13());
3018:
3019: private static final long[] mk_tokenSet_14() {
3020: long[] data = { -1153339868781215744L, 63L, 0L, 0L };
3021: return data;
3022: }
3023:
3024: public static final BitSet _tokenSet_14 = new BitSet(
3025: mk_tokenSet_14());
3026:
3027: private static final long[] mk_tokenSet_15() {
3028: long[] data = { 575897802350002176L, -4611686018427281408L,
3029: 65532L, 0L, 0L, 0L };
3030: return data;
3031: }
3032:
3033: public static final BitSet _tokenSet_15 = new BitSet(
3034: mk_tokenSet_15());
3035:
3036: private static final long[] mk_tokenSet_16() {
3037: long[] data = { 2305455981120716800L, -34359500800L, 65535L,
3038: 0L, 0L, 0L };
3039: return data;
3040: }
3041:
3042: public static final BitSet _tokenSet_16 = new BitSet(
3043: mk_tokenSet_16());
3044:
3045: private static final long[] mk_tokenSet_17() {
3046: long[] data = { -2305839160922996736L, 127L, 0L, 0L };
3047: return data;
3048: }
3049:
3050: public static final BitSet _tokenSet_17 = new BitSet(
3051: mk_tokenSet_17());
3052:
3053: private static final long[] mk_tokenSet_18() {
3054: long[] data = { -2017608784771284992L, 127L, 0L, 0L };
3055: return data;
3056: }
3057:
3058: public static final BitSet _tokenSet_18 = new BitSet(
3059: mk_tokenSet_18());
3060:
3061: private static final long[] mk_tokenSet_19() {
3062: long[] data = { 575897802350002176L, -4611686018427280896L,
3063: 65532L, 0L, 0L, 0L };
3064: return data;
3065: }
3066:
3067: public static final BitSet _tokenSet_19 = new BitSet(
3068: mk_tokenSet_19());
3069:
3070: private static final long[] mk_tokenSet_20() {
3071: long[] data = { 2305455981120716800L, -34359498752L, 65535L,
3072: 0L, 0L, 0L };
3073: return data;
3074: }
3075:
3076: public static final BitSet _tokenSet_20 = new BitSet(
3077: mk_tokenSet_20());
3078:
3079: private static final long[] mk_tokenSet_21() {
3080: long[] data = { 575897802350002176L, -4611686018426757120L,
3081: 65532L, 0L, 0L, 0L };
3082: return data;
3083: }
3084:
3085: public static final BitSet _tokenSet_21 = new BitSet(
3086: mk_tokenSet_21());
3087:
3088: private static final long[] mk_tokenSet_22() {
3089: long[] data = { 1152921504606846976L, 0L, 3L, 0L, 0L, 0L };
3090: return data;
3091: }
3092:
3093: public static final BitSet _tokenSet_22 = new BitSet(
3094: mk_tokenSet_22());
3095:
3096: private static final long[] mk_tokenSet_23() {
3097: long[] data = { 575897802350002176L, 106496L, 65472L, 0L, 0L,
3098: 0L };
3099: return data;
3100: }
3101:
3102: public static final BitSet _tokenSet_23 = new BitSet(
3103: mk_tokenSet_23());
3104:
3105: private static final long[] mk_tokenSet_24() {
3106: long[] data = { 2305737456097427456L, -34358957056L, 65535L,
3107: 0L, 0L, 0L };
3108: return data;
3109: }
3110:
3111: public static final BitSet _tokenSet_24 = new BitSet(
3112: mk_tokenSet_24());
3113:
3114: private static final long[] mk_tokenSet_25() {
3115: long[] data = { 1729839653747425280L, -34359063552L, 15L, 0L,
3116: 0L, 0L };
3117: return data;
3118: }
3119:
3120: public static final BitSet _tokenSet_25 = new BitSet(
3121: mk_tokenSet_25());
3122:
3123: private static final long[] mk_tokenSet_26() {
3124: long[] data = { -101704825569280L, -25770070145L, 65535L, 0L,
3125: 0L, 0L };
3126: return data;
3127: }
3128:
3129: public static final BitSet _tokenSet_26 = new BitSet(
3130: mk_tokenSet_26());
3131:
3132: private static final long[] mk_tokenSet_27() {
3133: long[] data = { 576179277326712832L, -4611686018427281408L,
3134: 65532L, 0L, 0L, 0L };
3135: return data;
3136: }
3137:
3138: public static final BitSet _tokenSet_27 = new BitSet(
3139: mk_tokenSet_27());
3140:
3141: }
|