0001: // $ANTLR 2.7.5 (20050128): "EJB3query.g" -> "EJB3QueryParser.java"$
0002:
0003: package com.jofti.parser.ejb;
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: import antlr.collections.AST;
0019: import java.util.Hashtable;
0020: import antlr.ASTFactory;
0021: import antlr.ASTPair;
0022: import antlr.collections.impl.ASTArray;
0023:
0024: public class EJB3QueryParser extends antlr.LLkParser implements
0025: EJB3QueryParserTokenTypes {
0026:
0027: protected EJB3QueryParser(TokenBuffer tokenBuf, int k) {
0028: super (tokenBuf, k);
0029: tokenNames = _tokenNames;
0030: buildTokenTypeASTClassMap();
0031: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0032: }
0033:
0034: public EJB3QueryParser(TokenBuffer tokenBuf) {
0035: this (tokenBuf, 4);
0036: }
0037:
0038: protected EJB3QueryParser(TokenStream lexer, int k) {
0039: super (lexer, k);
0040: tokenNames = _tokenNames;
0041: buildTokenTypeASTClassMap();
0042: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0043: }
0044:
0045: public EJB3QueryParser(TokenStream lexer) {
0046: this (lexer, 4);
0047: }
0048:
0049: public EJB3QueryParser(ParserSharedInputState state) {
0050: super (state, 4);
0051: tokenNames = _tokenNames;
0052: buildTokenTypeASTClassMap();
0053: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0054: }
0055:
0056: public final void queryStatement() throws RecognitionException,
0057: TokenStreamException {
0058:
0059: returnAST = null;
0060: ASTPair currentAST = new ASTPair();
0061: AST queryStatement_AST = null;
0062:
0063: try { // for error handling
0064: querySpecification();
0065: astFactory.addASTChild(currentAST, returnAST);
0066: match(SEMICOLON);
0067: queryStatement_AST = (AST) currentAST.root;
0068: } catch (RecognitionException ex) {
0069: if (inputState.guessing == 0) {
0070: reportError(ex);
0071: recover(ex, _tokenSet_0);
0072: } else {
0073: throw ex;
0074: }
0075: }
0076: returnAST = queryStatement_AST;
0077: }
0078:
0079: public final void querySpecification() throws RecognitionException,
0080: TokenStreamException {
0081:
0082: returnAST = null;
0083: ASTPair currentAST = new ASTPair();
0084: AST querySpecification_AST = null;
0085:
0086: try { // for error handling
0087: AST tmp2_AST = null;
0088: tmp2_AST = astFactory.create(LT(1));
0089: astFactory.makeASTRoot(currentAST, tmp2_AST);
0090: match(SELECT);
0091: selectList();
0092: astFactory.addASTChild(currentAST, returnAST);
0093: AST tmp3_AST = null;
0094: tmp3_AST = astFactory.create(LT(1));
0095: astFactory.makeASTRoot(currentAST, tmp3_AST);
0096: match(FROM);
0097: fromList();
0098: astFactory.addASTChild(currentAST, returnAST);
0099: {
0100: switch (LA(1)) {
0101: case WHERE: {
0102: AST tmp4_AST = null;
0103: tmp4_AST = astFactory.create(LT(1));
0104: astFactory.makeASTRoot(currentAST, tmp4_AST);
0105: match(WHERE);
0106: predicateList();
0107: astFactory.addASTChild(currentAST, returnAST);
0108: break;
0109: }
0110: case NAMESPACE:
0111: case ORDER:
0112: case SEMICOLON: {
0113: break;
0114: }
0115: default: {
0116: throw new NoViableAltException(LT(1), getFilename());
0117: }
0118: }
0119: }
0120: {
0121: switch (LA(1)) {
0122: case ORDER: {
0123: AST tmp5_AST = null;
0124: tmp5_AST = astFactory.create(LT(1));
0125: astFactory.makeASTRoot(currentAST, tmp5_AST);
0126: match(ORDER);
0127: match(BY);
0128: orderList();
0129: astFactory.addASTChild(currentAST, returnAST);
0130: break;
0131: }
0132: case NAMESPACE:
0133: case SEMICOLON: {
0134: break;
0135: }
0136: default: {
0137: throw new NoViableAltException(LT(1), getFilename());
0138: }
0139: }
0140: }
0141: {
0142: switch (LA(1)) {
0143: case NAMESPACE: {
0144: AST tmp7_AST = null;
0145: tmp7_AST = astFactory.create(LT(1));
0146: astFactory.makeASTRoot(currentAST, tmp7_AST);
0147: match(NAMESPACE);
0148: nameSpace();
0149: astFactory.addASTChild(currentAST, returnAST);
0150: break;
0151: }
0152: case SEMICOLON: {
0153: break;
0154: }
0155: default: {
0156: throw new NoViableAltException(LT(1), getFilename());
0157: }
0158: }
0159: }
0160: querySpecification_AST = (AST) currentAST.root;
0161: } catch (RecognitionException ex) {
0162: if (inputState.guessing == 0) {
0163: reportError(ex);
0164: recover(ex, _tokenSet_1);
0165: } else {
0166: throw ex;
0167: }
0168: }
0169: returnAST = querySpecification_AST;
0170: }
0171:
0172: public final void selectList() throws RecognitionException,
0173: TokenStreamException {
0174:
0175: returnAST = null;
0176: ASTPair currentAST = new ASTPair();
0177: AST selectList_AST = null;
0178:
0179: try { // for error handling
0180: boolean synPredMatched8 = false;
0181: if (((LA(1) == Identifier) && (LA(2) == COMMA || LA(2) == Identifier))) {
0182: int _m8 = mark();
0183: synPredMatched8 = true;
0184: inputState.guessing++;
0185: try {
0186: {
0187: className();
0188: }
0189: } catch (RecognitionException pe) {
0190: synPredMatched8 = false;
0191: }
0192: rewind(_m8);
0193: inputState.guessing--;
0194: }
0195: if (synPredMatched8) {
0196: className();
0197: astFactory.addASTChild(currentAST, returnAST);
0198: {
0199: int _cnt11 = 0;
0200: _loop11: do {
0201: if ((LA(1) == COMMA || LA(1) == Identifier)) {
0202: {
0203: switch (LA(1)) {
0204: case COMMA: {
0205: match(COMMA);
0206: break;
0207: }
0208: case Identifier: {
0209: break;
0210: }
0211: default: {
0212: throw new NoViableAltException(
0213: LT(1), getFilename());
0214: }
0215: }
0216: }
0217: className();
0218: astFactory.addASTChild(currentAST,
0219: returnAST);
0220: } else {
0221: if (_cnt11 >= 1) {
0222: break _loop11;
0223: } else {
0224: throw new NoViableAltException(LT(1),
0225: getFilename());
0226: }
0227: }
0228:
0229: _cnt11++;
0230: } while (true);
0231: }
0232: selectList_AST = (AST) currentAST.root;
0233: } else if ((LA(1) == Identifier) && (LA(2) == FROM)) {
0234: className();
0235: astFactory.addASTChild(currentAST, returnAST);
0236: selectList_AST = (AST) currentAST.root;
0237: } else {
0238: throw new NoViableAltException(LT(1), getFilename());
0239: }
0240:
0241: } catch (RecognitionException ex) {
0242: if (inputState.guessing == 0) {
0243: reportError(ex);
0244: recover(ex, _tokenSet_2);
0245: } else {
0246: throw ex;
0247: }
0248: }
0249: returnAST = selectList_AST;
0250: }
0251:
0252: public final void fromList() throws RecognitionException,
0253: TokenStreamException {
0254:
0255: returnAST = null;
0256: ASTPair currentAST = new ASTPair();
0257: AST fromList_AST = null;
0258:
0259: try { // for error handling
0260: boolean synPredMatched14 = false;
0261: if (((LA(1) == Identifier)
0262: && (LA(2) == ALIAS_IDENTIFIER || LA(2) == Identifier)
0263: && (_tokenSet_3.member(LA(3))) && (_tokenSet_4
0264: .member(LA(4))))) {
0265: int _m14 = mark();
0266: synPredMatched14 = true;
0267: inputState.guessing++;
0268: try {
0269: {
0270: fullClassName();
0271: }
0272: } catch (RecognitionException pe) {
0273: synPredMatched14 = false;
0274: }
0275: rewind(_m14);
0276: inputState.guessing--;
0277: }
0278: if (synPredMatched14) {
0279: fullClassName();
0280: astFactory.addASTChild(currentAST, returnAST);
0281: {
0282: _loop17: do {
0283: if ((LA(1) == COMMA)) {
0284: match(COMMA);
0285: {
0286: switch (LA(1)) {
0287: case IN: {
0288: collectionIdentifierName();
0289: astFactory.addASTChild(currentAST,
0290: returnAST);
0291: break;
0292: }
0293: case Identifier: {
0294: fullClassName();
0295: astFactory.addASTChild(currentAST,
0296: returnAST);
0297: break;
0298: }
0299: default: {
0300: throw new NoViableAltException(
0301: LT(1), getFilename());
0302: }
0303: }
0304: }
0305: } else {
0306: break _loop17;
0307: }
0308:
0309: } while (true);
0310: }
0311: fromList_AST = (AST) currentAST.root;
0312: } else if ((LA(1) == Identifier)
0313: && (LA(2) == ALIAS_IDENTIFIER || LA(2) == Identifier)
0314: && (_tokenSet_5.member(LA(3)))
0315: && (_tokenSet_6.member(LA(4)))) {
0316: fullClassName();
0317: astFactory.addASTChild(currentAST, returnAST);
0318: fromList_AST = (AST) currentAST.root;
0319: } else {
0320: throw new NoViableAltException(LT(1), getFilename());
0321: }
0322:
0323: } catch (RecognitionException ex) {
0324: if (inputState.guessing == 0) {
0325:
0326: throw new RecognitionException(
0327: "Expecting Classname Identifier[[,]ClassName Identifier]* :Found: "
0328: + ex);
0329:
0330: } else {
0331: throw ex;
0332: }
0333: }
0334: returnAST = fromList_AST;
0335: }
0336:
0337: public final void predicateList() throws RecognitionException,
0338: TokenStreamException {
0339:
0340: returnAST = null;
0341: ASTPair currentAST = new ASTPair();
0342: AST predicateList_AST = null;
0343:
0344: try { // for error handling
0345: subPredicate();
0346: astFactory.addASTChild(currentAST, returnAST);
0347: {
0348: _loop36: do {
0349: if ((LA(1) == AND || LA(1) == OR)) {
0350: {
0351: switch (LA(1)) {
0352: case AND: {
0353: AST tmp10_AST = null;
0354: tmp10_AST = astFactory.create(LT(1));
0355: astFactory.addASTChild(currentAST,
0356: tmp10_AST);
0357: match(AND);
0358: break;
0359: }
0360: case OR: {
0361: AST tmp11_AST = null;
0362: tmp11_AST = astFactory.create(LT(1));
0363: astFactory.addASTChild(currentAST,
0364: tmp11_AST);
0365: match(OR);
0366: break;
0367: }
0368: default: {
0369: throw new NoViableAltException(LT(1),
0370: getFilename());
0371: }
0372: }
0373: }
0374: subPredicate();
0375: astFactory.addASTChild(currentAST, returnAST);
0376: } else {
0377: break _loop36;
0378: }
0379:
0380: } while (true);
0381: }
0382: predicateList_AST = (AST) currentAST.root;
0383: } catch (RecognitionException ex) {
0384: if (inputState.guessing == 0) {
0385: reportError(ex);
0386: recover(ex, _tokenSet_7);
0387: } else {
0388: throw ex;
0389: }
0390: }
0391: returnAST = predicateList_AST;
0392: }
0393:
0394: public final void orderList() throws RecognitionException,
0395: TokenStreamException {
0396:
0397: returnAST = null;
0398: ASTPair currentAST = new ASTPair();
0399: AST orderList_AST = null;
0400:
0401: try { // for error handling
0402: boolean synPredMatched20 = false;
0403: if (((LA(1) == Identifier)
0404: && (LA(2) == ASC || LA(2) == DESC || LA(2) == COMMA)
0405: && (LA(3) == COMMA || LA(3) == Identifier) && (_tokenSet_8
0406: .member(LA(4))))) {
0407: int _m20 = mark();
0408: synPredMatched20 = true;
0409: inputState.guessing++;
0410: try {
0411: {
0412: orderName();
0413: }
0414: } catch (RecognitionException pe) {
0415: synPredMatched20 = false;
0416: }
0417: rewind(_m20);
0418: inputState.guessing--;
0419: }
0420: if (synPredMatched20) {
0421: orderName();
0422: astFactory.addASTChild(currentAST, returnAST);
0423: {
0424: switch (LA(1)) {
0425: case ASC: {
0426: AST tmp12_AST = null;
0427: tmp12_AST = astFactory.create(LT(1));
0428: astFactory.addASTChild(currentAST, tmp12_AST);
0429: match(ASC);
0430: break;
0431: }
0432: case DESC: {
0433: AST tmp13_AST = null;
0434: tmp13_AST = astFactory.create(LT(1));
0435: astFactory.addASTChild(currentAST, tmp13_AST);
0436: match(DESC);
0437: break;
0438: }
0439: case COMMA: {
0440: break;
0441: }
0442: default: {
0443: throw new NoViableAltException(LT(1),
0444: getFilename());
0445: }
0446: }
0447: }
0448: {
0449: int _cnt24 = 0;
0450: _loop24: do {
0451: if ((LA(1) == COMMA)) {
0452: match(COMMA);
0453: orderName();
0454: astFactory.addASTChild(currentAST,
0455: returnAST);
0456: {
0457: switch (LA(1)) {
0458: case ASC: {
0459: AST tmp15_AST = null;
0460: tmp15_AST = astFactory
0461: .create(LT(1));
0462: astFactory.addASTChild(currentAST,
0463: tmp15_AST);
0464: match(ASC);
0465: break;
0466: }
0467: case DESC: {
0468: AST tmp16_AST = null;
0469: tmp16_AST = astFactory
0470: .create(LT(1));
0471: astFactory.addASTChild(currentAST,
0472: tmp16_AST);
0473: match(DESC);
0474: break;
0475: }
0476: case NAMESPACE:
0477: case COMMA:
0478: case SEMICOLON: {
0479: break;
0480: }
0481: default: {
0482: throw new NoViableAltException(
0483: LT(1), getFilename());
0484: }
0485: }
0486: }
0487: } else {
0488: if (_cnt24 >= 1) {
0489: break _loop24;
0490: } else {
0491: throw new NoViableAltException(LT(1),
0492: getFilename());
0493: }
0494: }
0495:
0496: _cnt24++;
0497: } while (true);
0498: }
0499: orderList_AST = (AST) currentAST.root;
0500: } else if ((LA(1) == Identifier)
0501: && (_tokenSet_9.member(LA(2)))
0502: && (_tokenSet_10.member(LA(3)))
0503: && (_tokenSet_10.member(LA(4)))) {
0504: orderName();
0505: astFactory.addASTChild(currentAST, returnAST);
0506: {
0507: switch (LA(1)) {
0508: case ASC: {
0509: AST tmp17_AST = null;
0510: tmp17_AST = astFactory.create(LT(1));
0511: astFactory.addASTChild(currentAST, tmp17_AST);
0512: match(ASC);
0513: break;
0514: }
0515: case DESC: {
0516: AST tmp18_AST = null;
0517: tmp18_AST = astFactory.create(LT(1));
0518: astFactory.addASTChild(currentAST, tmp18_AST);
0519: match(DESC);
0520: break;
0521: }
0522: case NAMESPACE:
0523: case SEMICOLON: {
0524: break;
0525: }
0526: default: {
0527: throw new NoViableAltException(LT(1),
0528: getFilename());
0529: }
0530: }
0531: }
0532: orderList_AST = (AST) currentAST.root;
0533: } else {
0534: throw new NoViableAltException(LT(1), getFilename());
0535: }
0536:
0537: } catch (RecognitionException ex) {
0538: if (inputState.guessing == 0) {
0539: reportError(ex);
0540: recover(ex, _tokenSet_11);
0541: } else {
0542: throw ex;
0543: }
0544: }
0545: returnAST = orderList_AST;
0546: }
0547:
0548: public final void nameSpace() throws RecognitionException,
0549: TokenStreamException {
0550:
0551: returnAST = null;
0552: ASTPair currentAST = new ASTPair();
0553: AST nameSpace_AST = null;
0554:
0555: try { // for error handling
0556: {
0557: int _cnt56 = 0;
0558: _loop56: do {
0559: switch (LA(1)) {
0560: case FORWARDSLASH: {
0561: {
0562: AST tmp19_AST = null;
0563: tmp19_AST = astFactory.create(LT(1));
0564: astFactory.addASTChild(currentAST,
0565: tmp19_AST);
0566: match(FORWARDSLASH);
0567: }
0568: break;
0569: }
0570: case SELECT:
0571: case WHERE:
0572: case ALIAS_IDENTIFIER:
0573: case AND:
0574: case OR:
0575: case NOT:
0576: case VALUE:
0577: case FROM:
0578: case IS:
0579: case LIKE:
0580: case IN:
0581: case NAMESPACE:
0582: case ORDER:
0583: case BY:
0584: case Identifier:
0585: case PredicateIdentifier:
0586: case ASCENDING:
0587: case DESCENDING: {
0588: predicateValue();
0589: astFactory.addASTChild(currentAST, returnAST);
0590: break;
0591: }
0592: case DASH: {
0593: {
0594: AST tmp20_AST = null;
0595: tmp20_AST = astFactory.create(LT(1));
0596: astFactory.addASTChild(currentAST,
0597: tmp20_AST);
0598: match(DASH);
0599: }
0600: break;
0601: }
0602: case PLUS: {
0603: {
0604: AST tmp21_AST = null;
0605: tmp21_AST = astFactory.create(LT(1));
0606: astFactory.addASTChild(currentAST,
0607: tmp21_AST);
0608: match(PLUS);
0609: }
0610: break;
0611: }
0612: default: {
0613: if (_cnt56 >= 1) {
0614: break _loop56;
0615: } else {
0616: throw new NoViableAltException(LT(1),
0617: getFilename());
0618: }
0619: }
0620: }
0621: _cnt56++;
0622: } while (true);
0623: }
0624: nameSpace_AST = (AST) currentAST.root;
0625: } catch (RecognitionException ex) {
0626: if (inputState.guessing == 0) {
0627: reportError(ex);
0628: recover(ex, _tokenSet_1);
0629: } else {
0630: throw ex;
0631: }
0632: }
0633: returnAST = nameSpace_AST;
0634: }
0635:
0636: public final void className() throws RecognitionException,
0637: TokenStreamException {
0638:
0639: returnAST = null;
0640: ASTPair currentAST = new ASTPair();
0641: AST className_AST = null;
0642:
0643: try { // for error handling
0644: AST tmp22_AST = null;
0645: tmp22_AST = astFactory.create(LT(1));
0646: astFactory.addASTChild(currentAST, tmp22_AST);
0647: match(Identifier);
0648: className_AST = (AST) currentAST.root;
0649: } catch (RecognitionException ex) {
0650: if (inputState.guessing == 0) {
0651: reportError(ex);
0652: recover(ex, _tokenSet_12);
0653: } else {
0654: throw ex;
0655: }
0656: }
0657: returnAST = className_AST;
0658: }
0659:
0660: public final void fullClassName() throws RecognitionException,
0661: TokenStreamException {
0662:
0663: returnAST = null;
0664: ASTPair currentAST = new ASTPair();
0665: AST fullClassName_AST = null;
0666:
0667: try { // for error handling
0668: className();
0669: astFactory.addASTChild(currentAST, returnAST);
0670: {
0671: switch (LA(1)) {
0672: case ALIAS_IDENTIFIER: {
0673: AST tmp23_AST = null;
0674: tmp23_AST = astFactory.create(LT(1));
0675: astFactory.makeASTRoot(currentAST, tmp23_AST);
0676: match(ALIAS_IDENTIFIER);
0677: break;
0678: }
0679: case Identifier: {
0680: break;
0681: }
0682: default: {
0683: throw new NoViableAltException(LT(1), getFilename());
0684: }
0685: }
0686: }
0687: aliasName();
0688: astFactory.addASTChild(currentAST, returnAST);
0689: fullClassName_AST = (AST) currentAST.root;
0690: } catch (RecognitionException ex) {
0691: if (inputState.guessing == 0) {
0692: reportError(ex);
0693: recover(ex, _tokenSet_13);
0694: } else {
0695: throw ex;
0696: }
0697: }
0698: returnAST = fullClassName_AST;
0699: }
0700:
0701: public final void collectionIdentifierName()
0702: throws RecognitionException, TokenStreamException {
0703:
0704: returnAST = null;
0705: ASTPair currentAST = new ASTPair();
0706: AST collectionIdentifierName_AST = null;
0707:
0708: try { // for error handling
0709: AST tmp24_AST = null;
0710: tmp24_AST = astFactory.create(LT(1));
0711: astFactory.addASTChild(currentAST, tmp24_AST);
0712: match(IN);
0713: AST tmp25_AST = null;
0714: tmp25_AST = astFactory.create(LT(1));
0715: astFactory.addASTChild(currentAST, tmp25_AST);
0716: match(LPAREN);
0717: className();
0718: astFactory.addASTChild(currentAST, returnAST);
0719: AST tmp26_AST = null;
0720: tmp26_AST = astFactory.create(LT(1));
0721: astFactory.addASTChild(currentAST, tmp26_AST);
0722: match(RPAREN);
0723: {
0724: switch (LA(1)) {
0725: case ALIAS_IDENTIFIER: {
0726: AST tmp27_AST = null;
0727: tmp27_AST = astFactory.create(LT(1));
0728: astFactory.makeASTRoot(currentAST, tmp27_AST);
0729: match(ALIAS_IDENTIFIER);
0730: break;
0731: }
0732: case Identifier: {
0733: break;
0734: }
0735: default: {
0736: throw new NoViableAltException(LT(1), getFilename());
0737: }
0738: }
0739: }
0740: aliasName();
0741: astFactory.addASTChild(currentAST, returnAST);
0742: collectionIdentifierName_AST = (AST) currentAST.root;
0743: } catch (RecognitionException ex) {
0744: if (inputState.guessing == 0) {
0745: reportError(ex);
0746: recover(ex, _tokenSet_13);
0747: } else {
0748: throw ex;
0749: }
0750: }
0751: returnAST = collectionIdentifierName_AST;
0752: }
0753:
0754: public final void orderName() throws RecognitionException,
0755: TokenStreamException {
0756:
0757: returnAST = null;
0758: ASTPair currentAST = new ASTPair();
0759: AST orderName_AST = null;
0760:
0761: try { // for error handling
0762: AST tmp28_AST = null;
0763: tmp28_AST = astFactory.create(LT(1));
0764: astFactory.addASTChild(currentAST, tmp28_AST);
0765: match(Identifier);
0766: orderName_AST = (AST) currentAST.root;
0767: } catch (RecognitionException ex) {
0768: if (inputState.guessing == 0) {
0769: reportError(ex);
0770: recover(ex, _tokenSet_14);
0771: } else {
0772: throw ex;
0773: }
0774: }
0775: returnAST = orderName_AST;
0776: }
0777:
0778: public final void aliasName() throws RecognitionException,
0779: TokenStreamException {
0780:
0781: returnAST = null;
0782: ASTPair currentAST = new ASTPair();
0783: AST aliasName_AST = null;
0784:
0785: try { // for error handling
0786: AST tmp29_AST = null;
0787: tmp29_AST = astFactory.create(LT(1));
0788: astFactory.addASTChild(currentAST, tmp29_AST);
0789: match(Identifier);
0790: aliasName_AST = (AST) currentAST.root;
0791: } catch (RecognitionException ex) {
0792: if (inputState.guessing == 0) {
0793: reportError(ex);
0794: recover(ex, _tokenSet_13);
0795: } else {
0796: throw ex;
0797: }
0798: }
0799: returnAST = aliasName_AST;
0800: }
0801:
0802: public final void subPredicate() throws RecognitionException,
0803: TokenStreamException {
0804:
0805: returnAST = null;
0806: ASTPair currentAST = new ASTPair();
0807: AST subPredicate_AST = null;
0808:
0809: try { // for error handling
0810: switch (LA(1)) {
0811: case LPAREN: {
0812: AST tmp30_AST = null;
0813: tmp30_AST = astFactory.create(LT(1));
0814: astFactory.addASTChild(currentAST, tmp30_AST);
0815: match(LPAREN);
0816: predicateList();
0817: astFactory.addASTChild(currentAST, returnAST);
0818: AST tmp31_AST = null;
0819: tmp31_AST = astFactory.create(LT(1));
0820: astFactory.addASTChild(currentAST, tmp31_AST);
0821: match(RPAREN);
0822: subPredicate_AST = (AST) currentAST.root;
0823: break;
0824: }
0825: case VALUE:
0826: case Identifier: {
0827: predicate();
0828: astFactory.addASTChild(currentAST, returnAST);
0829: subPredicate_AST = (AST) currentAST.root;
0830: break;
0831: }
0832: default: {
0833: throw new NoViableAltException(LT(1), getFilename());
0834: }
0835: }
0836: } catch (RecognitionException ex) {
0837: if (inputState.guessing == 0) {
0838: reportError(ex);
0839: recover(ex, _tokenSet_15);
0840: } else {
0841: throw ex;
0842: }
0843: }
0844: returnAST = subPredicate_AST;
0845: }
0846:
0847: public final void predicate() throws RecognitionException,
0848: TokenStreamException {
0849:
0850: returnAST = null;
0851: ASTPair currentAST = new ASTPair();
0852: AST predicate_AST = null;
0853:
0854: try { // for error handling
0855: predicateName();
0856: astFactory.addASTChild(currentAST, returnAST);
0857: {
0858: switch (LA(1)) {
0859: case ASSIGNEQUAL: {
0860: AST tmp32_AST = null;
0861: tmp32_AST = astFactory.create(LT(1));
0862: astFactory.makeASTRoot(currentAST, tmp32_AST);
0863: match(ASSIGNEQUAL);
0864: break;
0865: }
0866: case NOTEQUAL2: {
0867: AST tmp33_AST = null;
0868: tmp33_AST = astFactory.create(LT(1));
0869: astFactory.makeASTRoot(currentAST, tmp33_AST);
0870: match(NOTEQUAL2);
0871: break;
0872: }
0873: case NOTEQUAL1: {
0874: AST tmp34_AST = null;
0875: tmp34_AST = astFactory.create(LT(1));
0876: astFactory.makeASTRoot(currentAST, tmp34_AST);
0877: match(NOTEQUAL1);
0878: break;
0879: }
0880: case LESSTHANOREQUALTO1: {
0881: AST tmp35_AST = null;
0882: tmp35_AST = astFactory.create(LT(1));
0883: astFactory.makeASTRoot(currentAST, tmp35_AST);
0884: match(LESSTHANOREQUALTO1);
0885: break;
0886: }
0887: case LESSTHANOREQUALTO2: {
0888: AST tmp36_AST = null;
0889: tmp36_AST = astFactory.create(LT(1));
0890: astFactory.makeASTRoot(currentAST, tmp36_AST);
0891: match(LESSTHANOREQUALTO2);
0892: break;
0893: }
0894: case LESSTHAN: {
0895: AST tmp37_AST = null;
0896: tmp37_AST = astFactory.create(LT(1));
0897: astFactory.makeASTRoot(currentAST, tmp37_AST);
0898: match(LESSTHAN);
0899: break;
0900: }
0901: case GREATERTHANOREQUALTO1: {
0902: AST tmp38_AST = null;
0903: tmp38_AST = astFactory.create(LT(1));
0904: astFactory.makeASTRoot(currentAST, tmp38_AST);
0905: match(GREATERTHANOREQUALTO1);
0906: break;
0907: }
0908: case GREATERTHANOREQUALTO2: {
0909: AST tmp39_AST = null;
0910: tmp39_AST = astFactory.create(LT(1));
0911: astFactory.makeASTRoot(currentAST, tmp39_AST);
0912: match(GREATERTHANOREQUALTO2);
0913: break;
0914: }
0915: case GREATERTHAN: {
0916: AST tmp40_AST = null;
0917: tmp40_AST = astFactory.create(LT(1));
0918: astFactory.makeASTRoot(currentAST, tmp40_AST);
0919: match(GREATERTHAN);
0920: break;
0921: }
0922: case IS: {
0923: AST tmp41_AST = null;
0924: tmp41_AST = astFactory.create(LT(1));
0925: astFactory.makeASTRoot(currentAST, tmp41_AST);
0926: match(IS);
0927: break;
0928: }
0929: case NOT: {
0930: AST tmp42_AST = null;
0931: tmp42_AST = astFactory.create(LT(1));
0932: astFactory.makeASTRoot(currentAST, tmp42_AST);
0933: match(NOT);
0934: break;
0935: }
0936: case LIKE: {
0937: AST tmp43_AST = null;
0938: tmp43_AST = astFactory.create(LT(1));
0939: astFactory.makeASTRoot(currentAST, tmp43_AST);
0940: match(LIKE);
0941: break;
0942: }
0943: case IN: {
0944: AST tmp44_AST = null;
0945: tmp44_AST = astFactory.create(LT(1));
0946: astFactory.makeASTRoot(currentAST, tmp44_AST);
0947: match(IN);
0948: break;
0949: }
0950: default: {
0951: throw new NoViableAltException(LT(1), getFilename());
0952: }
0953: }
0954: }
0955: predicateParenValue();
0956: astFactory.addASTChild(currentAST, returnAST);
0957: predicate_AST = (AST) currentAST.root;
0958: } catch (RecognitionException ex) {
0959: if (inputState.guessing == 0) {
0960: reportError(ex);
0961: recover(ex, _tokenSet_15);
0962: } else {
0963: throw ex;
0964: }
0965: }
0966: returnAST = predicate_AST;
0967: }
0968:
0969: public final void predicateName() throws RecognitionException,
0970: TokenStreamException {
0971:
0972: returnAST = null;
0973: ASTPair currentAST = new ASTPair();
0974: AST predicateName_AST = null;
0975:
0976: try { // for error handling
0977: switch (LA(1)) {
0978: case Identifier: {
0979: AST tmp45_AST = null;
0980: tmp45_AST = astFactory.create(LT(1));
0981: astFactory.addASTChild(currentAST, tmp45_AST);
0982: match(Identifier);
0983: predicateName_AST = (AST) currentAST.root;
0984: break;
0985: }
0986: case VALUE: {
0987: AST tmp46_AST = null;
0988: tmp46_AST = astFactory.create(LT(1));
0989: astFactory.addASTChild(currentAST, tmp46_AST);
0990: match(VALUE);
0991: predicateName_AST = (AST) currentAST.root;
0992: break;
0993: }
0994: default: {
0995: throw new NoViableAltException(LT(1), getFilename());
0996: }
0997: }
0998: } catch (RecognitionException ex) {
0999: if (inputState.guessing == 0) {
1000: reportError(ex);
1001: recover(ex, _tokenSet_16);
1002: } else {
1003: throw ex;
1004: }
1005: }
1006: returnAST = predicateName_AST;
1007: }
1008:
1009: public final void predicateParenValue()
1010: throws RecognitionException, TokenStreamException {
1011:
1012: returnAST = null;
1013: ASTPair currentAST = new ASTPair();
1014: AST predicateParenValue_AST = null;
1015:
1016: try { // for error handling
1017: switch (LA(1)) {
1018: case LPAREN: {
1019: AST tmp47_AST = null;
1020: tmp47_AST = astFactory.create(LT(1));
1021: astFactory.addASTChild(currentAST, tmp47_AST);
1022: match(LPAREN);
1023: {
1024: _loop46: do {
1025: switch (LA(1)) {
1026: case SELECT:
1027: case WHERE:
1028: case ALIAS_IDENTIFIER:
1029: case AND:
1030: case OR:
1031: case NOT:
1032: case VALUE:
1033: case FROM:
1034: case IS:
1035: case LIKE:
1036: case IN:
1037: case NAMESPACE:
1038: case ORDER:
1039: case BY:
1040: case Identifier:
1041: case PredicateIdentifier:
1042: case ASCENDING:
1043: case DESCENDING: {
1044: predicateValue();
1045: astFactory.addASTChild(currentAST,
1046: returnAST);
1047: break;
1048: }
1049: case COMMA: {
1050: AST tmp48_AST = null;
1051: tmp48_AST = astFactory.create(LT(1));
1052: astFactory.addASTChild(currentAST,
1053: tmp48_AST);
1054: match(COMMA);
1055: break;
1056: }
1057: default: {
1058: break _loop46;
1059: }
1060: }
1061: } while (true);
1062: }
1063: AST tmp49_AST = null;
1064: tmp49_AST = astFactory.create(LT(1));
1065: astFactory.addASTChild(currentAST, tmp49_AST);
1066: match(RPAREN);
1067: predicateParenValue_AST = (AST) currentAST.root;
1068: break;
1069: }
1070: case SELECT:
1071: case WHERE:
1072: case ALIAS_IDENTIFIER:
1073: case AND:
1074: case OR:
1075: case NOT:
1076: case VALUE:
1077: case FROM:
1078: case IS:
1079: case LIKE:
1080: case IN:
1081: case NAMESPACE:
1082: case ORDER:
1083: case BY:
1084: case Identifier:
1085: case PredicateIdentifier:
1086: case ASCENDING:
1087: case DESCENDING: {
1088: predicateValue();
1089: astFactory.addASTChild(currentAST, returnAST);
1090: predicateParenValue_AST = (AST) currentAST.root;
1091: break;
1092: }
1093: default: {
1094: throw new NoViableAltException(LT(1), getFilename());
1095: }
1096: }
1097: } catch (RecognitionException ex) {
1098: if (inputState.guessing == 0) {
1099: reportError(ex);
1100: recover(ex, _tokenSet_15);
1101: } else {
1102: throw ex;
1103: }
1104: }
1105: returnAST = predicateParenValue_AST;
1106: }
1107:
1108: public final void predicateValue() throws RecognitionException,
1109: TokenStreamException {
1110:
1111: returnAST = null;
1112: ASTPair currentAST = new ASTPair();
1113: AST predicateValue_AST = null;
1114:
1115: try { // for error handling
1116: switch (LA(1)) {
1117: case PredicateIdentifier: {
1118: AST tmp50_AST = null;
1119: tmp50_AST = astFactory.create(LT(1));
1120: astFactory.addASTChild(currentAST, tmp50_AST);
1121: match(PredicateIdentifier);
1122: predicateValue_AST = (AST) currentAST.root;
1123: break;
1124: }
1125: case Identifier: {
1126: AST tmp51_AST = null;
1127: tmp51_AST = astFactory.create(LT(1));
1128: astFactory.addASTChild(currentAST, tmp51_AST);
1129: match(Identifier);
1130: predicateValue_AST = (AST) currentAST.root;
1131: break;
1132: }
1133: case SELECT: {
1134: AST tmp52_AST = null;
1135: tmp52_AST = astFactory.create(LT(1));
1136: astFactory.addASTChild(currentAST, tmp52_AST);
1137: match(SELECT);
1138: predicateValue_AST = (AST) currentAST.root;
1139: break;
1140: }
1141: case FROM: {
1142: AST tmp53_AST = null;
1143: tmp53_AST = astFactory.create(LT(1));
1144: astFactory.addASTChild(currentAST, tmp53_AST);
1145: match(FROM);
1146: predicateValue_AST = (AST) currentAST.root;
1147: break;
1148: }
1149: case WHERE: {
1150: AST tmp54_AST = null;
1151: tmp54_AST = astFactory.create(LT(1));
1152: astFactory.addASTChild(currentAST, tmp54_AST);
1153: match(WHERE);
1154: predicateValue_AST = (AST) currentAST.root;
1155: break;
1156: }
1157: case ALIAS_IDENTIFIER: {
1158: AST tmp55_AST = null;
1159: tmp55_AST = astFactory.create(LT(1));
1160: astFactory.addASTChild(currentAST, tmp55_AST);
1161: match(ALIAS_IDENTIFIER);
1162: predicateValue_AST = (AST) currentAST.root;
1163: break;
1164: }
1165: case AND: {
1166: AST tmp56_AST = null;
1167: tmp56_AST = astFactory.create(LT(1));
1168: astFactory.addASTChild(currentAST, tmp56_AST);
1169: match(AND);
1170: predicateValue_AST = (AST) currentAST.root;
1171: break;
1172: }
1173: case OR: {
1174: AST tmp57_AST = null;
1175: tmp57_AST = astFactory.create(LT(1));
1176: astFactory.addASTChild(currentAST, tmp57_AST);
1177: match(OR);
1178: predicateValue_AST = (AST) currentAST.root;
1179: break;
1180: }
1181: case NOT: {
1182: AST tmp58_AST = null;
1183: tmp58_AST = astFactory.create(LT(1));
1184: astFactory.addASTChild(currentAST, tmp58_AST);
1185: match(NOT);
1186: predicateValue_AST = (AST) currentAST.root;
1187: break;
1188: }
1189: case VALUE: {
1190: AST tmp59_AST = null;
1191: tmp59_AST = astFactory.create(LT(1));
1192: astFactory.addASTChild(currentAST, tmp59_AST);
1193: match(VALUE);
1194: predicateValue_AST = (AST) currentAST.root;
1195: break;
1196: }
1197: case IS: {
1198: AST tmp60_AST = null;
1199: tmp60_AST = astFactory.create(LT(1));
1200: astFactory.addASTChild(currentAST, tmp60_AST);
1201: match(IS);
1202: predicateValue_AST = (AST) currentAST.root;
1203: break;
1204: }
1205: case LIKE: {
1206: AST tmp61_AST = null;
1207: tmp61_AST = astFactory.create(LT(1));
1208: astFactory.addASTChild(currentAST, tmp61_AST);
1209: match(LIKE);
1210: predicateValue_AST = (AST) currentAST.root;
1211: break;
1212: }
1213: case IN: {
1214: AST tmp62_AST = null;
1215: tmp62_AST = astFactory.create(LT(1));
1216: astFactory.addASTChild(currentAST, tmp62_AST);
1217: match(IN);
1218: predicateValue_AST = (AST) currentAST.root;
1219: break;
1220: }
1221: case NAMESPACE: {
1222: AST tmp63_AST = null;
1223: tmp63_AST = astFactory.create(LT(1));
1224: astFactory.addASTChild(currentAST, tmp63_AST);
1225: match(NAMESPACE);
1226: predicateValue_AST = (AST) currentAST.root;
1227: break;
1228: }
1229: case ORDER: {
1230: AST tmp64_AST = null;
1231: tmp64_AST = astFactory.create(LT(1));
1232: astFactory.addASTChild(currentAST, tmp64_AST);
1233: match(ORDER);
1234: predicateValue_AST = (AST) currentAST.root;
1235: break;
1236: }
1237: case BY: {
1238: AST tmp65_AST = null;
1239: tmp65_AST = astFactory.create(LT(1));
1240: astFactory.addASTChild(currentAST, tmp65_AST);
1241: match(BY);
1242: predicateValue_AST = (AST) currentAST.root;
1243: break;
1244: }
1245: case ASCENDING: {
1246: AST tmp66_AST = null;
1247: tmp66_AST = astFactory.create(LT(1));
1248: astFactory.addASTChild(currentAST, tmp66_AST);
1249: match(ASCENDING);
1250: predicateValue_AST = (AST) currentAST.root;
1251: break;
1252: }
1253: case DESCENDING: {
1254: AST tmp67_AST = null;
1255: tmp67_AST = astFactory.create(LT(1));
1256: astFactory.addASTChild(currentAST, tmp67_AST);
1257: match(DESCENDING);
1258: predicateValue_AST = (AST) currentAST.root;
1259: break;
1260: }
1261: default: {
1262: throw new NoViableAltException(LT(1), getFilename());
1263: }
1264: }
1265: } catch (RecognitionException ex) {
1266: if (inputState.guessing == 0) {
1267: reportError(ex);
1268: recover(ex, _tokenSet_17);
1269: } else {
1270: throw ex;
1271: }
1272: }
1273: returnAST = predicateValue_AST;
1274: }
1275:
1276: public final void comparisonOperator() throws RecognitionException,
1277: TokenStreamException {
1278:
1279: returnAST = null;
1280: ASTPair currentAST = new ASTPair();
1281: AST comparisonOperator_AST = null;
1282:
1283: try { // for error handling
1284: switch (LA(1)) {
1285: case ASSIGNEQUAL: {
1286: AST tmp68_AST = null;
1287: tmp68_AST = astFactory.create(LT(1));
1288: astFactory.addASTChild(currentAST, tmp68_AST);
1289: match(ASSIGNEQUAL);
1290: comparisonOperator_AST = (AST) currentAST.root;
1291: break;
1292: }
1293: case NOTEQUAL1: {
1294: AST tmp69_AST = null;
1295: tmp69_AST = astFactory.create(LT(1));
1296: astFactory.addASTChild(currentAST, tmp69_AST);
1297: match(NOTEQUAL1);
1298: comparisonOperator_AST = (AST) currentAST.root;
1299: break;
1300: }
1301: case NOTEQUAL2: {
1302: AST tmp70_AST = null;
1303: tmp70_AST = astFactory.create(LT(1));
1304: astFactory.addASTChild(currentAST, tmp70_AST);
1305: match(NOTEQUAL2);
1306: comparisonOperator_AST = (AST) currentAST.root;
1307: break;
1308: }
1309: case LESSTHANOREQUALTO1: {
1310: AST tmp71_AST = null;
1311: tmp71_AST = astFactory.create(LT(1));
1312: astFactory.addASTChild(currentAST, tmp71_AST);
1313: match(LESSTHANOREQUALTO1);
1314: comparisonOperator_AST = (AST) currentAST.root;
1315: break;
1316: }
1317: case LESSTHANOREQUALTO2: {
1318: AST tmp72_AST = null;
1319: tmp72_AST = astFactory.create(LT(1));
1320: astFactory.addASTChild(currentAST, tmp72_AST);
1321: match(LESSTHANOREQUALTO2);
1322: comparisonOperator_AST = (AST) currentAST.root;
1323: break;
1324: }
1325: case LESSTHAN: {
1326: AST tmp73_AST = null;
1327: tmp73_AST = astFactory.create(LT(1));
1328: astFactory.addASTChild(currentAST, tmp73_AST);
1329: match(LESSTHAN);
1330: comparisonOperator_AST = (AST) currentAST.root;
1331: break;
1332: }
1333: case GREATERTHANOREQUALTO1: {
1334: AST tmp74_AST = null;
1335: tmp74_AST = astFactory.create(LT(1));
1336: astFactory.addASTChild(currentAST, tmp74_AST);
1337: match(GREATERTHANOREQUALTO1);
1338: comparisonOperator_AST = (AST) currentAST.root;
1339: break;
1340: }
1341: case GREATERTHANOREQUALTO2: {
1342: AST tmp75_AST = null;
1343: tmp75_AST = astFactory.create(LT(1));
1344: astFactory.addASTChild(currentAST, tmp75_AST);
1345: match(GREATERTHANOREQUALTO2);
1346: comparisonOperator_AST = (AST) currentAST.root;
1347: break;
1348: }
1349: case GREATERTHAN: {
1350: AST tmp76_AST = null;
1351: tmp76_AST = astFactory.create(LT(1));
1352: astFactory.addASTChild(currentAST, tmp76_AST);
1353: match(GREATERTHAN);
1354: comparisonOperator_AST = (AST) currentAST.root;
1355: break;
1356: }
1357: default: {
1358: throw new NoViableAltException(LT(1), getFilename());
1359: }
1360: }
1361: } catch (RecognitionException ex) {
1362: if (inputState.guessing == 0) {
1363: reportError(ex);
1364: recover(ex, _tokenSet_0);
1365: } else {
1366: throw ex;
1367: }
1368: }
1369: returnAST = comparisonOperator_AST;
1370: }
1371:
1372: public final void logicalOperator() throws RecognitionException,
1373: TokenStreamException {
1374:
1375: returnAST = null;
1376: ASTPair currentAST = new ASTPair();
1377: AST logicalOperator_AST = null;
1378:
1379: try { // for error handling
1380: switch (LA(1)) {
1381: case AND: {
1382: AST tmp77_AST = null;
1383: tmp77_AST = astFactory.create(LT(1));
1384: astFactory.addASTChild(currentAST, tmp77_AST);
1385: match(AND);
1386: logicalOperator_AST = (AST) currentAST.root;
1387: break;
1388: }
1389: case OR: {
1390: AST tmp78_AST = null;
1391: tmp78_AST = astFactory.create(LT(1));
1392: astFactory.addASTChild(currentAST, tmp78_AST);
1393: match(OR);
1394: logicalOperator_AST = (AST) currentAST.root;
1395: break;
1396: }
1397: default: {
1398: throw new NoViableAltException(LT(1), getFilename());
1399: }
1400: }
1401: } catch (RecognitionException ex) {
1402: if (inputState.guessing == 0) {
1403: reportError(ex);
1404: recover(ex, _tokenSet_0);
1405: } else {
1406: throw ex;
1407: }
1408: }
1409: returnAST = logicalOperator_AST;
1410: }
1411:
1412: public static final String[] _tokenNames = { "<0>", "EOF", "<2>",
1413: "NULL_TREE_LOOKAHEAD", "\"select\"", "\"where\"", "\"as\"",
1414: "\"and\"", "\"or\"", "\"not\"", "\"value\"", "\"from\"",
1415: "\"is\"", "\"like\"", "\"in\"", "\"namespace\"",
1416: "\"order\"", "\"by\"", "\"asc\"", "\"desc\"",
1417: "PACKAGE_SEPERATOR", "COMMA", "SEMICOLON", "LPAREN",
1418: "RPAREN", "SINGLE_QUOTE", "BACKSLASH", "FORWARDSLASH",
1419: "DASH", "PLUS", "ASSIGNEQUAL", "NOTEQUAL1", "NOTEQUAL2",
1420: "LESSTHANOREQUALTO1", "LESSTHANOREQUALTO2", "LESSTHAN",
1421: "GREATERTHANOREQUALTO1", "GREATERTHANOREQUALTO2",
1422: "GREATERTHAN", "LBRACKET", "RBRACKET", "Letter", "Digit",
1423: "SPACE", "Identifier", "ESC", "NONESC",
1424: "PredicateIdentifier", "WS", "ASCENDING", "DESCENDING" };
1425:
1426: protected void buildTokenTypeASTClassMap() {
1427: tokenTypeToASTClassMap = null;
1428: };
1429:
1430: private static final long[] mk_tokenSet_0() {
1431: long[] data = { 2L, 0L };
1432: return data;
1433: }
1434:
1435: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1436:
1437: private static final long[] mk_tokenSet_1() {
1438: long[] data = { 4194304L, 0L };
1439: return data;
1440: }
1441:
1442: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1443:
1444: private static final long[] mk_tokenSet_2() {
1445: long[] data = { 2048L, 0L };
1446: return data;
1447: }
1448:
1449: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1450:
1451: private static final long[] mk_tokenSet_3() {
1452: long[] data = { 17592192434208L, 0L };
1453: return data;
1454: }
1455:
1456: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1457:
1458: private static final long[] mk_tokenSet_4() {
1459: long[] data = { 1847180489129970L, 0L };
1460: return data;
1461: }
1462:
1463: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1464:
1465: private static final long[] mk_tokenSet_5() {
1466: long[] data = { 17592190337056L, 0L };
1467: return data;
1468: }
1469:
1470: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
1471:
1472: private static final long[] mk_tokenSet_6() {
1473: long[] data = { 1847180487032818L, 0L };
1474: return data;
1475: }
1476:
1477: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
1478:
1479: private static final long[] mk_tokenSet_7() {
1480: long[] data = { 21069824L, 0L };
1481: return data;
1482: }
1483:
1484: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
1485:
1486: private static final long[] mk_tokenSet_8() {
1487: long[] data = { 17592193155072L, 0L };
1488: return data;
1489: }
1490:
1491: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
1492:
1493: private static final long[] mk_tokenSet_9() {
1494: long[] data = { 5013504L, 0L };
1495: return data;
1496: }
1497:
1498: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
1499:
1500: private static final long[] mk_tokenSet_10() {
1501: long[] data = { 1847180478644210L, 0L };
1502: return data;
1503: }
1504:
1505: public static final BitSet _tokenSet_10 = new BitSet(
1506: mk_tokenSet_10());
1507:
1508: private static final long[] mk_tokenSet_11() {
1509: long[] data = { 4227072L, 0L };
1510: return data;
1511: }
1512:
1513: public static final BitSet _tokenSet_11 = new BitSet(
1514: mk_tokenSet_11());
1515:
1516: private static final long[] mk_tokenSet_12() {
1517: long[] data = { 17592204920896L, 0L };
1518: return data;
1519: }
1520:
1521: public static final BitSet _tokenSet_12 = new BitSet(
1522: mk_tokenSet_12());
1523:
1524: private static final long[] mk_tokenSet_13() {
1525: long[] data = { 6389792L, 0L };
1526: return data;
1527: }
1528:
1529: public static final BitSet _tokenSet_13 = new BitSet(
1530: mk_tokenSet_13());
1531:
1532: private static final long[] mk_tokenSet_14() {
1533: long[] data = { 7110656L, 0L };
1534: return data;
1535: }
1536:
1537: public static final BitSet _tokenSet_14 = new BitSet(
1538: mk_tokenSet_14());
1539:
1540: private static final long[] mk_tokenSet_15() {
1541: long[] data = { 21070208L, 0L };
1542: return data;
1543: }
1544:
1545: public static final BitSet _tokenSet_15 = new BitSet(
1546: mk_tokenSet_15());
1547:
1548: private static final long[] mk_tokenSet_16() {
1549: long[] data = { 548682101248L, 0L };
1550: return data;
1551: }
1552:
1553: public static final BitSet _tokenSet_16 = new BitSet(
1554: mk_tokenSet_16());
1555:
1556: private static final long[] mk_tokenSet_17() {
1557: long[] data = { 1847180497518576L, 0L };
1558: return data;
1559: }
1560:
1561: public static final BitSet _tokenSet_17 = new BitSet(
1562: mk_tokenSet_17());
1563:
1564: }
|