0001: // $ANTLR 2.7.5 (20050128): "jdoql-ojb-parser.g" -> "JDOQLParser.java"$
0002:
0003: package org.apache.ojb.jdo.jdoql;
0004:
0005: /* Copyright 2003-2005 The Apache Software Foundation
0006: *
0007: * Licensed under the Apache License, Version 2.0 (the "License");
0008: * you may not use this file except in compliance with the License.
0009: * You may obtain a copy of the License at
0010: *
0011: * http://www.apache.org/licenses/LICENSE-2.0
0012: *
0013: * Unless required by applicable law or agreed to in writing, software
0014: * distributed under the License is distributed on an "AS IS" BASIS,
0015: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0016: * See the License for the specific language governing permissions and
0017: * limitations under the License.
0018: */
0019:
0020: import antlr.ASTFactory;
0021: import antlr.ASTPair;
0022: import antlr.NoViableAltException;
0023: import antlr.ParserSharedInputState;
0024: import antlr.RecognitionException;
0025: import antlr.Token;
0026: import antlr.TokenBuffer;
0027: import antlr.TokenStream;
0028: import antlr.TokenStreamException;
0029: import antlr.collections.AST;
0030: import antlr.collections.impl.ASTArray;
0031: import antlr.collections.impl.BitSet;
0032:
0033: public class JDOQLParser extends antlr.LLkParser implements
0034: JDOQLParserTokenTypes {
0035:
0036: protected JDOQLParser(TokenBuffer tokenBuf, int k) {
0037: super (tokenBuf, k);
0038: tokenNames = _tokenNames;
0039: buildTokenTypeASTClassMap();
0040: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0041: }
0042:
0043: public JDOQLParser(TokenBuffer tokenBuf) {
0044: this (tokenBuf, 2);
0045: }
0046:
0047: protected JDOQLParser(TokenStream lexer, int k) {
0048: super (lexer, k);
0049: tokenNames = _tokenNames;
0050: buildTokenTypeASTClassMap();
0051: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0052: }
0053:
0054: public JDOQLParser(TokenStream lexer) {
0055: this (lexer, 2);
0056: }
0057:
0058: public JDOQLParser(ParserSharedInputState state) {
0059: super (state, 2);
0060: tokenNames = _tokenNames;
0061: buildTokenTypeASTClassMap();
0062: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0063: }
0064:
0065: public final void declareParameters() throws RecognitionException,
0066: TokenStreamException {
0067:
0068: returnAST = null;
0069: ASTPair currentAST = new ASTPair();
0070: AST declareParameters_AST = null;
0071:
0072: parameter();
0073: astFactory.addASTChild(currentAST, returnAST);
0074: {
0075: _loop3: do {
0076: if ((LA(1) == SEP_COMMA) && (_tokenSet_0.member(LA(2)))) {
0077: match(SEP_COMMA);
0078: parameter();
0079: astFactory.addASTChild(currentAST, returnAST);
0080: } else {
0081: break _loop3;
0082: }
0083:
0084: } while (true);
0085: }
0086: {
0087: switch (LA(1)) {
0088: case SEP_COMMA: {
0089: match(SEP_COMMA);
0090: break;
0091: }
0092: case EOF: {
0093: break;
0094: }
0095: default: {
0096: throw new NoViableAltException(LT(1), getFilename());
0097: }
0098: }
0099: }
0100: if (inputState.guessing == 0) {
0101: declareParameters_AST = currentAST.root;
0102: declareParameters_AST = astFactory.make((new ASTArray(2))
0103: .add(astFactory.create(PARAMETERS, "PARAMETERS"))
0104: .add(declareParameters_AST));
0105: currentAST.root = declareParameters_AST;
0106: currentAST.child = declareParameters_AST != null
0107: && declareParameters_AST.getFirstChild() != null ? declareParameters_AST
0108: .getFirstChild()
0109: : declareParameters_AST;
0110: currentAST.advanceChildToEnd();
0111: }
0112: declareParameters_AST = currentAST.root;
0113: returnAST = declareParameters_AST;
0114: }
0115:
0116: public final void parameter() throws RecognitionException,
0117: TokenStreamException {
0118:
0119: returnAST = null;
0120: ASTPair currentAST = new ASTPair();
0121: AST parameter_AST = null;
0122:
0123: type();
0124: astFactory.addASTChild(currentAST, returnAST);
0125: identifier();
0126: astFactory.addASTChild(currentAST, returnAST);
0127: if (inputState.guessing == 0) {
0128: parameter_AST = currentAST.root;
0129: parameter_AST = astFactory.make((new ASTArray(2)).add(
0130: astFactory.create(PARAMETER, "PARAMETER")).add(
0131: parameter_AST));
0132: currentAST.root = parameter_AST;
0133: currentAST.child = parameter_AST != null
0134: && parameter_AST.getFirstChild() != null ? parameter_AST
0135: .getFirstChild()
0136: : parameter_AST;
0137: currentAST.advanceChildToEnd();
0138: }
0139: parameter_AST = currentAST.root;
0140: returnAST = parameter_AST;
0141: }
0142:
0143: public final void type() throws RecognitionException,
0144: TokenStreamException {
0145:
0146: returnAST = null;
0147: ASTPair currentAST = new ASTPair();
0148: AST type_AST = null;
0149:
0150: switch (LA(1)) {
0151: case LITERAL_BOOLEAN:
0152: case LITERAL_BYTE:
0153: case LITERAL_SHORT:
0154: case LITERAL_INT:
0155: case LITERAL_LONG:
0156: case LITERAL_CHAR:
0157: case LITERAL_FLOAT:
0158: case LITERAL_DOUBLE: {
0159: primitiveType();
0160: astFactory.addASTChild(currentAST, returnAST);
0161: type_AST = currentAST.root;
0162: break;
0163: }
0164: case IDENTIFIER: {
0165: name();
0166: astFactory.addASTChild(currentAST, returnAST);
0167: type_AST = currentAST.root;
0168: break;
0169: }
0170: default: {
0171: throw new NoViableAltException(LT(1), getFilename());
0172: }
0173: }
0174: returnAST = type_AST;
0175: }
0176:
0177: public final void identifier() throws RecognitionException,
0178: TokenStreamException {
0179:
0180: returnAST = null;
0181: ASTPair currentAST = new ASTPair();
0182: AST identifier_AST = null;
0183:
0184: AST tmp3_AST = null;
0185: tmp3_AST = astFactory.create(LT(1));
0186: astFactory.addASTChild(currentAST, tmp3_AST);
0187: match(IDENTIFIER);
0188: identifier_AST = currentAST.root;
0189: returnAST = identifier_AST;
0190: }
0191:
0192: public final void declareVariables() throws RecognitionException,
0193: TokenStreamException {
0194:
0195: returnAST = null;
0196: ASTPair currentAST = new ASTPair();
0197: AST declareVariables_AST = null;
0198:
0199: variable();
0200: astFactory.addASTChild(currentAST, returnAST);
0201: {
0202: _loop8: do {
0203: if ((LA(1) == SEP_SEMICOLON)
0204: && (_tokenSet_0.member(LA(2)))) {
0205: match(SEP_SEMICOLON);
0206: variable();
0207: astFactory.addASTChild(currentAST, returnAST);
0208: } else {
0209: break _loop8;
0210: }
0211:
0212: } while (true);
0213: }
0214: {
0215: switch (LA(1)) {
0216: case SEP_SEMICOLON: {
0217: match(SEP_SEMICOLON);
0218: break;
0219: }
0220: case EOF: {
0221: break;
0222: }
0223: default: {
0224: throw new NoViableAltException(LT(1), getFilename());
0225: }
0226: }
0227: }
0228: if (inputState.guessing == 0) {
0229: declareVariables_AST = currentAST.root;
0230: declareVariables_AST = astFactory.make((new ASTArray(2))
0231: .add(astFactory.create(VARIABLES, "VARIABLES"))
0232: .add(declareVariables_AST));
0233: currentAST.root = declareVariables_AST;
0234: currentAST.child = declareVariables_AST != null
0235: && declareVariables_AST.getFirstChild() != null ? declareVariables_AST
0236: .getFirstChild()
0237: : declareVariables_AST;
0238: currentAST.advanceChildToEnd();
0239: }
0240: declareVariables_AST = currentAST.root;
0241: returnAST = declareVariables_AST;
0242: }
0243:
0244: public final void variable() throws RecognitionException,
0245: TokenStreamException {
0246:
0247: returnAST = null;
0248: ASTPair currentAST = new ASTPair();
0249: AST variable_AST = null;
0250:
0251: type();
0252: astFactory.addASTChild(currentAST, returnAST);
0253: identifier();
0254: astFactory.addASTChild(currentAST, returnAST);
0255: if (inputState.guessing == 0) {
0256: variable_AST = currentAST.root;
0257: variable_AST = astFactory.make((new ASTArray(2)).add(
0258: astFactory.create(VARIABLE, "VARIABLE")).add(
0259: variable_AST));
0260: currentAST.root = variable_AST;
0261: currentAST.child = variable_AST != null
0262: && variable_AST.getFirstChild() != null ? variable_AST
0263: .getFirstChild()
0264: : variable_AST;
0265: currentAST.advanceChildToEnd();
0266: }
0267: variable_AST = currentAST.root;
0268: returnAST = variable_AST;
0269: }
0270:
0271: public final void declareImports() throws RecognitionException,
0272: TokenStreamException {
0273:
0274: returnAST = null;
0275: ASTPair currentAST = new ASTPair();
0276: AST declareImports_AST = null;
0277:
0278: importDeclaration();
0279: astFactory.addASTChild(currentAST, returnAST);
0280: {
0281: _loop13: do {
0282: if ((LA(1) == SEP_SEMICOLON)
0283: && (LA(2) == LITERAL_IMPORT)) {
0284: match(SEP_SEMICOLON);
0285: importDeclaration();
0286: astFactory.addASTChild(currentAST, returnAST);
0287: } else {
0288: break _loop13;
0289: }
0290:
0291: } while (true);
0292: }
0293: {
0294: switch (LA(1)) {
0295: case SEP_SEMICOLON: {
0296: match(SEP_SEMICOLON);
0297: break;
0298: }
0299: case EOF: {
0300: break;
0301: }
0302: default: {
0303: throw new NoViableAltException(LT(1), getFilename());
0304: }
0305: }
0306: }
0307: if (inputState.guessing == 0) {
0308: declareImports_AST = currentAST.root;
0309: declareImports_AST = astFactory.make((new ASTArray(2)).add(
0310: astFactory.create(IMPORTS, "IMPORTS")).add(
0311: declareImports_AST));
0312: currentAST.root = declareImports_AST;
0313: currentAST.child = declareImports_AST != null
0314: && declareImports_AST.getFirstChild() != null ? declareImports_AST
0315: .getFirstChild()
0316: : declareImports_AST;
0317: currentAST.advanceChildToEnd();
0318: }
0319: declareImports_AST = currentAST.root;
0320: returnAST = declareImports_AST;
0321: }
0322:
0323: public final void importDeclaration() throws RecognitionException,
0324: TokenStreamException {
0325:
0326: returnAST = null;
0327: ASTPair currentAST = new ASTPair();
0328: AST importDeclaration_AST = null;
0329: Token node = null;
0330: AST node_AST = null;
0331:
0332: node = LT(1);
0333: node_AST = astFactory.create(node);
0334: astFactory.makeASTRoot(currentAST, node_AST);
0335: match(LITERAL_IMPORT);
0336: name();
0337: astFactory.addASTChild(currentAST, returnAST);
0338: if (inputState.guessing == 0) {
0339: node_AST.setType(IMPORT);
0340: }
0341: {
0342: switch (LA(1)) {
0343: case SEP_DOT: {
0344: match(SEP_DOT);
0345: match(OP_MULTIPLY);
0346: if (inputState.guessing == 0) {
0347: node_AST.setType(ON_DEMAND_IMPORT);
0348: }
0349: break;
0350: }
0351: case EOF:
0352: case SEP_SEMICOLON: {
0353: break;
0354: }
0355: default: {
0356: throw new NoViableAltException(LT(1), getFilename());
0357: }
0358: }
0359: }
0360: importDeclaration_AST = currentAST.root;
0361: returnAST = importDeclaration_AST;
0362: }
0363:
0364: public final void name() throws RecognitionException,
0365: TokenStreamException {
0366:
0367: returnAST = null;
0368: ASTPair currentAST = new ASTPair();
0369: AST name_AST = null;
0370: Token dot = null;
0371: AST dot_AST = null;
0372: AST i_AST = null;
0373:
0374: identifier();
0375: astFactory.addASTChild(currentAST, returnAST);
0376: {
0377: _loop80: do {
0378: if ((LA(1) == SEP_DOT) && (LA(2) == IDENTIFIER)) {
0379: dot = LT(1);
0380: dot_AST = astFactory.create(dot);
0381: match(SEP_DOT);
0382: identifier();
0383: i_AST = returnAST;
0384: if (inputState.guessing == 0) {
0385: name_AST = currentAST.root;
0386:
0387: name_AST.setText(name_AST.getText()
0388: + dot_AST.getText() + i_AST.getText());
0389:
0390: }
0391: } else {
0392: break _loop80;
0393: }
0394:
0395: } while (true);
0396: }
0397: if (inputState.guessing == 0) {
0398: name_AST = currentAST.root;
0399: name_AST.setType(NAME);
0400: }
0401: name_AST = currentAST.root;
0402: returnAST = name_AST;
0403: }
0404:
0405: public final void setOrdering() throws RecognitionException,
0406: TokenStreamException {
0407:
0408: returnAST = null;
0409: ASTPair currentAST = new ASTPair();
0410: AST setOrdering_AST = null;
0411:
0412: orderSpecification();
0413: astFactory.addASTChild(currentAST, returnAST);
0414: {
0415: _loop19: do {
0416: if ((LA(1) == SEP_COMMA) && (_tokenSet_1.member(LA(2)))) {
0417: match(SEP_COMMA);
0418: orderSpecification();
0419: astFactory.addASTChild(currentAST, returnAST);
0420: } else {
0421: break _loop19;
0422: }
0423:
0424: } while (true);
0425: }
0426: {
0427: switch (LA(1)) {
0428: case SEP_COMMA: {
0429: match(SEP_COMMA);
0430: break;
0431: }
0432: case EOF: {
0433: break;
0434: }
0435: default: {
0436: throw new NoViableAltException(LT(1), getFilename());
0437: }
0438: }
0439: }
0440: if (inputState.guessing == 0) {
0441: setOrdering_AST = currentAST.root;
0442: setOrdering_AST = astFactory.make((new ASTArray(2)).add(
0443: astFactory.create(ORDERSPECS, "ORDERSPECS")).add(
0444: setOrdering_AST));
0445: currentAST.root = setOrdering_AST;
0446: currentAST.child = setOrdering_AST != null
0447: && setOrdering_AST.getFirstChild() != null ? setOrdering_AST
0448: .getFirstChild()
0449: : setOrdering_AST;
0450: currentAST.advanceChildToEnd();
0451: }
0452: setOrdering_AST = currentAST.root;
0453: returnAST = setOrdering_AST;
0454: }
0455:
0456: public final void orderSpecification() throws RecognitionException,
0457: TokenStreamException {
0458:
0459: returnAST = null;
0460: ASTPair currentAST = new ASTPair();
0461: AST orderSpecification_AST = null;
0462:
0463: expression();
0464: astFactory.addASTChild(currentAST, returnAST);
0465: {
0466: switch (LA(1)) {
0467: case LITERAL_ASCENDING: {
0468: AST tmp12_AST = null;
0469: tmp12_AST = astFactory.create(LT(1));
0470: astFactory.addASTChild(currentAST, tmp12_AST);
0471: match(LITERAL_ASCENDING);
0472: break;
0473: }
0474: case LITERAL_DESCENDING: {
0475: AST tmp13_AST = null;
0476: tmp13_AST = astFactory.create(LT(1));
0477: astFactory.addASTChild(currentAST, tmp13_AST);
0478: match(LITERAL_DESCENDING);
0479: break;
0480: }
0481: default: {
0482: throw new NoViableAltException(LT(1), getFilename());
0483: }
0484: }
0485: }
0486: if (inputState.guessing == 0) {
0487: orderSpecification_AST = currentAST.root;
0488: orderSpecification_AST = astFactory.make((new ASTArray(2))
0489: .add(astFactory.create(ORDERSPEC, "ORDERSPEC"))
0490: .add(orderSpecification_AST));
0491: currentAST.root = orderSpecification_AST;
0492: currentAST.child = orderSpecification_AST != null
0493: && orderSpecification_AST.getFirstChild() != null ? orderSpecification_AST
0494: .getFirstChild()
0495: : orderSpecification_AST;
0496: currentAST.advanceChildToEnd();
0497: }
0498: orderSpecification_AST = currentAST.root;
0499: returnAST = orderSpecification_AST;
0500: }
0501:
0502: public final void expression() throws RecognitionException,
0503: TokenStreamException {
0504:
0505: returnAST = null;
0506: ASTPair currentAST = new ASTPair();
0507: AST expression_AST = null;
0508:
0509: conditionalOrExpression();
0510: astFactory.addASTChild(currentAST, returnAST);
0511: expression_AST = currentAST.root;
0512: returnAST = expression_AST;
0513: }
0514:
0515: public final void primary() throws RecognitionException,
0516: TokenStreamException {
0517:
0518: returnAST = null;
0519: ASTPair currentAST = new ASTPair();
0520: AST primary_AST = null;
0521:
0522: {
0523: switch (LA(1)) {
0524: case LITERAL_TRUE:
0525: case LITERAL_FALSE:
0526: case LITERAL_NULL:
0527: case FLOATING_POINT_LITERAL:
0528: case INTEGER_LITERAL:
0529: case CHARACTER_LITERAL:
0530: case STRING_LITERAL: {
0531: literal();
0532: astFactory.addASTChild(currentAST, returnAST);
0533: break;
0534: }
0535: case LITERAL_THIS: {
0536: AST tmp14_AST = null;
0537: tmp14_AST = astFactory.create(LT(1));
0538: astFactory.makeASTRoot(currentAST, tmp14_AST);
0539: match(LITERAL_THIS);
0540: break;
0541: }
0542: case SEP_OPENING_PARENTHESIS: {
0543: match(SEP_OPENING_PARENTHESIS);
0544: expression();
0545: astFactory.addASTChild(currentAST, returnAST);
0546: match(SEP_CLOSING_PARENTHESIS);
0547: break;
0548: }
0549: case IDENTIFIER: {
0550: directAccess();
0551: astFactory.addASTChild(currentAST, returnAST);
0552: break;
0553: }
0554: default: {
0555: throw new NoViableAltException(LT(1), getFilename());
0556: }
0557: }
0558: }
0559: primary_AST = currentAST.root;
0560: returnAST = primary_AST;
0561: }
0562:
0563: public final void literal() throws RecognitionException,
0564: TokenStreamException {
0565:
0566: returnAST = null;
0567: ASTPair currentAST = new ASTPair();
0568: AST literal_AST = null;
0569:
0570: switch (LA(1)) {
0571: case LITERAL_TRUE: {
0572: AST tmp17_AST = null;
0573: tmp17_AST = astFactory.create(LT(1));
0574: astFactory.addASTChild(currentAST, tmp17_AST);
0575: match(LITERAL_TRUE);
0576: literal_AST = currentAST.root;
0577: break;
0578: }
0579: case LITERAL_FALSE: {
0580: AST tmp18_AST = null;
0581: tmp18_AST = astFactory.create(LT(1));
0582: astFactory.addASTChild(currentAST, tmp18_AST);
0583: match(LITERAL_FALSE);
0584: literal_AST = currentAST.root;
0585: break;
0586: }
0587: case LITERAL_NULL: {
0588: AST tmp19_AST = null;
0589: tmp19_AST = astFactory.create(LT(1));
0590: astFactory.addASTChild(currentAST, tmp19_AST);
0591: match(LITERAL_NULL);
0592: literal_AST = currentAST.root;
0593: break;
0594: }
0595: case INTEGER_LITERAL: {
0596: AST tmp20_AST = null;
0597: tmp20_AST = astFactory.create(LT(1));
0598: astFactory.addASTChild(currentAST, tmp20_AST);
0599: match(INTEGER_LITERAL);
0600: literal_AST = currentAST.root;
0601: break;
0602: }
0603: case FLOATING_POINT_LITERAL: {
0604: AST tmp21_AST = null;
0605: tmp21_AST = astFactory.create(LT(1));
0606: astFactory.addASTChild(currentAST, tmp21_AST);
0607: match(FLOATING_POINT_LITERAL);
0608: literal_AST = currentAST.root;
0609: break;
0610: }
0611: case CHARACTER_LITERAL: {
0612: AST tmp22_AST = null;
0613: tmp22_AST = astFactory.create(LT(1));
0614: astFactory.addASTChild(currentAST, tmp22_AST);
0615: match(CHARACTER_LITERAL);
0616: literal_AST = currentAST.root;
0617: break;
0618: }
0619: case STRING_LITERAL: {
0620: AST tmp23_AST = null;
0621: tmp23_AST = astFactory.create(LT(1));
0622: astFactory.addASTChild(currentAST, tmp23_AST);
0623: match(STRING_LITERAL);
0624: literal_AST = currentAST.root;
0625: break;
0626: }
0627: default: {
0628: throw new NoViableAltException(LT(1), getFilename());
0629: }
0630: }
0631: returnAST = literal_AST;
0632: }
0633:
0634: public final void directAccess() throws RecognitionException,
0635: TokenStreamException {
0636:
0637: returnAST = null;
0638: ASTPair currentAST = new ASTPair();
0639: AST directAccess_AST = null;
0640: Token id = null;
0641: AST id_AST = null;
0642:
0643: id = LT(1);
0644: id_AST = astFactory.create(id);
0645: astFactory.makeASTRoot(currentAST, id_AST);
0646: match(IDENTIFIER);
0647: {
0648: switch (LA(1)) {
0649: case SEP_OPENING_PARENTHESIS: {
0650: match(SEP_OPENING_PARENTHESIS);
0651: argList();
0652: astFactory.addASTChild(currentAST, returnAST);
0653: match(SEP_CLOSING_PARENTHESIS);
0654: if (inputState.guessing == 0) {
0655: directAccess_AST = currentAST.root;
0656: directAccess_AST.setType(METHOD_INVOCATION);
0657: }
0658: break;
0659: }
0660: case EOF:
0661: case LITERAL_ASCENDING:
0662: case LITERAL_DESCENDING:
0663: case OP_GREATER_OR_EQUAL:
0664: case OP_LOWER_OR_EQUAL:
0665: case OP_NOT_EQUAL:
0666: case OP_AND:
0667: case OP_OR:
0668: case SEP_DOT:
0669: case SEP_CLOSING_PARENTHESIS:
0670: case SEP_COMMA:
0671: case OP_EQUAL:
0672: case OP_GREATER:
0673: case OP_LOWER:
0674: case OP_BITWISE_AND:
0675: case OP_BITWISE_OR:
0676: case OP_BITWISE_XOR:
0677: case OP_BINARY_PLUS:
0678: case OP_BINARY_MINUS:
0679: case OP_MULTIPLY:
0680: case OP_DIVIDE: {
0681: if (inputState.guessing == 0) {
0682: directAccess_AST = currentAST.root;
0683: directAccess_AST.setType(NAME_EXPRESSION);
0684: }
0685: break;
0686: }
0687: default: {
0688: throw new NoViableAltException(LT(1), getFilename());
0689: }
0690: }
0691: }
0692: directAccess_AST = currentAST.root;
0693: returnAST = directAccess_AST;
0694: }
0695:
0696: public final void argList() throws RecognitionException,
0697: TokenStreamException {
0698:
0699: returnAST = null;
0700: ASTPair currentAST = new ASTPair();
0701: AST argList_AST = null;
0702:
0703: {
0704: switch (LA(1)) {
0705: case LITERAL_TRUE:
0706: case LITERAL_FALSE:
0707: case LITERAL_NULL:
0708: case LITERAL_THIS:
0709: case FLOATING_POINT_LITERAL:
0710: case INTEGER_LITERAL:
0711: case SEP_OPENING_PARENTHESIS:
0712: case OP_NOT:
0713: case OP_BITWISE_COMPLEMENT:
0714: case OP_BINARY_PLUS:
0715: case OP_BINARY_MINUS:
0716: case IDENTIFIER:
0717: case CHARACTER_LITERAL:
0718: case STRING_LITERAL: {
0719: expression();
0720: astFactory.addASTChild(currentAST, returnAST);
0721: {
0722: _loop30: do {
0723: if ((LA(1) == SEP_COMMA)) {
0724: match(SEP_COMMA);
0725: expression();
0726: astFactory.addASTChild(currentAST,
0727: returnAST);
0728: } else {
0729: break _loop30;
0730: }
0731:
0732: } while (true);
0733: }
0734: if (inputState.guessing == 0) {
0735: argList_AST = currentAST.root;
0736: argList_AST = astFactory.make((new ASTArray(2))
0737: .add(
0738: astFactory.create(ARG_LIST,
0739: "ARG_LIST")).add(
0740: argList_AST));
0741: currentAST.root = argList_AST;
0742: currentAST.child = argList_AST != null
0743: && argList_AST.getFirstChild() != null ? argList_AST
0744: .getFirstChild()
0745: : argList_AST;
0746: currentAST.advanceChildToEnd();
0747: }
0748: break;
0749: }
0750: case SEP_CLOSING_PARENTHESIS: {
0751: if (inputState.guessing == 0) {
0752: argList_AST = currentAST.root;
0753: argList_AST = astFactory.create(ARG_LIST,
0754: "ARG_LIST");
0755: currentAST.root = argList_AST;
0756: currentAST.child = argList_AST != null
0757: && argList_AST.getFirstChild() != null ? argList_AST
0758: .getFirstChild()
0759: : argList_AST;
0760: currentAST.advanceChildToEnd();
0761: }
0762: break;
0763: }
0764: default: {
0765: throw new NoViableAltException(LT(1), getFilename());
0766: }
0767: }
0768: }
0769: argList_AST = currentAST.root;
0770: returnAST = argList_AST;
0771: }
0772:
0773: public final void postfixExpression() throws RecognitionException,
0774: TokenStreamException {
0775:
0776: returnAST = null;
0777: ASTPair currentAST = new ASTPair();
0778: AST postfixExpression_AST = null;
0779:
0780: primary();
0781: astFactory.addASTChild(currentAST, returnAST);
0782: {
0783: _loop33: do {
0784: if ((LA(1) == SEP_DOT)) {
0785: AST tmp27_AST = null;
0786: tmp27_AST = astFactory.create(LT(1));
0787: astFactory.makeASTRoot(currentAST, tmp27_AST);
0788: match(SEP_DOT);
0789: directAccess();
0790: astFactory.addASTChild(currentAST, returnAST);
0791: } else {
0792: break _loop33;
0793: }
0794:
0795: } while (true);
0796: }
0797: postfixExpression_AST = currentAST.root;
0798: returnAST = postfixExpression_AST;
0799: }
0800:
0801: public final void unaryExpression() throws RecognitionException,
0802: TokenStreamException {
0803:
0804: returnAST = null;
0805: ASTPair currentAST = new ASTPair();
0806: AST unaryExpression_AST = null;
0807: Token op1 = null;
0808: AST op1_AST = null;
0809: Token op2 = null;
0810: AST op2_AST = null;
0811:
0812: {
0813: switch (LA(1)) {
0814: case OP_BINARY_MINUS: {
0815: op1 = LT(1);
0816: op1_AST = astFactory.create(op1);
0817: astFactory.makeASTRoot(currentAST, op1_AST);
0818: match(OP_BINARY_MINUS);
0819: unaryExpression();
0820: astFactory.addASTChild(currentAST, returnAST);
0821: if (inputState.guessing == 0) {
0822:
0823: op1_AST.setType(OP_UNARY_MINUS);
0824:
0825: }
0826: break;
0827: }
0828: case OP_BINARY_PLUS: {
0829: op2 = LT(1);
0830: op2_AST = astFactory.create(op2);
0831: astFactory.makeASTRoot(currentAST, op2_AST);
0832: match(OP_BINARY_PLUS);
0833: unaryExpression();
0834: astFactory.addASTChild(currentAST, returnAST);
0835: if (inputState.guessing == 0) {
0836:
0837: op2_AST.setType(OP_UNARY_PLUS);
0838:
0839: }
0840: break;
0841: }
0842: case LITERAL_TRUE:
0843: case LITERAL_FALSE:
0844: case LITERAL_NULL:
0845: case LITERAL_THIS:
0846: case FLOATING_POINT_LITERAL:
0847: case INTEGER_LITERAL:
0848: case SEP_OPENING_PARENTHESIS:
0849: case OP_NOT:
0850: case OP_BITWISE_COMPLEMENT:
0851: case IDENTIFIER:
0852: case CHARACTER_LITERAL:
0853: case STRING_LITERAL: {
0854: unaryExpressionNotPlusMinus();
0855: astFactory.addASTChild(currentAST, returnAST);
0856: break;
0857: }
0858: default: {
0859: throw new NoViableAltException(LT(1), getFilename());
0860: }
0861: }
0862: }
0863: unaryExpression_AST = currentAST.root;
0864: returnAST = unaryExpression_AST;
0865: }
0866:
0867: public final void unaryExpressionNotPlusMinus()
0868: throws RecognitionException, TokenStreamException {
0869:
0870: returnAST = null;
0871: ASTPair currentAST = new ASTPair();
0872: AST unaryExpressionNotPlusMinus_AST = null;
0873:
0874: {
0875: switch (LA(1)) {
0876: case OP_BITWISE_COMPLEMENT: {
0877: AST tmp28_AST = null;
0878: tmp28_AST = astFactory.create(LT(1));
0879: astFactory.makeASTRoot(currentAST, tmp28_AST);
0880: match(OP_BITWISE_COMPLEMENT);
0881: unaryExpression();
0882: astFactory.addASTChild(currentAST, returnAST);
0883: break;
0884: }
0885: case OP_NOT: {
0886: AST tmp29_AST = null;
0887: tmp29_AST = astFactory.create(LT(1));
0888: astFactory.makeASTRoot(currentAST, tmp29_AST);
0889: match(OP_NOT);
0890: unaryExpression();
0891: astFactory.addASTChild(currentAST, returnAST);
0892: break;
0893: }
0894: default:
0895: boolean synPredMatched39 = false;
0896: if (((LA(1) == SEP_OPENING_PARENTHESIS) && (_tokenSet_0
0897: .member(LA(2))))) {
0898: int _m39 = mark();
0899: synPredMatched39 = true;
0900: inputState.guessing++;
0901: try {
0902: {
0903: match(SEP_OPENING_PARENTHESIS);
0904: type();
0905: match(SEP_CLOSING_PARENTHESIS);
0906: unaryExpression();
0907: }
0908: } catch (RecognitionException pe) {
0909: synPredMatched39 = false;
0910: }
0911: rewind(_m39);
0912: inputState.guessing--;
0913: }
0914: if (synPredMatched39) {
0915: castExpression();
0916: astFactory.addASTChild(currentAST, returnAST);
0917: } else if ((_tokenSet_2.member(LA(1)))
0918: && (_tokenSet_3.member(LA(2)))) {
0919: postfixExpression();
0920: astFactory.addASTChild(currentAST, returnAST);
0921: } else {
0922: throw new NoViableAltException(LT(1), getFilename());
0923: }
0924: }
0925: }
0926: unaryExpressionNotPlusMinus_AST = currentAST.root;
0927: returnAST = unaryExpressionNotPlusMinus_AST;
0928: }
0929:
0930: public final void castExpression() throws RecognitionException,
0931: TokenStreamException {
0932:
0933: returnAST = null;
0934: ASTPair currentAST = new ASTPair();
0935: AST castExpression_AST = null;
0936:
0937: match(SEP_OPENING_PARENTHESIS);
0938: type();
0939: astFactory.addASTChild(currentAST, returnAST);
0940: match(SEP_CLOSING_PARENTHESIS);
0941: unaryExpression();
0942: astFactory.addASTChild(currentAST, returnAST);
0943: if (inputState.guessing == 0) {
0944: castExpression_AST = currentAST.root;
0945: castExpression_AST = astFactory.make((new ASTArray(2)).add(
0946: astFactory.create(CAST, "CAST")).add(
0947: castExpression_AST));
0948: currentAST.root = castExpression_AST;
0949: currentAST.child = castExpression_AST != null
0950: && castExpression_AST.getFirstChild() != null ? castExpression_AST
0951: .getFirstChild()
0952: : castExpression_AST;
0953: currentAST.advanceChildToEnd();
0954: }
0955: castExpression_AST = currentAST.root;
0956: returnAST = castExpression_AST;
0957: }
0958:
0959: public final void multiplicativeExpression()
0960: throws RecognitionException, TokenStreamException {
0961:
0962: returnAST = null;
0963: ASTPair currentAST = new ASTPair();
0964: AST multiplicativeExpression_AST = null;
0965:
0966: unaryExpression();
0967: astFactory.addASTChild(currentAST, returnAST);
0968: {
0969: _loop44: do {
0970: if ((LA(1) == OP_MULTIPLY || LA(1) == OP_DIVIDE)) {
0971: {
0972: switch (LA(1)) {
0973: case OP_MULTIPLY: {
0974: AST tmp32_AST = null;
0975: tmp32_AST = astFactory.create(LT(1));
0976: astFactory.makeASTRoot(currentAST,
0977: tmp32_AST);
0978: match(OP_MULTIPLY);
0979: break;
0980: }
0981: case OP_DIVIDE: {
0982: AST tmp33_AST = null;
0983: tmp33_AST = astFactory.create(LT(1));
0984: astFactory.makeASTRoot(currentAST,
0985: tmp33_AST);
0986: match(OP_DIVIDE);
0987: break;
0988: }
0989: default: {
0990: throw new NoViableAltException(LT(1),
0991: getFilename());
0992: }
0993: }
0994: }
0995: unaryExpression();
0996: astFactory.addASTChild(currentAST, returnAST);
0997: } else {
0998: break _loop44;
0999: }
1000:
1001: } while (true);
1002: }
1003: multiplicativeExpression_AST = currentAST.root;
1004: returnAST = multiplicativeExpression_AST;
1005: }
1006:
1007: public final void additiveExpression() throws RecognitionException,
1008: TokenStreamException {
1009:
1010: returnAST = null;
1011: ASTPair currentAST = new ASTPair();
1012: AST additiveExpression_AST = null;
1013:
1014: multiplicativeExpression();
1015: astFactory.addASTChild(currentAST, returnAST);
1016: {
1017: _loop48: do {
1018: if ((LA(1) == OP_BINARY_PLUS || LA(1) == OP_BINARY_MINUS)) {
1019: {
1020: switch (LA(1)) {
1021: case OP_BINARY_PLUS: {
1022: AST tmp34_AST = null;
1023: tmp34_AST = astFactory.create(LT(1));
1024: astFactory.makeASTRoot(currentAST,
1025: tmp34_AST);
1026: match(OP_BINARY_PLUS);
1027: break;
1028: }
1029: case OP_BINARY_MINUS: {
1030: AST tmp35_AST = null;
1031: tmp35_AST = astFactory.create(LT(1));
1032: astFactory.makeASTRoot(currentAST,
1033: tmp35_AST);
1034: match(OP_BINARY_MINUS);
1035: break;
1036: }
1037: default: {
1038: throw new NoViableAltException(LT(1),
1039: getFilename());
1040: }
1041: }
1042: }
1043: multiplicativeExpression();
1044: astFactory.addASTChild(currentAST, returnAST);
1045: } else {
1046: break _loop48;
1047: }
1048:
1049: } while (true);
1050: }
1051: additiveExpression_AST = currentAST.root;
1052: returnAST = additiveExpression_AST;
1053: }
1054:
1055: public final void relationalExpression()
1056: throws RecognitionException, TokenStreamException {
1057:
1058: returnAST = null;
1059: ASTPair currentAST = new ASTPair();
1060: AST relationalExpression_AST = null;
1061:
1062: additiveExpression();
1063: astFactory.addASTChild(currentAST, returnAST);
1064: {
1065: _loop52: do {
1066: if ((_tokenSet_4.member(LA(1)))) {
1067: {
1068: switch (LA(1)) {
1069: case OP_LOWER: {
1070: AST tmp36_AST = null;
1071: tmp36_AST = astFactory.create(LT(1));
1072: astFactory.makeASTRoot(currentAST,
1073: tmp36_AST);
1074: match(OP_LOWER);
1075: break;
1076: }
1077: case OP_GREATER: {
1078: AST tmp37_AST = null;
1079: tmp37_AST = astFactory.create(LT(1));
1080: astFactory.makeASTRoot(currentAST,
1081: tmp37_AST);
1082: match(OP_GREATER);
1083: break;
1084: }
1085: case OP_LOWER_OR_EQUAL: {
1086: AST tmp38_AST = null;
1087: tmp38_AST = astFactory.create(LT(1));
1088: astFactory.makeASTRoot(currentAST,
1089: tmp38_AST);
1090: match(OP_LOWER_OR_EQUAL);
1091: break;
1092: }
1093: case OP_GREATER_OR_EQUAL: {
1094: AST tmp39_AST = null;
1095: tmp39_AST = astFactory.create(LT(1));
1096: astFactory.makeASTRoot(currentAST,
1097: tmp39_AST);
1098: match(OP_GREATER_OR_EQUAL);
1099: break;
1100: }
1101: default: {
1102: throw new NoViableAltException(LT(1),
1103: getFilename());
1104: }
1105: }
1106: }
1107: additiveExpression();
1108: astFactory.addASTChild(currentAST, returnAST);
1109: } else {
1110: break _loop52;
1111: }
1112:
1113: } while (true);
1114: }
1115: relationalExpression_AST = currentAST.root;
1116: returnAST = relationalExpression_AST;
1117: }
1118:
1119: public final void equalityExpression() throws RecognitionException,
1120: TokenStreamException {
1121:
1122: returnAST = null;
1123: ASTPair currentAST = new ASTPair();
1124: AST equalityExpression_AST = null;
1125:
1126: relationalExpression();
1127: astFactory.addASTChild(currentAST, returnAST);
1128: {
1129: _loop56: do {
1130: if ((LA(1) == OP_NOT_EQUAL || LA(1) == OP_EQUAL)) {
1131: {
1132: switch (LA(1)) {
1133: case OP_EQUAL: {
1134: AST tmp40_AST = null;
1135: tmp40_AST = astFactory.create(LT(1));
1136: astFactory.makeASTRoot(currentAST,
1137: tmp40_AST);
1138: match(OP_EQUAL);
1139: break;
1140: }
1141: case OP_NOT_EQUAL: {
1142: AST tmp41_AST = null;
1143: tmp41_AST = astFactory.create(LT(1));
1144: astFactory.makeASTRoot(currentAST,
1145: tmp41_AST);
1146: match(OP_NOT_EQUAL);
1147: break;
1148: }
1149: default: {
1150: throw new NoViableAltException(LT(1),
1151: getFilename());
1152: }
1153: }
1154: }
1155: relationalExpression();
1156: astFactory.addASTChild(currentAST, returnAST);
1157: } else {
1158: break _loop56;
1159: }
1160:
1161: } while (true);
1162: }
1163: equalityExpression_AST = currentAST.root;
1164: returnAST = equalityExpression_AST;
1165: }
1166:
1167: public final void andExpression() throws RecognitionException,
1168: TokenStreamException {
1169:
1170: returnAST = null;
1171: ASTPair currentAST = new ASTPair();
1172: AST andExpression_AST = null;
1173:
1174: equalityExpression();
1175: astFactory.addASTChild(currentAST, returnAST);
1176: {
1177: _loop59: do {
1178: if ((LA(1) == OP_BITWISE_AND)) {
1179: AST tmp42_AST = null;
1180: tmp42_AST = astFactory.create(LT(1));
1181: astFactory.makeASTRoot(currentAST, tmp42_AST);
1182: match(OP_BITWISE_AND);
1183: equalityExpression();
1184: astFactory.addASTChild(currentAST, returnAST);
1185: } else {
1186: break _loop59;
1187: }
1188:
1189: } while (true);
1190: }
1191: andExpression_AST = currentAST.root;
1192: returnAST = andExpression_AST;
1193: }
1194:
1195: public final void exclusiveOrExpression()
1196: throws RecognitionException, TokenStreamException {
1197:
1198: returnAST = null;
1199: ASTPair currentAST = new ASTPair();
1200: AST exclusiveOrExpression_AST = null;
1201:
1202: andExpression();
1203: astFactory.addASTChild(currentAST, returnAST);
1204: {
1205: _loop62: do {
1206: if ((LA(1) == OP_BITWISE_XOR)) {
1207: AST tmp43_AST = null;
1208: tmp43_AST = astFactory.create(LT(1));
1209: astFactory.makeASTRoot(currentAST, tmp43_AST);
1210: match(OP_BITWISE_XOR);
1211: andExpression();
1212: astFactory.addASTChild(currentAST, returnAST);
1213: } else {
1214: break _loop62;
1215: }
1216:
1217: } while (true);
1218: }
1219: exclusiveOrExpression_AST = currentAST.root;
1220: returnAST = exclusiveOrExpression_AST;
1221: }
1222:
1223: public final void inclusiveOrExpression()
1224: throws RecognitionException, TokenStreamException {
1225:
1226: returnAST = null;
1227: ASTPair currentAST = new ASTPair();
1228: AST inclusiveOrExpression_AST = null;
1229:
1230: exclusiveOrExpression();
1231: astFactory.addASTChild(currentAST, returnAST);
1232: {
1233: _loop65: do {
1234: if ((LA(1) == OP_BITWISE_OR)) {
1235: AST tmp44_AST = null;
1236: tmp44_AST = astFactory.create(LT(1));
1237: astFactory.makeASTRoot(currentAST, tmp44_AST);
1238: match(OP_BITWISE_OR);
1239: exclusiveOrExpression();
1240: astFactory.addASTChild(currentAST, returnAST);
1241: } else {
1242: break _loop65;
1243: }
1244:
1245: } while (true);
1246: }
1247: inclusiveOrExpression_AST = currentAST.root;
1248: returnAST = inclusiveOrExpression_AST;
1249: }
1250:
1251: public final void conditionalAndExpression()
1252: throws RecognitionException, TokenStreamException {
1253:
1254: returnAST = null;
1255: ASTPair currentAST = new ASTPair();
1256: AST conditionalAndExpression_AST = null;
1257:
1258: inclusiveOrExpression();
1259: astFactory.addASTChild(currentAST, returnAST);
1260: {
1261: _loop68: do {
1262: if ((LA(1) == OP_AND)) {
1263: AST tmp45_AST = null;
1264: tmp45_AST = astFactory.create(LT(1));
1265: astFactory.makeASTRoot(currentAST, tmp45_AST);
1266: match(OP_AND);
1267: inclusiveOrExpression();
1268: astFactory.addASTChild(currentAST, returnAST);
1269: } else {
1270: break _loop68;
1271: }
1272:
1273: } while (true);
1274: }
1275: conditionalAndExpression_AST = currentAST.root;
1276: returnAST = conditionalAndExpression_AST;
1277: }
1278:
1279: public final void conditionalOrExpression()
1280: throws RecognitionException, TokenStreamException {
1281:
1282: returnAST = null;
1283: ASTPair currentAST = new ASTPair();
1284: AST conditionalOrExpression_AST = null;
1285:
1286: conditionalAndExpression();
1287: astFactory.addASTChild(currentAST, returnAST);
1288: {
1289: _loop71: do {
1290: if ((LA(1) == OP_OR)) {
1291: AST tmp46_AST = null;
1292: tmp46_AST = astFactory.create(LT(1));
1293: astFactory.makeASTRoot(currentAST, tmp46_AST);
1294: match(OP_OR);
1295: conditionalAndExpression();
1296: astFactory.addASTChild(currentAST, returnAST);
1297: } else {
1298: break _loop71;
1299: }
1300:
1301: } while (true);
1302: }
1303: conditionalOrExpression_AST = currentAST.root;
1304: returnAST = conditionalOrExpression_AST;
1305: }
1306:
1307: public final void dummyExpressionUsage()
1308: throws RecognitionException, TokenStreamException {
1309:
1310: returnAST = null;
1311: ASTPair currentAST = new ASTPair();
1312: AST dummyExpressionUsage_AST = null;
1313:
1314: expression();
1315: astFactory.addASTChild(currentAST, returnAST);
1316: dummyExpressionUsage_AST = currentAST.root;
1317: returnAST = dummyExpressionUsage_AST;
1318: }
1319:
1320: public final void primitiveType() throws RecognitionException,
1321: TokenStreamException {
1322:
1323: returnAST = null;
1324: ASTPair currentAST = new ASTPair();
1325: AST primitiveType_AST = null;
1326:
1327: {
1328: switch (LA(1)) {
1329: case LITERAL_BOOLEAN: {
1330: AST tmp47_AST = null;
1331: tmp47_AST = astFactory.create(LT(1));
1332: astFactory.addASTChild(currentAST, tmp47_AST);
1333: match(LITERAL_BOOLEAN);
1334: break;
1335: }
1336: case LITERAL_BYTE: {
1337: AST tmp48_AST = null;
1338: tmp48_AST = astFactory.create(LT(1));
1339: astFactory.addASTChild(currentAST, tmp48_AST);
1340: match(LITERAL_BYTE);
1341: break;
1342: }
1343: case LITERAL_SHORT: {
1344: AST tmp49_AST = null;
1345: tmp49_AST = astFactory.create(LT(1));
1346: astFactory.addASTChild(currentAST, tmp49_AST);
1347: match(LITERAL_SHORT);
1348: break;
1349: }
1350: case LITERAL_INT: {
1351: AST tmp50_AST = null;
1352: tmp50_AST = astFactory.create(LT(1));
1353: astFactory.addASTChild(currentAST, tmp50_AST);
1354: match(LITERAL_INT);
1355: break;
1356: }
1357: case LITERAL_LONG: {
1358: AST tmp51_AST = null;
1359: tmp51_AST = astFactory.create(LT(1));
1360: astFactory.addASTChild(currentAST, tmp51_AST);
1361: match(LITERAL_LONG);
1362: break;
1363: }
1364: case LITERAL_CHAR: {
1365: AST tmp52_AST = null;
1366: tmp52_AST = astFactory.create(LT(1));
1367: astFactory.addASTChild(currentAST, tmp52_AST);
1368: match(LITERAL_CHAR);
1369: break;
1370: }
1371: case LITERAL_FLOAT: {
1372: AST tmp53_AST = null;
1373: tmp53_AST = astFactory.create(LT(1));
1374: astFactory.addASTChild(currentAST, tmp53_AST);
1375: match(LITERAL_FLOAT);
1376: break;
1377: }
1378: case LITERAL_DOUBLE: {
1379: AST tmp54_AST = null;
1380: tmp54_AST = astFactory.create(LT(1));
1381: astFactory.addASTChild(currentAST, tmp54_AST);
1382: match(LITERAL_DOUBLE);
1383: break;
1384: }
1385: default: {
1386: throw new NoViableAltException(LT(1), getFilename());
1387: }
1388: }
1389: }
1390: if (inputState.guessing == 0) {
1391: primitiveType_AST = currentAST.root;
1392: primitiveType_AST.setType(PRIMITIVE_TYPE);
1393: }
1394: primitiveType_AST = currentAST.root;
1395: returnAST = primitiveType_AST;
1396: }
1397:
1398: public static final String[] _tokenNames = { "<0>", "EOF", "<2>",
1399: "NULL_TREE_LOOKAHEAD", "PARAMETERS", "PARAMETER",
1400: "VARIABLES", "VARIABLE", "IMPORTS", "IMPORT",
1401: "ON_DEMAND_IMPORT", "ORDERSPECS", "ORDERSPEC", "EXPR",
1402: "CAST", "METHOD_INVOCATION", "ARG_LIST", "NAME_EXPRESSION",
1403: "PRIMITIVE_TYPE", "NAME", "\"import\"", "\"ascending\"",
1404: "\"descending\"", "\"true\"", "\"false\"", "\"null\"",
1405: "\"this\"", "\"boolean\"", "\"byte\"", "\"short\"",
1406: "\"int\"", "\"long\"", "\"char\"", "\"float\"",
1407: "\"double\"", "OP_GREATER_OR_EQUAL", "OP_LOWER_OR_EQUAL",
1408: "OP_NOT_EQUAL", "OP_AND", "OP_OR", "OP_UNARY_MINUS",
1409: "OP_UNARY_PLUS", "SEP_DOT", "FLOATING_POINT_LITERAL",
1410: "INTEGER_LITERAL", "SEP_OPENING_PARENTHESIS",
1411: "SEP_CLOSING_PARENTHESIS", "SEP_SEMICOLON", "SEP_COMMA",
1412: "OP_EQUAL", "OP_GREATER", "OP_LOWER", "OP_NOT",
1413: "OP_BITWISE_COMPLEMENT", "OP_BITWISE_AND", "OP_BITWISE_OR",
1414: "OP_BITWISE_XOR", "OP_BINARY_PLUS", "OP_BINARY_MINUS",
1415: "OP_MULTIPLY", "OP_DIVIDE", "WHITESPACE", "IDENTIFIER",
1416: "CHARACTER_LITERAL", "STRING_LITERAL",
1417: "INT_OR_FLOAT_LITERAL_OR_DOT", "LINE_TERMINATOR",
1418: "ESCAPE_SEQUENCE", "UNICODE_ESCAPE", "OCTAL_ESCAPE",
1419: "OCTAL_DIGIT", "DIGIT", "HEX_DIGIT", "EXPONENT_PART",
1420: "INTEGER_TYPE_SUFFIX", "FLOAT_TYPE_SUFFIX",
1421: "IDENTIFIER_START", "IDENTIFIER_PART" };
1422:
1423: protected void buildTokenTypeASTClassMap() {
1424: tokenTypeToASTClassMap = null;
1425: };
1426:
1427: private static final long[] mk_tokenSet_0() {
1428: long[] data = { 4611686052652908544L, 0L };
1429: return data;
1430: }
1431:
1432: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
1433:
1434: private static final long[] mk_tokenSet_1() {
1435: long[] data = { -4165768082540724224L, 1L, 0L, 0L };
1436: return data;
1437: }
1438:
1439: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
1440:
1441: private static final long[] mk_tokenSet_2() {
1442: long[] data = { -4611624445650403328L, 1L, 0L, 0L };
1443: return data;
1444: }
1445:
1446: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
1447:
1448: private static final long[] mk_tokenSet_3() {
1449: long[] data = { -2305987079464550398L, 1L, 0L, 0L };
1450: return data;
1451: }
1452:
1453: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
1454:
1455: private static final long[] mk_tokenSet_4() {
1456: long[] data = { 3377802799742976L, 0L };
1457: return data;
1458: }
1459:
1460: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
1461:
1462: }
|