0001: // $ANTLR 2.7.5 (20050128): "javatree.g" -> "JavaTreeRecognizer.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: 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: @SuppressWarnings({"unused","cast"})
0025: public class JavaTreeRecognizer extends antlr.LLkParser implements
0026: JavaTreeTokenTypes {
0027:
0028: protected JavaTreeRecognizer(TokenBuffer tokenBuf, int k) {
0029: super (tokenBuf, k);
0030: tokenNames = _tokenNames;
0031: buildTokenTypeASTClassMap();
0032: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0033: }
0034:
0035: public JavaTreeRecognizer(TokenBuffer tokenBuf) {
0036: this (tokenBuf, 2);
0037: }
0038:
0039: protected JavaTreeRecognizer(TokenStream lexer, int k) {
0040: super (lexer, k);
0041: tokenNames = _tokenNames;
0042: buildTokenTypeASTClassMap();
0043: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0044: }
0045:
0046: public JavaTreeRecognizer(TokenStream lexer) {
0047: this (lexer, 2);
0048: }
0049:
0050: public JavaTreeRecognizer(ParserSharedInputState state) {
0051: super (state, 2);
0052: tokenNames = _tokenNames;
0053: buildTokenTypeASTClassMap();
0054: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0055: }
0056:
0057: public final void compilationUnit() throws RecognitionException,
0058: TokenStreamException {
0059:
0060: returnAST = null;
0061: ASTPair currentAST = new ASTPair();
0062: AST compilationUnit_AST = null;
0063:
0064: {
0065: switch (LA(1)) {
0066: case LITERAL_package: {
0067: packageDefinition();
0068: astFactory.addASTChild(currentAST, returnAST);
0069: break;
0070: }
0071: case EOF:
0072: case FINAL:
0073: case ABSTRACT:
0074: case STRICTFP:
0075: case SEMI:
0076: case LITERAL_import:
0077: case LITERAL_private:
0078: case LITERAL_public:
0079: case LITERAL_protected:
0080: case LITERAL_static:
0081: case LITERAL_transient:
0082: case LITERAL_native:
0083: case LITERAL_threadsafe:
0084: case LITERAL_synchronized:
0085: case LITERAL_volatile:
0086: case LITERAL_class:
0087: case LITERAL_interface: {
0088: break;
0089: }
0090: default: {
0091: throw new NoViableAltException(LT(1), getFilename());
0092: }
0093: }
0094: }
0095: {
0096: _loop4: do {
0097: if ((LA(1) == LITERAL_import)) {
0098: importDefinition();
0099: astFactory.addASTChild(currentAST, returnAST);
0100: } else {
0101: break _loop4;
0102: }
0103:
0104: } while (true);
0105: }
0106: {
0107: _loop6: do {
0108: if ((_tokenSet_0.member(LA(1)))) {
0109: typeDefinition();
0110: astFactory.addASTChild(currentAST, returnAST);
0111: } else {
0112: break _loop6;
0113: }
0114:
0115: } while (true);
0116: }
0117: match(Token.EOF_TYPE);
0118: compilationUnit_AST = (AST) currentAST.root;
0119: returnAST = compilationUnit_AST;
0120: }
0121:
0122: public final void packageDefinition() throws RecognitionException,
0123: TokenStreamException {
0124:
0125: returnAST = null;
0126: ASTPair currentAST = new ASTPair();
0127: AST packageDefinition_AST = null;
0128: Token p = null;
0129: AST p_AST = null;
0130:
0131: try { // for error handling
0132: p = LT(1);
0133: p_AST = astFactory.create(p);
0134: astFactory.makeASTRoot(currentAST, p_AST);
0135: match(LITERAL_package);
0136: if (inputState.guessing == 0) {
0137: p_AST.setType(PACKAGE_DEF);
0138: }
0139: identifier();
0140: astFactory.addASTChild(currentAST, returnAST);
0141: match(SEMI);
0142: packageDefinition_AST = (AST) currentAST.root;
0143: } catch (RecognitionException ex) {
0144: if (inputState.guessing == 0) {
0145: reportError(ex);
0146: recover(ex, _tokenSet_1);
0147: } else {
0148: throw ex;
0149: }
0150: }
0151: returnAST = packageDefinition_AST;
0152: }
0153:
0154: public final void importDefinition() throws RecognitionException,
0155: TokenStreamException {
0156:
0157: returnAST = null;
0158: ASTPair currentAST = new ASTPair();
0159: AST importDefinition_AST = null;
0160: Token i = null;
0161: AST i_AST = null;
0162:
0163: try { // for error handling
0164: i = LT(1);
0165: i_AST = astFactory.create(i);
0166: astFactory.makeASTRoot(currentAST, i_AST);
0167: match(LITERAL_import);
0168: if (inputState.guessing == 0) {
0169: i_AST.setType(IMPORT);
0170: }
0171: identifierStar();
0172: astFactory.addASTChild(currentAST, returnAST);
0173: match(SEMI);
0174: importDefinition_AST = (AST) currentAST.root;
0175: } catch (RecognitionException ex) {
0176: if (inputState.guessing == 0) {
0177: reportError(ex);
0178: recover(ex, _tokenSet_1);
0179: } else {
0180: throw ex;
0181: }
0182: }
0183: returnAST = importDefinition_AST;
0184: }
0185:
0186: public final void typeDefinition() throws RecognitionException,
0187: TokenStreamException {
0188:
0189: returnAST = null;
0190: ASTPair currentAST = new ASTPair();
0191: AST typeDefinition_AST = null;
0192: AST m_AST = null;
0193:
0194: try { // for error handling
0195: switch (LA(1)) {
0196: case FINAL:
0197: case ABSTRACT:
0198: case STRICTFP:
0199: case LITERAL_private:
0200: case LITERAL_public:
0201: case LITERAL_protected:
0202: case LITERAL_static:
0203: case LITERAL_transient:
0204: case LITERAL_native:
0205: case LITERAL_threadsafe:
0206: case LITERAL_synchronized:
0207: case LITERAL_volatile:
0208: case LITERAL_class:
0209: case LITERAL_interface: {
0210: modifiers();
0211: m_AST = (AST) returnAST;
0212: {
0213: switch (LA(1)) {
0214: case LITERAL_class: {
0215: classDefinition(m_AST);
0216: astFactory.addASTChild(currentAST, returnAST);
0217: break;
0218: }
0219: case LITERAL_interface: {
0220: interfaceDefinition(m_AST);
0221: astFactory.addASTChild(currentAST, returnAST);
0222: break;
0223: }
0224: default: {
0225: throw new NoViableAltException(LT(1),
0226: getFilename());
0227: }
0228: }
0229: }
0230: typeDefinition_AST = (AST) currentAST.root;
0231: break;
0232: }
0233: case SEMI: {
0234: match(SEMI);
0235: typeDefinition_AST = (AST) currentAST.root;
0236: break;
0237: }
0238: default: {
0239: throw new NoViableAltException(LT(1), getFilename());
0240: }
0241: }
0242: } catch (RecognitionException ex) {
0243: if (inputState.guessing == 0) {
0244: reportError(ex);
0245: recover(ex, _tokenSet_2);
0246: } else {
0247: throw ex;
0248: }
0249: }
0250: returnAST = typeDefinition_AST;
0251: }
0252:
0253: public final void identifier() throws RecognitionException,
0254: TokenStreamException {
0255:
0256: returnAST = null;
0257: ASTPair currentAST = new ASTPair();
0258: AST identifier_AST = null;
0259:
0260: AST tmp5_AST = null;
0261: tmp5_AST = astFactory.create(LT(1));
0262: astFactory.addASTChild(currentAST, tmp5_AST);
0263: match(IDENT);
0264: {
0265: _loop23: do {
0266: if ((LA(1) == DOT)) {
0267: AST tmp6_AST = null;
0268: tmp6_AST = astFactory.create(LT(1));
0269: astFactory.makeASTRoot(currentAST, tmp6_AST);
0270: match(DOT);
0271: AST tmp7_AST = null;
0272: tmp7_AST = astFactory.create(LT(1));
0273: astFactory.addASTChild(currentAST, tmp7_AST);
0274: match(IDENT);
0275: } else {
0276: break _loop23;
0277: }
0278:
0279: } while (true);
0280: }
0281: identifier_AST = (AST) currentAST.root;
0282: returnAST = identifier_AST;
0283: }
0284:
0285: public final void identifierStar() throws RecognitionException,
0286: TokenStreamException {
0287:
0288: returnAST = null;
0289: ASTPair currentAST = new ASTPair();
0290: AST identifierStar_AST = null;
0291:
0292: AST tmp8_AST = null;
0293: tmp8_AST = astFactory.create(LT(1));
0294: astFactory.addASTChild(currentAST, tmp8_AST);
0295: match(IDENT);
0296: {
0297: _loop26: do {
0298: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
0299: AST tmp9_AST = null;
0300: tmp9_AST = astFactory.create(LT(1));
0301: astFactory.makeASTRoot(currentAST, tmp9_AST);
0302: match(DOT);
0303: AST tmp10_AST = null;
0304: tmp10_AST = astFactory.create(LT(1));
0305: astFactory.addASTChild(currentAST, tmp10_AST);
0306: match(IDENT);
0307: } else {
0308: break _loop26;
0309: }
0310:
0311: } while (true);
0312: }
0313: {
0314: switch (LA(1)) {
0315: case DOT: {
0316: AST tmp11_AST = null;
0317: tmp11_AST = astFactory.create(LT(1));
0318: astFactory.makeASTRoot(currentAST, tmp11_AST);
0319: match(DOT);
0320: AST tmp12_AST = null;
0321: tmp12_AST = astFactory.create(LT(1));
0322: astFactory.addASTChild(currentAST, tmp12_AST);
0323: match(STAR);
0324: break;
0325: }
0326: case SEMI: {
0327: break;
0328: }
0329: default: {
0330: throw new NoViableAltException(LT(1), getFilename());
0331: }
0332: }
0333: }
0334: identifierStar_AST = (AST) currentAST.root;
0335: returnAST = identifierStar_AST;
0336: }
0337:
0338: public final void modifiers() throws RecognitionException,
0339: TokenStreamException {
0340:
0341: returnAST = null;
0342: ASTPair currentAST = new ASTPair();
0343: AST modifiers_AST = null;
0344:
0345: {
0346: _loop30: do {
0347: if ((_tokenSet_3.member(LA(1)))) {
0348: modifier();
0349: astFactory.addASTChild(currentAST, returnAST);
0350: } else {
0351: break _loop30;
0352: }
0353:
0354: } while (true);
0355: }
0356: if (inputState.guessing == 0) {
0357: modifiers_AST = (AST) currentAST.root;
0358: modifiers_AST = (AST) astFactory.make((new ASTArray(2))
0359: .add(astFactory.create(MODIFIERS, "MODIFIERS"))
0360: .add(modifiers_AST));
0361: currentAST.root = modifiers_AST;
0362: currentAST.child = modifiers_AST != null
0363: && modifiers_AST.getFirstChild() != null ? modifiers_AST
0364: .getFirstChild()
0365: : modifiers_AST;
0366: currentAST.advanceChildToEnd();
0367: }
0368: modifiers_AST = (AST) currentAST.root;
0369: returnAST = modifiers_AST;
0370: }
0371:
0372: public final void classDefinition(AST modifiers)
0373: throws RecognitionException, TokenStreamException {
0374:
0375: returnAST = null;
0376: ASTPair currentAST = new ASTPair();
0377: AST classDefinition_AST = null;
0378: AST sc_AST = null;
0379: AST ic_AST = null;
0380: AST cb_AST = null;
0381:
0382: match(LITERAL_class);
0383: AST tmp14_AST = null;
0384: tmp14_AST = astFactory.create(LT(1));
0385: match(IDENT);
0386: super ClassClause();
0387: sc_AST = (AST) returnAST;
0388: implements Clause();
0389: ic_AST = (AST) returnAST;
0390: classBlock();
0391: cb_AST = (AST) returnAST;
0392: if (inputState.guessing == 0) {
0393: classDefinition_AST = (AST) currentAST.root;
0394: classDefinition_AST = (AST) astFactory
0395: .make((new ASTArray(6)).add(
0396: astFactory.create(CLASS_DEF, "CLASS_DEF"))
0397: .add(modifiers).add(tmp14_AST).add(sc_AST)
0398: .add(ic_AST).add(cb_AST));
0399: currentAST.root = classDefinition_AST;
0400: currentAST.child = classDefinition_AST != null
0401: && classDefinition_AST.getFirstChild() != null ? classDefinition_AST
0402: .getFirstChild()
0403: : classDefinition_AST;
0404: currentAST.advanceChildToEnd();
0405: }
0406: returnAST = classDefinition_AST;
0407: }
0408:
0409: public final void interfaceDefinition(AST modifiers)
0410: throws RecognitionException, TokenStreamException {
0411:
0412: returnAST = null;
0413: ASTPair currentAST = new ASTPair();
0414: AST interfaceDefinition_AST = null;
0415: AST ie_AST = null;
0416: AST cb_AST = null;
0417:
0418: match(LITERAL_interface);
0419: AST tmp16_AST = null;
0420: tmp16_AST = astFactory.create(LT(1));
0421: match(IDENT);
0422: interfaceExtends();
0423: ie_AST = (AST) returnAST;
0424: classBlock();
0425: cb_AST = (AST) returnAST;
0426: if (inputState.guessing == 0) {
0427: interfaceDefinition_AST = (AST) currentAST.root;
0428: interfaceDefinition_AST = (AST) astFactory
0429: .make((new ASTArray(5)).add(
0430: astFactory.create(INTERFACE_DEF,
0431: "INTERFACE_DEF")).add(modifiers)
0432: .add(tmp16_AST).add(ie_AST).add(cb_AST));
0433: currentAST.root = interfaceDefinition_AST;
0434: currentAST.child = interfaceDefinition_AST != null
0435: && interfaceDefinition_AST.getFirstChild() != null ? interfaceDefinition_AST
0436: .getFirstChild()
0437: : interfaceDefinition_AST;
0438: currentAST.advanceChildToEnd();
0439: }
0440: returnAST = interfaceDefinition_AST;
0441: }
0442:
0443: /** A declaration is the creation of a reference or primitive-type variable
0444: * Create a separate Type/Var tree for each var in the var list.
0445: */
0446: public final void declaration() throws RecognitionException,
0447: TokenStreamException {
0448:
0449: returnAST = null;
0450: ASTPair currentAST = new ASTPair();
0451: AST declaration_AST = null;
0452: AST m_AST = null;
0453: AST t_AST = null;
0454: AST v_AST = null;
0455:
0456: modifiers();
0457: m_AST = (AST) returnAST;
0458: typeSpec(false);
0459: t_AST = (AST) returnAST;
0460: variableDefinitions(m_AST, t_AST);
0461: v_AST = (AST) returnAST;
0462: if (inputState.guessing == 0) {
0463: declaration_AST = (AST) currentAST.root;
0464: declaration_AST = v_AST;
0465: currentAST.root = declaration_AST;
0466: currentAST.child = declaration_AST != null
0467: && declaration_AST.getFirstChild() != null ? declaration_AST
0468: .getFirstChild()
0469: : declaration_AST;
0470: currentAST.advanceChildToEnd();
0471: }
0472: returnAST = declaration_AST;
0473: }
0474:
0475: public final void typeSpec(boolean addImagNode)
0476: throws RecognitionException, TokenStreamException {
0477:
0478: returnAST = null;
0479: ASTPair currentAST = new ASTPair();
0480: AST typeSpec_AST = null;
0481:
0482: switch (LA(1)) {
0483: case IDENT: {
0484: classTypeSpec(addImagNode);
0485: astFactory.addASTChild(currentAST, returnAST);
0486: typeSpec_AST = (AST) currentAST.root;
0487: break;
0488: }
0489: case LITERAL_void:
0490: case LITERAL_boolean:
0491: case LITERAL_byte:
0492: case LITERAL_char:
0493: case LITERAL_short:
0494: case LITERAL_int:
0495: case LITERAL_float:
0496: case LITERAL_long:
0497: case LITERAL_double: {
0498: builtInTypeSpec(addImagNode);
0499: astFactory.addASTChild(currentAST, returnAST);
0500: typeSpec_AST = (AST) currentAST.root;
0501: break;
0502: }
0503: default: {
0504: throw new NoViableAltException(LT(1), getFilename());
0505: }
0506: }
0507: returnAST = typeSpec_AST;
0508: }
0509:
0510: public final void variableDefinitions(AST mods, AST t)
0511: throws RecognitionException, TokenStreamException {
0512:
0513: returnAST = null;
0514: ASTPair currentAST = new ASTPair();
0515: AST variableDefinitions_AST = null;
0516:
0517: variableDeclarator(getASTFactory().dupTree(mods),
0518: getASTFactory().dupTree(t));
0519: astFactory.addASTChild(currentAST, returnAST);
0520: {
0521: _loop59: do {
0522: if ((LA(1) == COMMA)) {
0523: match(COMMA);
0524: variableDeclarator(getASTFactory().dupTree(mods),
0525: getASTFactory().dupTree(t));
0526: astFactory.addASTChild(currentAST, returnAST);
0527: } else {
0528: break _loop59;
0529: }
0530:
0531: } while (true);
0532: }
0533: variableDefinitions_AST = (AST) currentAST.root;
0534: returnAST = variableDefinitions_AST;
0535: }
0536:
0537: public final void classTypeSpec(boolean addImagNode)
0538: throws RecognitionException, TokenStreamException {
0539:
0540: returnAST = null;
0541: ASTPair currentAST = new ASTPair();
0542: AST classTypeSpec_AST = null;
0543: Token lb = null;
0544: AST lb_AST = null;
0545:
0546: identifier();
0547: astFactory.addASTChild(currentAST, returnAST);
0548: {
0549: _loop15: do {
0550: if ((LA(1) == LBRACK)) {
0551: lb = LT(1);
0552: lb_AST = astFactory.create(lb);
0553: astFactory.makeASTRoot(currentAST, lb_AST);
0554: match(LBRACK);
0555: if (inputState.guessing == 0) {
0556: lb_AST.setType(ARRAY_DECLARATOR);
0557: }
0558: match(RBRACK);
0559: } else {
0560: break _loop15;
0561: }
0562:
0563: } while (true);
0564: }
0565: if (inputState.guessing == 0) {
0566: classTypeSpec_AST = (AST) currentAST.root;
0567:
0568: if (addImagNode) {
0569: classTypeSpec_AST = (AST) astFactory
0570: .make((new ASTArray(2)).add(
0571: astFactory.create(TYPE, "TYPE")).add(
0572: classTypeSpec_AST));
0573: }
0574:
0575: currentAST.root = classTypeSpec_AST;
0576: currentAST.child = classTypeSpec_AST != null
0577: && classTypeSpec_AST.getFirstChild() != null ? classTypeSpec_AST
0578: .getFirstChild()
0579: : classTypeSpec_AST;
0580: currentAST.advanceChildToEnd();
0581: }
0582: classTypeSpec_AST = (AST) currentAST.root;
0583: returnAST = classTypeSpec_AST;
0584: }
0585:
0586: public final void builtInTypeSpec(boolean addImagNode)
0587: throws RecognitionException, TokenStreamException {
0588:
0589: returnAST = null;
0590: ASTPair currentAST = new ASTPair();
0591: AST builtInTypeSpec_AST = null;
0592: Token lb = null;
0593: AST lb_AST = null;
0594:
0595: builtInType();
0596: astFactory.addASTChild(currentAST, returnAST);
0597: {
0598: _loop18: do {
0599: if ((LA(1) == LBRACK)) {
0600: lb = LT(1);
0601: lb_AST = astFactory.create(lb);
0602: astFactory.makeASTRoot(currentAST, lb_AST);
0603: match(LBRACK);
0604: if (inputState.guessing == 0) {
0605: lb_AST.setType(ARRAY_DECLARATOR);
0606: }
0607: match(RBRACK);
0608: } else {
0609: break _loop18;
0610: }
0611:
0612: } while (true);
0613: }
0614: if (inputState.guessing == 0) {
0615: builtInTypeSpec_AST = (AST) currentAST.root;
0616:
0617: if (addImagNode) {
0618: builtInTypeSpec_AST = (AST) astFactory
0619: .make((new ASTArray(2)).add(
0620: astFactory.create(TYPE, "TYPE")).add(
0621: builtInTypeSpec_AST));
0622: }
0623:
0624: currentAST.root = builtInTypeSpec_AST;
0625: currentAST.child = builtInTypeSpec_AST != null
0626: && builtInTypeSpec_AST.getFirstChild() != null ? builtInTypeSpec_AST
0627: .getFirstChild()
0628: : builtInTypeSpec_AST;
0629: currentAST.advanceChildToEnd();
0630: }
0631: builtInTypeSpec_AST = (AST) currentAST.root;
0632: returnAST = builtInTypeSpec_AST;
0633: }
0634:
0635: public final void builtInType() throws RecognitionException,
0636: TokenStreamException {
0637:
0638: returnAST = null;
0639: ASTPair currentAST = new ASTPair();
0640: AST builtInType_AST = null;
0641:
0642: switch (LA(1)) {
0643: case LITERAL_void: {
0644: AST tmp20_AST = null;
0645: tmp20_AST = astFactory.create(LT(1));
0646: astFactory.addASTChild(currentAST, tmp20_AST);
0647: match(LITERAL_void);
0648: builtInType_AST = (AST) currentAST.root;
0649: break;
0650: }
0651: case LITERAL_boolean: {
0652: AST tmp21_AST = null;
0653: tmp21_AST = astFactory.create(LT(1));
0654: astFactory.addASTChild(currentAST, tmp21_AST);
0655: match(LITERAL_boolean);
0656: builtInType_AST = (AST) currentAST.root;
0657: break;
0658: }
0659: case LITERAL_byte: {
0660: AST tmp22_AST = null;
0661: tmp22_AST = astFactory.create(LT(1));
0662: astFactory.addASTChild(currentAST, tmp22_AST);
0663: match(LITERAL_byte);
0664: builtInType_AST = (AST) currentAST.root;
0665: break;
0666: }
0667: case LITERAL_char: {
0668: AST tmp23_AST = null;
0669: tmp23_AST = astFactory.create(LT(1));
0670: astFactory.addASTChild(currentAST, tmp23_AST);
0671: match(LITERAL_char);
0672: builtInType_AST = (AST) currentAST.root;
0673: break;
0674: }
0675: case LITERAL_short: {
0676: AST tmp24_AST = null;
0677: tmp24_AST = astFactory.create(LT(1));
0678: astFactory.addASTChild(currentAST, tmp24_AST);
0679: match(LITERAL_short);
0680: builtInType_AST = (AST) currentAST.root;
0681: break;
0682: }
0683: case LITERAL_int: {
0684: AST tmp25_AST = null;
0685: tmp25_AST = astFactory.create(LT(1));
0686: astFactory.addASTChild(currentAST, tmp25_AST);
0687: match(LITERAL_int);
0688: builtInType_AST = (AST) currentAST.root;
0689: break;
0690: }
0691: case LITERAL_float: {
0692: AST tmp26_AST = null;
0693: tmp26_AST = astFactory.create(LT(1));
0694: astFactory.addASTChild(currentAST, tmp26_AST);
0695: match(LITERAL_float);
0696: builtInType_AST = (AST) currentAST.root;
0697: break;
0698: }
0699: case LITERAL_long: {
0700: AST tmp27_AST = null;
0701: tmp27_AST = astFactory.create(LT(1));
0702: astFactory.addASTChild(currentAST, tmp27_AST);
0703: match(LITERAL_long);
0704: builtInType_AST = (AST) currentAST.root;
0705: break;
0706: }
0707: case LITERAL_double: {
0708: AST tmp28_AST = null;
0709: tmp28_AST = astFactory.create(LT(1));
0710: astFactory.addASTChild(currentAST, tmp28_AST);
0711: match(LITERAL_double);
0712: builtInType_AST = (AST) currentAST.root;
0713: break;
0714: }
0715: default: {
0716: throw new NoViableAltException(LT(1), getFilename());
0717: }
0718: }
0719: returnAST = builtInType_AST;
0720: }
0721:
0722: public final void type() throws RecognitionException,
0723: TokenStreamException {
0724:
0725: returnAST = null;
0726: ASTPair currentAST = new ASTPair();
0727: AST type_AST = null;
0728:
0729: switch (LA(1)) {
0730: case IDENT: {
0731: identifier();
0732: astFactory.addASTChild(currentAST, returnAST);
0733: type_AST = (AST) currentAST.root;
0734: break;
0735: }
0736: case LITERAL_void:
0737: case LITERAL_boolean:
0738: case LITERAL_byte:
0739: case LITERAL_char:
0740: case LITERAL_short:
0741: case LITERAL_int:
0742: case LITERAL_float:
0743: case LITERAL_long:
0744: case LITERAL_double: {
0745: builtInType();
0746: astFactory.addASTChild(currentAST, returnAST);
0747: type_AST = (AST) currentAST.root;
0748: break;
0749: }
0750: default: {
0751: throw new NoViableAltException(LT(1), getFilename());
0752: }
0753: }
0754: returnAST = type_AST;
0755: }
0756:
0757: public final void modifier() throws RecognitionException,
0758: TokenStreamException {
0759:
0760: returnAST = null;
0761: ASTPair currentAST = new ASTPair();
0762: AST modifier_AST = null;
0763:
0764: switch (LA(1)) {
0765: case LITERAL_private: {
0766: AST tmp29_AST = null;
0767: tmp29_AST = astFactory.create(LT(1));
0768: astFactory.addASTChild(currentAST, tmp29_AST);
0769: match(LITERAL_private);
0770: modifier_AST = (AST) currentAST.root;
0771: break;
0772: }
0773: case LITERAL_public: {
0774: AST tmp30_AST = null;
0775: tmp30_AST = astFactory.create(LT(1));
0776: astFactory.addASTChild(currentAST, tmp30_AST);
0777: match(LITERAL_public);
0778: modifier_AST = (AST) currentAST.root;
0779: break;
0780: }
0781: case LITERAL_protected: {
0782: AST tmp31_AST = null;
0783: tmp31_AST = astFactory.create(LT(1));
0784: astFactory.addASTChild(currentAST, tmp31_AST);
0785: match(LITERAL_protected);
0786: modifier_AST = (AST) currentAST.root;
0787: break;
0788: }
0789: case LITERAL_static: {
0790: AST tmp32_AST = null;
0791: tmp32_AST = astFactory.create(LT(1));
0792: astFactory.addASTChild(currentAST, tmp32_AST);
0793: match(LITERAL_static);
0794: modifier_AST = (AST) currentAST.root;
0795: break;
0796: }
0797: case LITERAL_transient: {
0798: AST tmp33_AST = null;
0799: tmp33_AST = astFactory.create(LT(1));
0800: astFactory.addASTChild(currentAST, tmp33_AST);
0801: match(LITERAL_transient);
0802: modifier_AST = (AST) currentAST.root;
0803: break;
0804: }
0805: case FINAL: {
0806: AST tmp34_AST = null;
0807: tmp34_AST = astFactory.create(LT(1));
0808: astFactory.addASTChild(currentAST, tmp34_AST);
0809: match(FINAL);
0810: modifier_AST = (AST) currentAST.root;
0811: break;
0812: }
0813: case ABSTRACT: {
0814: AST tmp35_AST = null;
0815: tmp35_AST = astFactory.create(LT(1));
0816: astFactory.addASTChild(currentAST, tmp35_AST);
0817: match(ABSTRACT);
0818: modifier_AST = (AST) currentAST.root;
0819: break;
0820: }
0821: case LITERAL_native: {
0822: AST tmp36_AST = null;
0823: tmp36_AST = astFactory.create(LT(1));
0824: astFactory.addASTChild(currentAST, tmp36_AST);
0825: match(LITERAL_native);
0826: modifier_AST = (AST) currentAST.root;
0827: break;
0828: }
0829: case LITERAL_threadsafe: {
0830: AST tmp37_AST = null;
0831: tmp37_AST = astFactory.create(LT(1));
0832: astFactory.addASTChild(currentAST, tmp37_AST);
0833: match(LITERAL_threadsafe);
0834: modifier_AST = (AST) currentAST.root;
0835: break;
0836: }
0837: case LITERAL_synchronized: {
0838: AST tmp38_AST = null;
0839: tmp38_AST = astFactory.create(LT(1));
0840: astFactory.addASTChild(currentAST, tmp38_AST);
0841: match(LITERAL_synchronized);
0842: modifier_AST = (AST) currentAST.root;
0843: break;
0844: }
0845: case LITERAL_volatile: {
0846: AST tmp39_AST = null;
0847: tmp39_AST = astFactory.create(LT(1));
0848: astFactory.addASTChild(currentAST, tmp39_AST);
0849: match(LITERAL_volatile);
0850: modifier_AST = (AST) currentAST.root;
0851: break;
0852: }
0853: case STRICTFP: {
0854: AST tmp40_AST = null;
0855: tmp40_AST = astFactory.create(LT(1));
0856: astFactory.addASTChild(currentAST, tmp40_AST);
0857: match(STRICTFP);
0858: modifier_AST = (AST) currentAST.root;
0859: break;
0860: }
0861: default: {
0862: throw new NoViableAltException(LT(1), getFilename());
0863: }
0864: }
0865: returnAST = modifier_AST;
0866: }
0867:
0868: public final void super ClassClause() throws RecognitionException,
0869: TokenStreamException {
0870:
0871: returnAST = null;
0872: ASTPair currentAST = new ASTPair();
0873: AST super ClassClause_AST = null;
0874: AST id_AST = null;
0875:
0876: {
0877: switch (LA(1)) {
0878: case LITERAL_extends: {
0879: match(LITERAL_extends);
0880: identifier();
0881: id_AST = (AST) returnAST;
0882: break;
0883: }
0884: case LCURLY:
0885: case LITERAL_implements : {
0886: break;
0887: }
0888: default: {
0889: throw new NoViableAltException(LT(1), getFilename());
0890: }
0891: }
0892: }
0893: if (inputState.guessing == 0) {
0894: super ClassClause_AST = (AST) currentAST.root;
0895: super ClassClause_AST = (AST) astFactory.make((new ASTArray(
0896: 2))
0897: .add(
0898: astFactory.create(EXTENDS_CLAUSE,
0899: "EXTENDS_CLAUSE")).add(id_AST));
0900: currentAST.root = super ClassClause_AST;
0901: currentAST.child = super ClassClause_AST != null
0902: && super ClassClause_AST.getFirstChild() != null ? super ClassClause_AST
0903: .getFirstChild()
0904: : super ClassClause_AST;
0905: currentAST.advanceChildToEnd();
0906: }
0907: returnAST = super ClassClause_AST;
0908: }
0909:
0910: public final void implements Clause() throws RecognitionException,
0911: TokenStreamException {
0912:
0913: returnAST = null;
0914: ASTPair currentAST = new ASTPair();
0915: AST implements Clause_AST = null;
0916: Token i = null;
0917: AST i_AST = null;
0918:
0919: {
0920: switch (LA(1)) {
0921: case LITERAL_implements : {
0922: i = LT(1);
0923: i_AST = astFactory.create(i);
0924: match(LITERAL_implements );
0925: identifier();
0926: astFactory.addASTChild(currentAST, returnAST);
0927: {
0928: _loop46: do {
0929: if ((LA(1) == COMMA)) {
0930: match(COMMA);
0931: identifier();
0932: astFactory.addASTChild(currentAST,
0933: returnAST);
0934: } else {
0935: break _loop46;
0936: }
0937:
0938: } while (true);
0939: }
0940: break;
0941: }
0942: case LCURLY: {
0943: break;
0944: }
0945: default: {
0946: throw new NoViableAltException(LT(1), getFilename());
0947: }
0948: }
0949: }
0950: if (inputState.guessing == 0) {
0951: implements Clause_AST = (AST) currentAST.root;
0952: implements Clause_AST = (AST) astFactory.make((new ASTArray(
0953: 2)).add(
0954: astFactory.create(IMPLEMENTS_CLAUSE,
0955: "IMPLEMENTS_CLAUSE")).add(
0956: implements Clause_AST));
0957: currentAST.root = implements Clause_AST;
0958: currentAST.child = implements Clause_AST != null
0959: && implements Clause_AST.getFirstChild() != null ? implements Clause_AST
0960: .getFirstChild()
0961: : implements Clause_AST;
0962: currentAST.advanceChildToEnd();
0963: }
0964: implements Clause_AST = (AST) currentAST.root;
0965: returnAST = implements Clause_AST;
0966: }
0967:
0968: public final void classBlock() throws RecognitionException,
0969: TokenStreamException {
0970:
0971: returnAST = null;
0972: ASTPair currentAST = new ASTPair();
0973: AST classBlock_AST = null;
0974:
0975: match(LCURLY);
0976: {
0977: _loop38: do {
0978: switch (LA(1)) {
0979: case FINAL:
0980: case ABSTRACT:
0981: case STRICTFP:
0982: case LITERAL_void:
0983: case LITERAL_boolean:
0984: case LITERAL_byte:
0985: case LITERAL_char:
0986: case LITERAL_short:
0987: case LITERAL_int:
0988: case LITERAL_float:
0989: case LITERAL_long:
0990: case LITERAL_double:
0991: case IDENT:
0992: case LITERAL_private:
0993: case LITERAL_public:
0994: case LITERAL_protected:
0995: case LITERAL_static:
0996: case LITERAL_transient:
0997: case LITERAL_native:
0998: case LITERAL_threadsafe:
0999: case LITERAL_synchronized:
1000: case LITERAL_volatile:
1001: case LITERAL_class:
1002: case LITERAL_interface:
1003: case LCURLY: {
1004: field();
1005: astFactory.addASTChild(currentAST, returnAST);
1006: break;
1007: }
1008: case SEMI: {
1009: match(SEMI);
1010: break;
1011: }
1012: default: {
1013: break _loop38;
1014: }
1015: }
1016: } while (true);
1017: }
1018: match(RCURLY);
1019: if (inputState.guessing == 0) {
1020: classBlock_AST = (AST) currentAST.root;
1021: classBlock_AST = (AST) astFactory.make((new ASTArray(2))
1022: .add(astFactory.create(OBJBLOCK, "OBJBLOCK")).add(
1023: classBlock_AST));
1024: currentAST.root = classBlock_AST;
1025: currentAST.child = classBlock_AST != null
1026: && classBlock_AST.getFirstChild() != null ? classBlock_AST
1027: .getFirstChild()
1028: : classBlock_AST;
1029: currentAST.advanceChildToEnd();
1030: }
1031: classBlock_AST = (AST) currentAST.root;
1032: returnAST = classBlock_AST;
1033: }
1034:
1035: public final void interfaceExtends() throws RecognitionException,
1036: TokenStreamException {
1037:
1038: returnAST = null;
1039: ASTPair currentAST = new ASTPair();
1040: AST interfaceExtends_AST = null;
1041: Token e = null;
1042: AST e_AST = null;
1043:
1044: {
1045: switch (LA(1)) {
1046: case LITERAL_extends: {
1047: e = LT(1);
1048: e_AST = astFactory.create(e);
1049: match(LITERAL_extends);
1050: identifier();
1051: astFactory.addASTChild(currentAST, returnAST);
1052: {
1053: _loop42: do {
1054: if ((LA(1) == COMMA)) {
1055: match(COMMA);
1056: identifier();
1057: astFactory.addASTChild(currentAST,
1058: returnAST);
1059: } else {
1060: break _loop42;
1061: }
1062:
1063: } while (true);
1064: }
1065: break;
1066: }
1067: case LCURLY: {
1068: break;
1069: }
1070: default: {
1071: throw new NoViableAltException(LT(1), getFilename());
1072: }
1073: }
1074: }
1075: if (inputState.guessing == 0) {
1076: interfaceExtends_AST = (AST) currentAST.root;
1077: interfaceExtends_AST = (AST) astFactory.make((new ASTArray(
1078: 2))
1079: .add(
1080: astFactory.create(EXTENDS_CLAUSE,
1081: "EXTENDS_CLAUSE")).add(
1082: interfaceExtends_AST));
1083: currentAST.root = interfaceExtends_AST;
1084: currentAST.child = interfaceExtends_AST != null
1085: && interfaceExtends_AST.getFirstChild() != null ? interfaceExtends_AST
1086: .getFirstChild()
1087: : interfaceExtends_AST;
1088: currentAST.advanceChildToEnd();
1089: }
1090: interfaceExtends_AST = (AST) currentAST.root;
1091: returnAST = interfaceExtends_AST;
1092: }
1093:
1094: public final void field() throws RecognitionException,
1095: TokenStreamException {
1096:
1097: returnAST = null;
1098: ASTPair currentAST = new ASTPair();
1099: AST field_AST = null;
1100: AST mods_AST = null;
1101: AST h_AST = null;
1102: AST s_AST = null;
1103: AST cd_AST = null;
1104: AST id_AST = null;
1105: AST t_AST = null;
1106: AST param_AST = null;
1107: AST rt_AST = null;
1108: AST tc_AST = null;
1109: AST s2_AST = null;
1110: AST v_AST = null;
1111: AST s3_AST = null;
1112: AST s4_AST = null;
1113:
1114: if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
1115: modifiers();
1116: mods_AST = (AST) returnAST;
1117: {
1118: switch (LA(1)) {
1119: case LITERAL_class: {
1120: classDefinition(mods_AST);
1121: cd_AST = (AST) returnAST;
1122: if (inputState.guessing == 0) {
1123: field_AST = (AST) currentAST.root;
1124: field_AST = cd_AST;
1125: currentAST.root = field_AST;
1126: currentAST.child = field_AST != null
1127: && field_AST.getFirstChild() != null ? field_AST
1128: .getFirstChild()
1129: : field_AST;
1130: currentAST.advanceChildToEnd();
1131: }
1132: break;
1133: }
1134: case LITERAL_interface: {
1135: interfaceDefinition(mods_AST);
1136: id_AST = (AST) returnAST;
1137: if (inputState.guessing == 0) {
1138: field_AST = (AST) currentAST.root;
1139: field_AST = id_AST;
1140: currentAST.root = field_AST;
1141: currentAST.child = field_AST != null
1142: && field_AST.getFirstChild() != null ? field_AST
1143: .getFirstChild()
1144: : field_AST;
1145: currentAST.advanceChildToEnd();
1146: }
1147: break;
1148: }
1149: default:
1150: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
1151: ctorHead();
1152: h_AST = (AST) returnAST;
1153: constructorBody();
1154: s_AST = (AST) returnAST;
1155: if (inputState.guessing == 0) {
1156: field_AST = (AST) currentAST.root;
1157: field_AST = (AST) astFactory
1158: .make((new ASTArray(4)).add(
1159: astFactory.create(CTOR_DEF,
1160: "CTOR_DEF")).add(
1161: mods_AST).add(h_AST).add(
1162: s_AST));
1163: currentAST.root = field_AST;
1164: currentAST.child = field_AST != null
1165: && field_AST.getFirstChild() != null ? field_AST
1166: .getFirstChild()
1167: : field_AST;
1168: currentAST.advanceChildToEnd();
1169: }
1170: } else if (((LA(1) >= LITERAL_void && LA(1) <= IDENT))
1171: && (_tokenSet_6.member(LA(2)))) {
1172: typeSpec(false);
1173: t_AST = (AST) returnAST;
1174: {
1175: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
1176: AST tmp47_AST = null;
1177: tmp47_AST = astFactory.create(LT(1));
1178: match(IDENT);
1179: match(LPAREN);
1180: parameterDeclarationList();
1181: param_AST = (AST) returnAST;
1182: match(RPAREN);
1183: declaratorBrackets(t_AST);
1184: rt_AST = (AST) returnAST;
1185: {
1186: switch (LA(1)) {
1187: case LITERAL_throws: {
1188: throwsClause();
1189: tc_AST = (AST) returnAST;
1190: break;
1191: }
1192: case SEMI:
1193: case LCURLY: {
1194: break;
1195: }
1196: default: {
1197: throw new NoViableAltException(
1198: LT(1), getFilename());
1199: }
1200: }
1201: }
1202: {
1203: switch (LA(1)) {
1204: case LCURLY: {
1205: compoundStatement();
1206: s2_AST = (AST) returnAST;
1207: break;
1208: }
1209: case SEMI: {
1210: AST tmp50_AST = null;
1211: tmp50_AST = astFactory
1212: .create(LT(1));
1213: match(SEMI);
1214: break;
1215: }
1216: default: {
1217: throw new NoViableAltException(
1218: LT(1), getFilename());
1219: }
1220: }
1221: }
1222: if (inputState.guessing == 0) {
1223: field_AST = (AST) currentAST.root;
1224: field_AST = (AST) astFactory
1225: .make((new ASTArray(7))
1226: .add(
1227: astFactory
1228: .create(
1229: METHOD_DEF,
1230: "METHOD_DEF"))
1231: .add(mods_AST)
1232: .add(
1233: (AST) astFactory
1234: .make((new ASTArray(
1235: 2))
1236: .add(
1237: astFactory
1238: .create(
1239: TYPE,
1240: "TYPE"))
1241: .add(
1242: rt_AST)))
1243: .add(tmp47_AST)
1244: .add(param_AST)
1245: .add(tc_AST).add(
1246: s2_AST));
1247: currentAST.root = field_AST;
1248: currentAST.child = field_AST != null
1249: && field_AST
1250: .getFirstChild() != null ? field_AST
1251: .getFirstChild()
1252: : field_AST;
1253: currentAST.advanceChildToEnd();
1254: }
1255: } else if ((LA(1) == IDENT)
1256: && (_tokenSet_7.member(LA(2)))) {
1257: variableDefinitions(mods_AST, t_AST);
1258: v_AST = (AST) returnAST;
1259: AST tmp51_AST = null;
1260: tmp51_AST = astFactory.create(LT(1));
1261: match(SEMI);
1262: if (inputState.guessing == 0) {
1263: field_AST = (AST) currentAST.root;
1264: field_AST = v_AST;
1265: currentAST.root = field_AST;
1266: currentAST.child = field_AST != null
1267: && field_AST
1268: .getFirstChild() != null ? field_AST
1269: .getFirstChild()
1270: : field_AST;
1271: currentAST.advanceChildToEnd();
1272: }
1273: } else {
1274: throw new NoViableAltException(LT(1),
1275: getFilename());
1276: }
1277:
1278: }
1279: } else {
1280: throw new NoViableAltException(LT(1),
1281: getFilename());
1282: }
1283: }
1284: }
1285: } else if ((LA(1) == LITERAL_static) && (LA(2) == LCURLY)) {
1286: match(LITERAL_static);
1287: compoundStatement();
1288: s3_AST = (AST) returnAST;
1289: if (inputState.guessing == 0) {
1290: field_AST = (AST) currentAST.root;
1291: field_AST = (AST) astFactory.make((new ASTArray(2))
1292: .add(
1293: astFactory.create(STATIC_INIT,
1294: "STATIC_INIT")).add(s3_AST));
1295: currentAST.root = field_AST;
1296: currentAST.child = field_AST != null
1297: && field_AST.getFirstChild() != null ? field_AST
1298: .getFirstChild()
1299: : field_AST;
1300: currentAST.advanceChildToEnd();
1301: }
1302: } else if ((LA(1) == LCURLY)) {
1303: compoundStatement();
1304: s4_AST = (AST) returnAST;
1305: if (inputState.guessing == 0) {
1306: field_AST = (AST) currentAST.root;
1307: field_AST = (AST) astFactory.make((new ASTArray(2))
1308: .add(
1309: astFactory.create(INSTANCE_INIT,
1310: "INSTANCE_INIT")).add(s4_AST));
1311: currentAST.root = field_AST;
1312: currentAST.child = field_AST != null
1313: && field_AST.getFirstChild() != null ? field_AST
1314: .getFirstChild()
1315: : field_AST;
1316: currentAST.advanceChildToEnd();
1317: }
1318: } else {
1319: throw new NoViableAltException(LT(1), getFilename());
1320: }
1321:
1322: returnAST = field_AST;
1323: }
1324:
1325: public final void ctorHead() throws RecognitionException,
1326: TokenStreamException {
1327:
1328: returnAST = null;
1329: ASTPair currentAST = new ASTPair();
1330: AST ctorHead_AST = null;
1331:
1332: AST tmp53_AST = null;
1333: tmp53_AST = astFactory.create(LT(1));
1334: astFactory.addASTChild(currentAST, tmp53_AST);
1335: match(IDENT);
1336: match(LPAREN);
1337: parameterDeclarationList();
1338: astFactory.addASTChild(currentAST, returnAST);
1339: match(RPAREN);
1340: {
1341: switch (LA(1)) {
1342: case LITERAL_throws: {
1343: throwsClause();
1344: astFactory.addASTChild(currentAST, returnAST);
1345: break;
1346: }
1347: case LCURLY: {
1348: break;
1349: }
1350: default: {
1351: throw new NoViableAltException(LT(1), getFilename());
1352: }
1353: }
1354: }
1355: ctorHead_AST = (AST) currentAST.root;
1356: returnAST = ctorHead_AST;
1357: }
1358:
1359: public final void constructorBody() throws RecognitionException,
1360: TokenStreamException {
1361:
1362: returnAST = null;
1363: ASTPair currentAST = new ASTPair();
1364: AST constructorBody_AST = null;
1365: Token lc = null;
1366: AST lc_AST = null;
1367:
1368: lc = LT(1);
1369: lc_AST = astFactory.create(lc);
1370: astFactory.makeASTRoot(currentAST, lc_AST);
1371: match(LCURLY);
1372: if (inputState.guessing == 0) {
1373: lc_AST.setType(SLIST);
1374: }
1375: {
1376: if ((LA(1) == LITERAL_this || LA(1) == LITERAL_super )
1377: && (LA(2) == LPAREN)) {
1378: explicitConstructorInvocation();
1379: astFactory.addASTChild(currentAST, returnAST);
1380: } else if ((_tokenSet_8.member(LA(1)))
1381: && (_tokenSet_9.member(LA(2)))) {
1382: } else {
1383: throw new NoViableAltException(LT(1), getFilename());
1384: }
1385:
1386: }
1387: {
1388: _loop55: do {
1389: if ((_tokenSet_10.member(LA(1)))) {
1390: statement();
1391: astFactory.addASTChild(currentAST, returnAST);
1392: } else {
1393: break _loop55;
1394: }
1395:
1396: } while (true);
1397: }
1398: match(RCURLY);
1399: constructorBody_AST = (AST) currentAST.root;
1400: returnAST = constructorBody_AST;
1401: }
1402:
1403: public final void parameterDeclarationList()
1404: throws RecognitionException, TokenStreamException {
1405:
1406: returnAST = null;
1407: ASTPair currentAST = new ASTPair();
1408: AST parameterDeclarationList_AST = null;
1409:
1410: {
1411: switch (LA(1)) {
1412: case FINAL:
1413: case LITERAL_void:
1414: case LITERAL_boolean:
1415: case LITERAL_byte:
1416: case LITERAL_char:
1417: case LITERAL_short:
1418: case LITERAL_int:
1419: case LITERAL_float:
1420: case LITERAL_long:
1421: case LITERAL_double:
1422: case IDENT: {
1423: parameterDeclaration();
1424: astFactory.addASTChild(currentAST, returnAST);
1425: {
1426: _loop80: do {
1427: if ((LA(1) == COMMA)) {
1428: match(COMMA);
1429: parameterDeclaration();
1430: astFactory.addASTChild(currentAST,
1431: returnAST);
1432: } else {
1433: break _loop80;
1434: }
1435:
1436: } while (true);
1437: }
1438: break;
1439: }
1440: case RPAREN: {
1441: break;
1442: }
1443: default: {
1444: throw new NoViableAltException(LT(1), getFilename());
1445: }
1446: }
1447: }
1448: if (inputState.guessing == 0) {
1449: parameterDeclarationList_AST = (AST) currentAST.root;
1450: parameterDeclarationList_AST = (AST) astFactory
1451: .make((new ASTArray(2))
1452: .add(
1453: astFactory.create(PARAMETERS,
1454: "PARAMETERS")).add(
1455: parameterDeclarationList_AST));
1456: currentAST.root = parameterDeclarationList_AST;
1457: currentAST.child = parameterDeclarationList_AST != null
1458: && parameterDeclarationList_AST.getFirstChild() != null ? parameterDeclarationList_AST
1459: .getFirstChild()
1460: : parameterDeclarationList_AST;
1461: currentAST.advanceChildToEnd();
1462: }
1463: parameterDeclarationList_AST = (AST) currentAST.root;
1464: returnAST = parameterDeclarationList_AST;
1465: }
1466:
1467: public final void declaratorBrackets(AST typ)
1468: throws RecognitionException, TokenStreamException {
1469:
1470: returnAST = null;
1471: ASTPair currentAST = new ASTPair();
1472: AST declaratorBrackets_AST = null;
1473: Token lb = null;
1474: AST lb_AST = null;
1475:
1476: if (inputState.guessing == 0) {
1477: declaratorBrackets_AST = (AST) currentAST.root;
1478: declaratorBrackets_AST = typ;
1479: currentAST.root = declaratorBrackets_AST;
1480: currentAST.child = declaratorBrackets_AST != null
1481: && declaratorBrackets_AST.getFirstChild() != null ? declaratorBrackets_AST
1482: .getFirstChild()
1483: : declaratorBrackets_AST;
1484: currentAST.advanceChildToEnd();
1485: }
1486: {
1487: _loop63: do {
1488: if ((LA(1) == LBRACK)) {
1489: lb = LT(1);
1490: lb_AST = astFactory.create(lb);
1491: astFactory.makeASTRoot(currentAST, lb_AST);
1492: match(LBRACK);
1493: if (inputState.guessing == 0) {
1494: lb_AST.setType(ARRAY_DECLARATOR);
1495: }
1496: match(RBRACK);
1497: } else {
1498: break _loop63;
1499: }
1500:
1501: } while (true);
1502: }
1503: declaratorBrackets_AST = (AST) currentAST.root;
1504: returnAST = declaratorBrackets_AST;
1505: }
1506:
1507: public final void throwsClause() throws RecognitionException,
1508: TokenStreamException {
1509:
1510: returnAST = null;
1511: ASTPair currentAST = new ASTPair();
1512: AST throwsClause_AST = null;
1513:
1514: AST tmp59_AST = null;
1515: tmp59_AST = astFactory.create(LT(1));
1516: astFactory.makeASTRoot(currentAST, tmp59_AST);
1517: match(LITERAL_throws);
1518: identifier();
1519: astFactory.addASTChild(currentAST, returnAST);
1520: {
1521: _loop76: do {
1522: if ((LA(1) == COMMA)) {
1523: match(COMMA);
1524: identifier();
1525: astFactory.addASTChild(currentAST, returnAST);
1526: } else {
1527: break _loop76;
1528: }
1529:
1530: } while (true);
1531: }
1532: throwsClause_AST = (AST) currentAST.root;
1533: returnAST = throwsClause_AST;
1534: }
1535:
1536: public final void compoundStatement() throws RecognitionException,
1537: TokenStreamException {
1538:
1539: returnAST = null;
1540: ASTPair currentAST = new ASTPair();
1541: AST compoundStatement_AST = null;
1542: Token lc = null;
1543: AST lc_AST = null;
1544:
1545: lc = LT(1);
1546: lc_AST = astFactory.create(lc);
1547: astFactory.makeASTRoot(currentAST, lc_AST);
1548: match(LCURLY);
1549: if (inputState.guessing == 0) {
1550: lc_AST.setType(SLIST);
1551: }
1552: {
1553: _loop86: do {
1554: if ((_tokenSet_10.member(LA(1)))) {
1555: statement();
1556: astFactory.addASTChild(currentAST, returnAST);
1557: } else {
1558: break _loop86;
1559: }
1560:
1561: } while (true);
1562: }
1563: match(RCURLY);
1564: compoundStatement_AST = (AST) currentAST.root;
1565: returnAST = compoundStatement_AST;
1566: }
1567:
1568: /** Catch obvious constructor calls, but not the expr.super(...) calls */
1569: public final void explicitConstructorInvocation()
1570: throws RecognitionException, TokenStreamException {
1571:
1572: returnAST = null;
1573: ASTPair currentAST = new ASTPair();
1574: AST explicitConstructorInvocation_AST = null;
1575: Token lp1 = null;
1576: AST lp1_AST = null;
1577: Token lp2 = null;
1578: AST lp2_AST = null;
1579:
1580: switch (LA(1)) {
1581: case LITERAL_this : {
1582: match(LITERAL_this );
1583: lp1 = LT(1);
1584: lp1_AST = astFactory.create(lp1);
1585: astFactory.makeASTRoot(currentAST, lp1_AST);
1586: match(LPAREN);
1587: argList();
1588: astFactory.addASTChild(currentAST, returnAST);
1589: match(RPAREN);
1590: match(SEMI);
1591: if (inputState.guessing == 0) {
1592: lp1_AST.setType(CTOR_CALL);
1593: }
1594: explicitConstructorInvocation_AST = (AST) currentAST.root;
1595: break;
1596: }
1597: case LITERAL_super : {
1598: match(LITERAL_super );
1599: lp2 = LT(1);
1600: lp2_AST = astFactory.create(lp2);
1601: astFactory.makeASTRoot(currentAST, lp2_AST);
1602: match(LPAREN);
1603: argList();
1604: astFactory.addASTChild(currentAST, returnAST);
1605: match(RPAREN);
1606: match(SEMI);
1607: if (inputState.guessing == 0) {
1608: lp2_AST.setType(SUPER_CTOR_CALL);
1609: }
1610: explicitConstructorInvocation_AST = (AST) currentAST.root;
1611: break;
1612: }
1613: default: {
1614: throw new NoViableAltException(LT(1), getFilename());
1615: }
1616: }
1617: returnAST = explicitConstructorInvocation_AST;
1618: }
1619:
1620: public final void statement() throws RecognitionException,
1621: TokenStreamException {
1622:
1623: returnAST = null;
1624: ASTPair currentAST = new ASTPair();
1625: AST statement_AST = null;
1626: AST m_AST = null;
1627: Token c = null;
1628: AST c_AST = null;
1629: Token s = null;
1630: AST s_AST = null;
1631:
1632: switch (LA(1)) {
1633: case LCURLY: {
1634: compoundStatement();
1635: astFactory.addASTChild(currentAST, returnAST);
1636: statement_AST = (AST) currentAST.root;
1637: break;
1638: }
1639: case LITERAL_if: {
1640: AST tmp68_AST = null;
1641: tmp68_AST = astFactory.create(LT(1));
1642: astFactory.makeASTRoot(currentAST, tmp68_AST);
1643: match(LITERAL_if);
1644: match(LPAREN);
1645: expression();
1646: astFactory.addASTChild(currentAST, returnAST);
1647: match(RPAREN);
1648: statement();
1649: astFactory.addASTChild(currentAST, returnAST);
1650: {
1651: if ((LA(1) == LITERAL_else)
1652: && (_tokenSet_10.member(LA(2)))) {
1653: match(LITERAL_else);
1654: statement();
1655: astFactory.addASTChild(currentAST, returnAST);
1656: } else if ((_tokenSet_11.member(LA(1)))
1657: && (_tokenSet_12.member(LA(2)))) {
1658: } else {
1659: throw new NoViableAltException(LT(1), getFilename());
1660: }
1661:
1662: }
1663: statement_AST = (AST) currentAST.root;
1664: break;
1665: }
1666: case LITERAL_for: {
1667: AST tmp72_AST = null;
1668: tmp72_AST = astFactory.create(LT(1));
1669: astFactory.makeASTRoot(currentAST, tmp72_AST);
1670: match(LITERAL_for);
1671: match(LPAREN);
1672: forInit();
1673: astFactory.addASTChild(currentAST, returnAST);
1674: match(SEMI);
1675: forCond();
1676: astFactory.addASTChild(currentAST, returnAST);
1677: match(SEMI);
1678: forIter();
1679: astFactory.addASTChild(currentAST, returnAST);
1680: match(RPAREN);
1681: statement();
1682: astFactory.addASTChild(currentAST, returnAST);
1683: statement_AST = (AST) currentAST.root;
1684: break;
1685: }
1686: case LITERAL_while: {
1687: AST tmp77_AST = null;
1688: tmp77_AST = astFactory.create(LT(1));
1689: astFactory.makeASTRoot(currentAST, tmp77_AST);
1690: match(LITERAL_while);
1691: match(LPAREN);
1692: expression();
1693: astFactory.addASTChild(currentAST, returnAST);
1694: match(RPAREN);
1695: statement();
1696: astFactory.addASTChild(currentAST, returnAST);
1697: statement_AST = (AST) currentAST.root;
1698: break;
1699: }
1700: case LITERAL_do: {
1701: AST tmp80_AST = null;
1702: tmp80_AST = astFactory.create(LT(1));
1703: astFactory.makeASTRoot(currentAST, tmp80_AST);
1704: match(LITERAL_do);
1705: statement();
1706: astFactory.addASTChild(currentAST, returnAST);
1707: match(LITERAL_while);
1708: match(LPAREN);
1709: expression();
1710: astFactory.addASTChild(currentAST, returnAST);
1711: match(RPAREN);
1712: match(SEMI);
1713: statement_AST = (AST) currentAST.root;
1714: break;
1715: }
1716: case LITERAL_break: {
1717: AST tmp85_AST = null;
1718: tmp85_AST = astFactory.create(LT(1));
1719: astFactory.makeASTRoot(currentAST, tmp85_AST);
1720: match(LITERAL_break);
1721: {
1722: switch (LA(1)) {
1723: case IDENT: {
1724: AST tmp86_AST = null;
1725: tmp86_AST = astFactory.create(LT(1));
1726: astFactory.addASTChild(currentAST, tmp86_AST);
1727: match(IDENT);
1728: break;
1729: }
1730: case SEMI: {
1731: break;
1732: }
1733: default: {
1734: throw new NoViableAltException(LT(1), getFilename());
1735: }
1736: }
1737: }
1738: match(SEMI);
1739: statement_AST = (AST) currentAST.root;
1740: break;
1741: }
1742: case LITERAL_continue: {
1743: AST tmp88_AST = null;
1744: tmp88_AST = astFactory.create(LT(1));
1745: astFactory.makeASTRoot(currentAST, tmp88_AST);
1746: match(LITERAL_continue);
1747: {
1748: switch (LA(1)) {
1749: case IDENT: {
1750: AST tmp89_AST = null;
1751: tmp89_AST = astFactory.create(LT(1));
1752: astFactory.addASTChild(currentAST, tmp89_AST);
1753: match(IDENT);
1754: break;
1755: }
1756: case SEMI: {
1757: break;
1758: }
1759: default: {
1760: throw new NoViableAltException(LT(1), getFilename());
1761: }
1762: }
1763: }
1764: match(SEMI);
1765: statement_AST = (AST) currentAST.root;
1766: break;
1767: }
1768: case LITERAL_return: {
1769: AST tmp91_AST = null;
1770: tmp91_AST = astFactory.create(LT(1));
1771: astFactory.makeASTRoot(currentAST, tmp91_AST);
1772: match(LITERAL_return);
1773: {
1774: switch (LA(1)) {
1775: case LITERAL_void:
1776: case LITERAL_boolean:
1777: case LITERAL_byte:
1778: case LITERAL_char:
1779: case LITERAL_short:
1780: case LITERAL_int:
1781: case LITERAL_float:
1782: case LITERAL_long:
1783: case LITERAL_double:
1784: case IDENT:
1785: case LPAREN:
1786: case LITERAL_this :
1787: case LITERAL_super :
1788: case PLUS:
1789: case MINUS:
1790: case INC:
1791: case DEC:
1792: case BNOT:
1793: case LNOT:
1794: case LITERAL_true:
1795: case LITERAL_false:
1796: case LITERAL_null:
1797: case LITERAL_new:
1798: case NUM_INT:
1799: case CHAR_LITERAL:
1800: case STRING_LITERAL:
1801: case NUM_FLOAT:
1802: case NUM_LONG:
1803: case NUM_DOUBLE: {
1804: expression();
1805: astFactory.addASTChild(currentAST, returnAST);
1806: break;
1807: }
1808: case SEMI: {
1809: break;
1810: }
1811: default: {
1812: throw new NoViableAltException(LT(1), getFilename());
1813: }
1814: }
1815: }
1816: match(SEMI);
1817: statement_AST = (AST) currentAST.root;
1818: break;
1819: }
1820: case LITERAL_switch: {
1821: AST tmp93_AST = null;
1822: tmp93_AST = astFactory.create(LT(1));
1823: astFactory.makeASTRoot(currentAST, tmp93_AST);
1824: match(LITERAL_switch);
1825: match(LPAREN);
1826: expression();
1827: astFactory.addASTChild(currentAST, returnAST);
1828: match(RPAREN);
1829: match(LCURLY);
1830: {
1831: _loop95: do {
1832: if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default)) {
1833: casesGroup();
1834: astFactory.addASTChild(currentAST, returnAST);
1835: } else {
1836: break _loop95;
1837: }
1838:
1839: } while (true);
1840: }
1841: match(RCURLY);
1842: statement_AST = (AST) currentAST.root;
1843: break;
1844: }
1845: case LITERAL_try: {
1846: tryBlock();
1847: astFactory.addASTChild(currentAST, returnAST);
1848: statement_AST = (AST) currentAST.root;
1849: break;
1850: }
1851: case LITERAL_throw: {
1852: AST tmp98_AST = null;
1853: tmp98_AST = astFactory.create(LT(1));
1854: astFactory.makeASTRoot(currentAST, tmp98_AST);
1855: match(LITERAL_throw);
1856: expression();
1857: astFactory.addASTChild(currentAST, returnAST);
1858: match(SEMI);
1859: statement_AST = (AST) currentAST.root;
1860: break;
1861: }
1862: case SEMI: {
1863: s = LT(1);
1864: s_AST = astFactory.create(s);
1865: astFactory.addASTChild(currentAST, s_AST);
1866: match(SEMI);
1867: if (inputState.guessing == 0) {
1868: s_AST.setType(EMPTY_STAT);
1869: }
1870: statement_AST = (AST) currentAST.root;
1871: break;
1872: }
1873: default:
1874: boolean synPredMatched89 = false;
1875: if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14
1876: .member(LA(2))))) {
1877: int _m89 = mark();
1878: synPredMatched89 = true;
1879: inputState.guessing++;
1880: try {
1881: {
1882: declaration();
1883: }
1884: } catch (RecognitionException pe) {
1885: synPredMatched89 = false;
1886: }
1887: rewind(_m89);
1888: inputState.guessing--;
1889: }
1890: if (synPredMatched89) {
1891: declaration();
1892: astFactory.addASTChild(currentAST, returnAST);
1893: match(SEMI);
1894: statement_AST = (AST) currentAST.root;
1895: } else if ((_tokenSet_15.member(LA(1)))
1896: && (_tokenSet_16.member(LA(2)))) {
1897: expression();
1898: astFactory.addASTChild(currentAST, returnAST);
1899: match(SEMI);
1900: statement_AST = (AST) currentAST.root;
1901: } else if ((_tokenSet_17.member(LA(1)))
1902: && (_tokenSet_18.member(LA(2)))) {
1903: modifiers();
1904: m_AST = (AST) returnAST;
1905: classDefinition(m_AST);
1906: astFactory.addASTChild(currentAST, returnAST);
1907: statement_AST = (AST) currentAST.root;
1908: } else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
1909: AST tmp102_AST = null;
1910: tmp102_AST = astFactory.create(LT(1));
1911: astFactory.addASTChild(currentAST, tmp102_AST);
1912: match(IDENT);
1913: c = LT(1);
1914: c_AST = astFactory.create(c);
1915: astFactory.makeASTRoot(currentAST, c_AST);
1916: match(COLON);
1917: if (inputState.guessing == 0) {
1918: c_AST.setType(LABELED_STAT);
1919: }
1920: statement();
1921: astFactory.addASTChild(currentAST, returnAST);
1922: statement_AST = (AST) currentAST.root;
1923: } else if ((LA(1) == LITERAL_synchronized)
1924: && (LA(2) == LPAREN)) {
1925: AST tmp103_AST = null;
1926: tmp103_AST = astFactory.create(LT(1));
1927: astFactory.makeASTRoot(currentAST, tmp103_AST);
1928: match(LITERAL_synchronized);
1929: match(LPAREN);
1930: expression();
1931: astFactory.addASTChild(currentAST, returnAST);
1932: match(RPAREN);
1933: compoundStatement();
1934: astFactory.addASTChild(currentAST, returnAST);
1935: statement_AST = (AST) currentAST.root;
1936: } else {
1937: throw new NoViableAltException(LT(1), getFilename());
1938: }
1939: }
1940: returnAST = statement_AST;
1941: }
1942:
1943: public final void argList() throws RecognitionException,
1944: TokenStreamException {
1945:
1946: returnAST = null;
1947: ASTPair currentAST = new ASTPair();
1948: AST argList_AST = null;
1949:
1950: {
1951: switch (LA(1)) {
1952: case LITERAL_void:
1953: case LITERAL_boolean:
1954: case LITERAL_byte:
1955: case LITERAL_char:
1956: case LITERAL_short:
1957: case LITERAL_int:
1958: case LITERAL_float:
1959: case LITERAL_long:
1960: case LITERAL_double:
1961: case IDENT:
1962: case LPAREN:
1963: case LITERAL_this :
1964: case LITERAL_super :
1965: case PLUS:
1966: case MINUS:
1967: case INC:
1968: case DEC:
1969: case BNOT:
1970: case LNOT:
1971: case LITERAL_true:
1972: case LITERAL_false:
1973: case LITERAL_null:
1974: case LITERAL_new:
1975: case NUM_INT:
1976: case CHAR_LITERAL:
1977: case STRING_LITERAL:
1978: case NUM_FLOAT:
1979: case NUM_LONG:
1980: case NUM_DOUBLE: {
1981: expressionList();
1982: astFactory.addASTChild(currentAST, returnAST);
1983: break;
1984: }
1985: case RPAREN: {
1986: if (inputState.guessing == 0) {
1987: argList_AST = (AST) currentAST.root;
1988: argList_AST = astFactory.create(ELIST, "ELIST");
1989: currentAST.root = argList_AST;
1990: currentAST.child = argList_AST != null
1991: && argList_AST.getFirstChild() != null ? argList_AST
1992: .getFirstChild()
1993: : argList_AST;
1994: currentAST.advanceChildToEnd();
1995: }
1996: break;
1997: }
1998: default: {
1999: throw new NoViableAltException(LT(1), getFilename());
2000: }
2001: }
2002: }
2003: argList_AST = (AST) currentAST.root;
2004: returnAST = argList_AST;
2005: }
2006:
2007: /** Declaration of a variable. This can be a class/instance variable,
2008: * or a local variable in a method
2009: * It can also include possible initialization.
2010: */
2011: public final void variableDeclarator(AST mods, AST t)
2012: throws RecognitionException, TokenStreamException {
2013:
2014: returnAST = null;
2015: ASTPair currentAST = new ASTPair();
2016: AST variableDeclarator_AST = null;
2017: Token id = null;
2018: AST id_AST = null;
2019: AST d_AST = null;
2020: AST v_AST = null;
2021:
2022: id = LT(1);
2023: id_AST = astFactory.create(id);
2024: match(IDENT);
2025: declaratorBrackets(t);
2026: d_AST = (AST) returnAST;
2027: varInitializer();
2028: v_AST = (AST) returnAST;
2029: if (inputState.guessing == 0) {
2030: variableDeclarator_AST = (AST) currentAST.root;
2031: variableDeclarator_AST = (AST) astFactory
2032: .make((new ASTArray(5))
2033: .add(
2034: astFactory.create(VARIABLE_DEF,
2035: "VARIABLE_DEF"))
2036: .add(mods)
2037: .add(
2038: (AST) astFactory
2039: .make((new ASTArray(2))
2040: .add(
2041: astFactory
2042: .create(
2043: TYPE,
2044: "TYPE"))
2045: .add(d_AST))).add(
2046: id_AST).add(v_AST));
2047: currentAST.root = variableDeclarator_AST;
2048: currentAST.child = variableDeclarator_AST != null
2049: && variableDeclarator_AST.getFirstChild() != null ? variableDeclarator_AST
2050: .getFirstChild()
2051: : variableDeclarator_AST;
2052: currentAST.advanceChildToEnd();
2053: }
2054: returnAST = variableDeclarator_AST;
2055: }
2056:
2057: public final void varInitializer() throws RecognitionException,
2058: TokenStreamException {
2059:
2060: returnAST = null;
2061: ASTPair currentAST = new ASTPair();
2062: AST varInitializer_AST = null;
2063:
2064: {
2065: switch (LA(1)) {
2066: case ASSIGN: {
2067: AST tmp106_AST = null;
2068: tmp106_AST = astFactory.create(LT(1));
2069: astFactory.makeASTRoot(currentAST, tmp106_AST);
2070: match(ASSIGN);
2071: initializer();
2072: astFactory.addASTChild(currentAST, returnAST);
2073: break;
2074: }
2075: case SEMI:
2076: case COMMA: {
2077: break;
2078: }
2079: default: {
2080: throw new NoViableAltException(LT(1), getFilename());
2081: }
2082: }
2083: }
2084: varInitializer_AST = (AST) currentAST.root;
2085: returnAST = varInitializer_AST;
2086: }
2087:
2088: public final void initializer() throws RecognitionException,
2089: TokenStreamException {
2090:
2091: returnAST = null;
2092: ASTPair currentAST = new ASTPair();
2093: AST initializer_AST = null;
2094:
2095: switch (LA(1)) {
2096: case LITERAL_void:
2097: case LITERAL_boolean:
2098: case LITERAL_byte:
2099: case LITERAL_char:
2100: case LITERAL_short:
2101: case LITERAL_int:
2102: case LITERAL_float:
2103: case LITERAL_long:
2104: case LITERAL_double:
2105: case IDENT:
2106: case LPAREN:
2107: case LITERAL_this :
2108: case LITERAL_super :
2109: case PLUS:
2110: case MINUS:
2111: case INC:
2112: case DEC:
2113: case BNOT:
2114: case LNOT:
2115: case LITERAL_true:
2116: case LITERAL_false:
2117: case LITERAL_null:
2118: case LITERAL_new:
2119: case NUM_INT:
2120: case CHAR_LITERAL:
2121: case STRING_LITERAL:
2122: case NUM_FLOAT:
2123: case NUM_LONG:
2124: case NUM_DOUBLE: {
2125: expression();
2126: astFactory.addASTChild(currentAST, returnAST);
2127: initializer_AST = (AST) currentAST.root;
2128: break;
2129: }
2130: case LCURLY: {
2131: arrayInitializer();
2132: astFactory.addASTChild(currentAST, returnAST);
2133: initializer_AST = (AST) currentAST.root;
2134: break;
2135: }
2136: default: {
2137: throw new NoViableAltException(LT(1), getFilename());
2138: }
2139: }
2140: returnAST = initializer_AST;
2141: }
2142:
2143: public final void arrayInitializer() throws RecognitionException,
2144: TokenStreamException {
2145:
2146: returnAST = null;
2147: ASTPair currentAST = new ASTPair();
2148: AST arrayInitializer_AST = null;
2149: Token lc = null;
2150: AST lc_AST = null;
2151:
2152: lc = LT(1);
2153: lc_AST = astFactory.create(lc);
2154: astFactory.makeASTRoot(currentAST, lc_AST);
2155: match(LCURLY);
2156: if (inputState.guessing == 0) {
2157: lc_AST.setType(ARRAY_INIT);
2158: }
2159: {
2160: switch (LA(1)) {
2161: case LITERAL_void:
2162: case LITERAL_boolean:
2163: case LITERAL_byte:
2164: case LITERAL_char:
2165: case LITERAL_short:
2166: case LITERAL_int:
2167: case LITERAL_float:
2168: case LITERAL_long:
2169: case LITERAL_double:
2170: case IDENT:
2171: case LCURLY:
2172: case LPAREN:
2173: case LITERAL_this :
2174: case LITERAL_super :
2175: case PLUS:
2176: case MINUS:
2177: case INC:
2178: case DEC:
2179: case BNOT:
2180: case LNOT:
2181: case LITERAL_true:
2182: case LITERAL_false:
2183: case LITERAL_null:
2184: case LITERAL_new:
2185: case NUM_INT:
2186: case CHAR_LITERAL:
2187: case STRING_LITERAL:
2188: case NUM_FLOAT:
2189: case NUM_LONG:
2190: case NUM_DOUBLE: {
2191: initializer();
2192: astFactory.addASTChild(currentAST, returnAST);
2193: {
2194: _loop69: do {
2195: if ((LA(1) == COMMA)
2196: && (_tokenSet_19.member(LA(2)))) {
2197: match(COMMA);
2198: initializer();
2199: astFactory.addASTChild(currentAST,
2200: returnAST);
2201: } else {
2202: break _loop69;
2203: }
2204:
2205: } while (true);
2206: }
2207: {
2208: switch (LA(1)) {
2209: case COMMA: {
2210: match(COMMA);
2211: break;
2212: }
2213: case RCURLY: {
2214: break;
2215: }
2216: default: {
2217: throw new NoViableAltException(LT(1),
2218: getFilename());
2219: }
2220: }
2221: }
2222: break;
2223: }
2224: case RCURLY: {
2225: break;
2226: }
2227: default: {
2228: throw new NoViableAltException(LT(1), getFilename());
2229: }
2230: }
2231: }
2232: match(RCURLY);
2233: arrayInitializer_AST = (AST) currentAST.root;
2234: returnAST = arrayInitializer_AST;
2235: }
2236:
2237: public final void expression() throws RecognitionException,
2238: TokenStreamException {
2239:
2240: returnAST = null;
2241: ASTPair currentAST = new ASTPair();
2242: AST expression_AST = null;
2243:
2244: assignmentExpression();
2245: astFactory.addASTChild(currentAST, returnAST);
2246: if (inputState.guessing == 0) {
2247: expression_AST = (AST) currentAST.root;
2248: expression_AST = (AST) astFactory.make((new ASTArray(2))
2249: .add(astFactory.create(EXPR, "EXPR")).add(
2250: expression_AST));
2251: currentAST.root = expression_AST;
2252: currentAST.child = expression_AST != null
2253: && expression_AST.getFirstChild() != null ? expression_AST
2254: .getFirstChild()
2255: : expression_AST;
2256: currentAST.advanceChildToEnd();
2257: }
2258: expression_AST = (AST) currentAST.root;
2259: returnAST = expression_AST;
2260: }
2261:
2262: public final void parameterDeclaration()
2263: throws RecognitionException, TokenStreamException {
2264:
2265: returnAST = null;
2266: ASTPair currentAST = new ASTPair();
2267: AST parameterDeclaration_AST = null;
2268: AST pm_AST = null;
2269: AST t_AST = null;
2270: Token id = null;
2271: AST id_AST = null;
2272: AST pd_AST = null;
2273:
2274: parameterModifier();
2275: pm_AST = (AST) returnAST;
2276: typeSpec(false);
2277: t_AST = (AST) returnAST;
2278: id = LT(1);
2279: id_AST = astFactory.create(id);
2280: match(IDENT);
2281: declaratorBrackets(t_AST);
2282: pd_AST = (AST) returnAST;
2283: if (inputState.guessing == 0) {
2284: parameterDeclaration_AST = (AST) currentAST.root;
2285: parameterDeclaration_AST = (AST) astFactory
2286: .make((new ASTArray(4)).add(
2287: astFactory.create(PARAMETER_DEF,
2288: "PARAMETER_DEF")).add(pm_AST).add(
2289: (AST) astFactory.make((new ASTArray(2))
2290: .add(
2291: astFactory.create(TYPE,
2292: "TYPE"))
2293: .add(pd_AST))).add(id_AST));
2294: currentAST.root = parameterDeclaration_AST;
2295: currentAST.child = parameterDeclaration_AST != null
2296: && parameterDeclaration_AST.getFirstChild() != null ? parameterDeclaration_AST
2297: .getFirstChild()
2298: : parameterDeclaration_AST;
2299: currentAST.advanceChildToEnd();
2300: }
2301: returnAST = parameterDeclaration_AST;
2302: }
2303:
2304: public final void parameterModifier() throws RecognitionException,
2305: TokenStreamException {
2306:
2307: returnAST = null;
2308: ASTPair currentAST = new ASTPair();
2309: AST parameterModifier_AST = null;
2310: Token f = null;
2311: AST f_AST = null;
2312:
2313: {
2314: switch (LA(1)) {
2315: case FINAL: {
2316: f = LT(1);
2317: f_AST = astFactory.create(f);
2318: astFactory.addASTChild(currentAST, f_AST);
2319: match(FINAL);
2320: break;
2321: }
2322: case LITERAL_void:
2323: case LITERAL_boolean:
2324: case LITERAL_byte:
2325: case LITERAL_char:
2326: case LITERAL_short:
2327: case LITERAL_int:
2328: case LITERAL_float:
2329: case LITERAL_long:
2330: case LITERAL_double:
2331: case IDENT: {
2332: break;
2333: }
2334: default: {
2335: throw new NoViableAltException(LT(1), getFilename());
2336: }
2337: }
2338: }
2339: if (inputState.guessing == 0) {
2340: parameterModifier_AST = (AST) currentAST.root;
2341: parameterModifier_AST = (AST) astFactory
2342: .make((new ASTArray(2)).add(
2343: astFactory.create(MODIFIERS, "MODIFIERS"))
2344: .add(f_AST));
2345: currentAST.root = parameterModifier_AST;
2346: currentAST.child = parameterModifier_AST != null
2347: && parameterModifier_AST.getFirstChild() != null ? parameterModifier_AST
2348: .getFirstChild()
2349: : parameterModifier_AST;
2350: currentAST.advanceChildToEnd();
2351: }
2352: parameterModifier_AST = (AST) currentAST.root;
2353: returnAST = parameterModifier_AST;
2354: }
2355:
2356: public final void forInit() throws RecognitionException,
2357: TokenStreamException {
2358:
2359: returnAST = null;
2360: ASTPair currentAST = new ASTPair();
2361: AST forInit_AST = null;
2362:
2363: {
2364: boolean synPredMatched107 = false;
2365: if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14
2366: .member(LA(2))))) {
2367: int _m107 = mark();
2368: synPredMatched107 = true;
2369: inputState.guessing++;
2370: try {
2371: {
2372: declaration();
2373: }
2374: } catch (RecognitionException pe) {
2375: synPredMatched107 = false;
2376: }
2377: rewind(_m107);
2378: inputState.guessing--;
2379: }
2380: if (synPredMatched107) {
2381: declaration();
2382: astFactory.addASTChild(currentAST, returnAST);
2383: } else if ((_tokenSet_15.member(LA(1)))
2384: && (_tokenSet_20.member(LA(2)))) {
2385: expressionList();
2386: astFactory.addASTChild(currentAST, returnAST);
2387: } else if ((LA(1) == SEMI)) {
2388: } else {
2389: throw new NoViableAltException(LT(1), getFilename());
2390: }
2391:
2392: }
2393: if (inputState.guessing == 0) {
2394: forInit_AST = (AST) currentAST.root;
2395: forInit_AST = (AST) astFactory.make((new ASTArray(2)).add(
2396: astFactory.create(FOR_INIT, "FOR_INIT")).add(
2397: forInit_AST));
2398: currentAST.root = forInit_AST;
2399: currentAST.child = forInit_AST != null
2400: && forInit_AST.getFirstChild() != null ? forInit_AST
2401: .getFirstChild()
2402: : forInit_AST;
2403: currentAST.advanceChildToEnd();
2404: }
2405: forInit_AST = (AST) currentAST.root;
2406: returnAST = forInit_AST;
2407: }
2408:
2409: public final void forCond() throws RecognitionException,
2410: TokenStreamException {
2411:
2412: returnAST = null;
2413: ASTPair currentAST = new ASTPair();
2414: AST forCond_AST = null;
2415:
2416: {
2417: switch (LA(1)) {
2418: case LITERAL_void:
2419: case LITERAL_boolean:
2420: case LITERAL_byte:
2421: case LITERAL_char:
2422: case LITERAL_short:
2423: case LITERAL_int:
2424: case LITERAL_float:
2425: case LITERAL_long:
2426: case LITERAL_double:
2427: case IDENT:
2428: case LPAREN:
2429: case LITERAL_this :
2430: case LITERAL_super :
2431: case PLUS:
2432: case MINUS:
2433: case INC:
2434: case DEC:
2435: case BNOT:
2436: case LNOT:
2437: case LITERAL_true:
2438: case LITERAL_false:
2439: case LITERAL_null:
2440: case LITERAL_new:
2441: case NUM_INT:
2442: case CHAR_LITERAL:
2443: case STRING_LITERAL:
2444: case NUM_FLOAT:
2445: case NUM_LONG:
2446: case NUM_DOUBLE: {
2447: expression();
2448: astFactory.addASTChild(currentAST, returnAST);
2449: break;
2450: }
2451: case SEMI: {
2452: break;
2453: }
2454: default: {
2455: throw new NoViableAltException(LT(1), getFilename());
2456: }
2457: }
2458: }
2459: if (inputState.guessing == 0) {
2460: forCond_AST = (AST) currentAST.root;
2461: forCond_AST = (AST) astFactory.make((new ASTArray(2)).add(
2462: astFactory.create(FOR_CONDITION, "FOR_CONDITION"))
2463: .add(forCond_AST));
2464: currentAST.root = forCond_AST;
2465: currentAST.child = forCond_AST != null
2466: && forCond_AST.getFirstChild() != null ? forCond_AST
2467: .getFirstChild()
2468: : forCond_AST;
2469: currentAST.advanceChildToEnd();
2470: }
2471: forCond_AST = (AST) currentAST.root;
2472: returnAST = forCond_AST;
2473: }
2474:
2475: public final void forIter() throws RecognitionException,
2476: TokenStreamException {
2477:
2478: returnAST = null;
2479: ASTPair currentAST = new ASTPair();
2480: AST forIter_AST = null;
2481:
2482: {
2483: switch (LA(1)) {
2484: case LITERAL_void:
2485: case LITERAL_boolean:
2486: case LITERAL_byte:
2487: case LITERAL_char:
2488: case LITERAL_short:
2489: case LITERAL_int:
2490: case LITERAL_float:
2491: case LITERAL_long:
2492: case LITERAL_double:
2493: case IDENT:
2494: case LPAREN:
2495: case LITERAL_this :
2496: case LITERAL_super :
2497: case PLUS:
2498: case MINUS:
2499: case INC:
2500: case DEC:
2501: case BNOT:
2502: case LNOT:
2503: case LITERAL_true:
2504: case LITERAL_false:
2505: case LITERAL_null:
2506: case LITERAL_new:
2507: case NUM_INT:
2508: case CHAR_LITERAL:
2509: case STRING_LITERAL:
2510: case NUM_FLOAT:
2511: case NUM_LONG:
2512: case NUM_DOUBLE: {
2513: expressionList();
2514: astFactory.addASTChild(currentAST, returnAST);
2515: break;
2516: }
2517: case RPAREN: {
2518: break;
2519: }
2520: default: {
2521: throw new NoViableAltException(LT(1), getFilename());
2522: }
2523: }
2524: }
2525: if (inputState.guessing == 0) {
2526: forIter_AST = (AST) currentAST.root;
2527: forIter_AST = (AST) astFactory.make((new ASTArray(2)).add(
2528: astFactory.create(FOR_ITERATOR, "FOR_ITERATOR"))
2529: .add(forIter_AST));
2530: currentAST.root = forIter_AST;
2531: currentAST.child = forIter_AST != null
2532: && forIter_AST.getFirstChild() != null ? forIter_AST
2533: .getFirstChild()
2534: : forIter_AST;
2535: currentAST.advanceChildToEnd();
2536: }
2537: forIter_AST = (AST) currentAST.root;
2538: returnAST = forIter_AST;
2539: }
2540:
2541: public final void casesGroup() throws RecognitionException,
2542: TokenStreamException {
2543:
2544: returnAST = null;
2545: ASTPair currentAST = new ASTPair();
2546: AST casesGroup_AST = null;
2547:
2548: {
2549: int _cnt98 = 0;
2550: _loop98: do {
2551: if ((LA(1) == LITERAL_case || LA(1) == LITERAL_default)
2552: && (_tokenSet_21.member(LA(2)))) {
2553: aCase();
2554: astFactory.addASTChild(currentAST, returnAST);
2555: } else {
2556: if (_cnt98 >= 1) {
2557: break _loop98;
2558: } else {
2559: throw new NoViableAltException(LT(1),
2560: getFilename());
2561: }
2562: }
2563:
2564: _cnt98++;
2565: } while (true);
2566: }
2567: caseSList();
2568: astFactory.addASTChild(currentAST, returnAST);
2569: if (inputState.guessing == 0) {
2570: casesGroup_AST = (AST) currentAST.root;
2571: casesGroup_AST = (AST) astFactory.make((new ASTArray(2))
2572: .add(astFactory.create(CASE_GROUP, "CASE_GROUP"))
2573: .add(casesGroup_AST));
2574: currentAST.root = casesGroup_AST;
2575: currentAST.child = casesGroup_AST != null
2576: && casesGroup_AST.getFirstChild() != null ? casesGroup_AST
2577: .getFirstChild()
2578: : casesGroup_AST;
2579: currentAST.advanceChildToEnd();
2580: }
2581: casesGroup_AST = (AST) currentAST.root;
2582: returnAST = casesGroup_AST;
2583: }
2584:
2585: public final void tryBlock() throws RecognitionException,
2586: TokenStreamException {
2587:
2588: returnAST = null;
2589: ASTPair currentAST = new ASTPair();
2590: AST tryBlock_AST = null;
2591:
2592: AST tmp110_AST = null;
2593: tmp110_AST = astFactory.create(LT(1));
2594: astFactory.makeASTRoot(currentAST, tmp110_AST);
2595: match(LITERAL_try);
2596: compoundStatement();
2597: astFactory.addASTChild(currentAST, returnAST);
2598: {
2599: _loop114: do {
2600: if ((LA(1) == LITERAL_catch)) {
2601: handler();
2602: astFactory.addASTChild(currentAST, returnAST);
2603: } else {
2604: break _loop114;
2605: }
2606:
2607: } while (true);
2608: }
2609: {
2610: switch (LA(1)) {
2611: case LITERAL_finally: {
2612: finallyClause();
2613: astFactory.addASTChild(currentAST, returnAST);
2614: break;
2615: }
2616: case FINAL:
2617: case ABSTRACT:
2618: case STRICTFP:
2619: case SEMI:
2620: case LITERAL_void:
2621: case LITERAL_boolean:
2622: case LITERAL_byte:
2623: case LITERAL_char:
2624: case LITERAL_short:
2625: case LITERAL_int:
2626: case LITERAL_float:
2627: case LITERAL_long:
2628: case LITERAL_double:
2629: case IDENT:
2630: case LITERAL_private:
2631: case LITERAL_public:
2632: case LITERAL_protected:
2633: case LITERAL_static:
2634: case LITERAL_transient:
2635: case LITERAL_native:
2636: case LITERAL_threadsafe:
2637: case LITERAL_synchronized:
2638: case LITERAL_volatile:
2639: case LITERAL_class:
2640: case LCURLY:
2641: case RCURLY:
2642: case LPAREN:
2643: case LITERAL_this :
2644: case LITERAL_super :
2645: case LITERAL_if:
2646: case LITERAL_else:
2647: case LITERAL_for:
2648: case LITERAL_while:
2649: case LITERAL_do:
2650: case LITERAL_break:
2651: case LITERAL_continue:
2652: case LITERAL_return:
2653: case LITERAL_switch:
2654: case LITERAL_throw:
2655: case LITERAL_case:
2656: case LITERAL_default:
2657: case LITERAL_try:
2658: case PLUS:
2659: case MINUS:
2660: case INC:
2661: case DEC:
2662: case BNOT:
2663: case LNOT:
2664: case LITERAL_true:
2665: case LITERAL_false:
2666: case LITERAL_null:
2667: case LITERAL_new:
2668: case NUM_INT:
2669: case CHAR_LITERAL:
2670: case STRING_LITERAL:
2671: case NUM_FLOAT:
2672: case NUM_LONG:
2673: case NUM_DOUBLE: {
2674: break;
2675: }
2676: default: {
2677: throw new NoViableAltException(LT(1), getFilename());
2678: }
2679: }
2680: }
2681: tryBlock_AST = (AST) currentAST.root;
2682: returnAST = tryBlock_AST;
2683: }
2684:
2685: public final void aCase() throws RecognitionException,
2686: TokenStreamException {
2687:
2688: returnAST = null;
2689: ASTPair currentAST = new ASTPair();
2690: AST aCase_AST = null;
2691:
2692: {
2693: switch (LA(1)) {
2694: case LITERAL_case: {
2695: AST tmp111_AST = null;
2696: tmp111_AST = astFactory.create(LT(1));
2697: astFactory.makeASTRoot(currentAST, tmp111_AST);
2698: match(LITERAL_case);
2699: expression();
2700: astFactory.addASTChild(currentAST, returnAST);
2701: break;
2702: }
2703: case LITERAL_default: {
2704: AST tmp112_AST = null;
2705: tmp112_AST = astFactory.create(LT(1));
2706: astFactory.addASTChild(currentAST, tmp112_AST);
2707: match(LITERAL_default);
2708: break;
2709: }
2710: default: {
2711: throw new NoViableAltException(LT(1), getFilename());
2712: }
2713: }
2714: }
2715: match(COLON);
2716: aCase_AST = (AST) currentAST.root;
2717: returnAST = aCase_AST;
2718: }
2719:
2720: public final void caseSList() throws RecognitionException,
2721: TokenStreamException {
2722:
2723: returnAST = null;
2724: ASTPair currentAST = new ASTPair();
2725: AST caseSList_AST = null;
2726:
2727: {
2728: _loop103: do {
2729: if ((_tokenSet_10.member(LA(1)))) {
2730: statement();
2731: astFactory.addASTChild(currentAST, returnAST);
2732: } else {
2733: break _loop103;
2734: }
2735:
2736: } while (true);
2737: }
2738: if (inputState.guessing == 0) {
2739: caseSList_AST = (AST) currentAST.root;
2740: caseSList_AST = (AST) astFactory.make((new ASTArray(2))
2741: .add(astFactory.create(SLIST, "SLIST")).add(
2742: caseSList_AST));
2743: currentAST.root = caseSList_AST;
2744: currentAST.child = caseSList_AST != null
2745: && caseSList_AST.getFirstChild() != null ? caseSList_AST
2746: .getFirstChild()
2747: : caseSList_AST;
2748: currentAST.advanceChildToEnd();
2749: }
2750: caseSList_AST = (AST) currentAST.root;
2751: returnAST = caseSList_AST;
2752: }
2753:
2754: public final void expressionList() throws RecognitionException,
2755: TokenStreamException {
2756:
2757: returnAST = null;
2758: ASTPair currentAST = new ASTPair();
2759: AST expressionList_AST = null;
2760:
2761: expression();
2762: astFactory.addASTChild(currentAST, returnAST);
2763: {
2764: _loop121: do {
2765: if ((LA(1) == COMMA)) {
2766: match(COMMA);
2767: expression();
2768: astFactory.addASTChild(currentAST, returnAST);
2769: } else {
2770: break _loop121;
2771: }
2772:
2773: } while (true);
2774: }
2775: if (inputState.guessing == 0) {
2776: expressionList_AST = (AST) currentAST.root;
2777: expressionList_AST = (AST) astFactory
2778: .make((new ASTArray(2)).add(
2779: astFactory.create(ELIST, "ELIST")).add(
2780: expressionList_AST));
2781: currentAST.root = expressionList_AST;
2782: currentAST.child = expressionList_AST != null
2783: && expressionList_AST.getFirstChild() != null ? expressionList_AST
2784: .getFirstChild()
2785: : expressionList_AST;
2786: currentAST.advanceChildToEnd();
2787: }
2788: expressionList_AST = (AST) currentAST.root;
2789: returnAST = expressionList_AST;
2790: }
2791:
2792: public final void handler() throws RecognitionException,
2793: TokenStreamException {
2794:
2795: returnAST = null;
2796: ASTPair currentAST = new ASTPair();
2797: AST handler_AST = null;
2798:
2799: AST tmp115_AST = null;
2800: tmp115_AST = astFactory.create(LT(1));
2801: astFactory.makeASTRoot(currentAST, tmp115_AST);
2802: match(LITERAL_catch);
2803: match(LPAREN);
2804: parameterDeclaration();
2805: astFactory.addASTChild(currentAST, returnAST);
2806: match(RPAREN);
2807: compoundStatement();
2808: astFactory.addASTChild(currentAST, returnAST);
2809: handler_AST = (AST) currentAST.root;
2810: returnAST = handler_AST;
2811: }
2812:
2813: public final void finallyClause() throws RecognitionException,
2814: TokenStreamException {
2815:
2816: returnAST = null;
2817: ASTPair currentAST = new ASTPair();
2818: AST finallyClause_AST = null;
2819:
2820: AST tmp118_AST = null;
2821: tmp118_AST = astFactory.create(LT(1));
2822: astFactory.makeASTRoot(currentAST, tmp118_AST);
2823: match(LITERAL_finally);
2824: compoundStatement();
2825: astFactory.addASTChild(currentAST, returnAST);
2826: finallyClause_AST = (AST) currentAST.root;
2827: returnAST = finallyClause_AST;
2828: }
2829:
2830: public final void assignmentExpression()
2831: throws RecognitionException, TokenStreamException {
2832:
2833: returnAST = null;
2834: ASTPair currentAST = new ASTPair();
2835: AST assignmentExpression_AST = null;
2836:
2837: conditionalExpression();
2838: astFactory.addASTChild(currentAST, returnAST);
2839: {
2840: switch (LA(1)) {
2841: case ASSIGN:
2842: case PLUS_ASSIGN:
2843: case MINUS_ASSIGN:
2844: case STAR_ASSIGN:
2845: case DIV_ASSIGN:
2846: case MOD_ASSIGN:
2847: case SR_ASSIGN:
2848: case BSR_ASSIGN:
2849: case SL_ASSIGN:
2850: case BAND_ASSIGN:
2851: case BXOR_ASSIGN:
2852: case BOR_ASSIGN: {
2853: {
2854: switch (LA(1)) {
2855: case ASSIGN: {
2856: AST tmp119_AST = null;
2857: tmp119_AST = astFactory.create(LT(1));
2858: astFactory.makeASTRoot(currentAST, tmp119_AST);
2859: match(ASSIGN);
2860: break;
2861: }
2862: case PLUS_ASSIGN: {
2863: AST tmp120_AST = null;
2864: tmp120_AST = astFactory.create(LT(1));
2865: astFactory.makeASTRoot(currentAST, tmp120_AST);
2866: match(PLUS_ASSIGN);
2867: break;
2868: }
2869: case MINUS_ASSIGN: {
2870: AST tmp121_AST = null;
2871: tmp121_AST = astFactory.create(LT(1));
2872: astFactory.makeASTRoot(currentAST, tmp121_AST);
2873: match(MINUS_ASSIGN);
2874: break;
2875: }
2876: case STAR_ASSIGN: {
2877: AST tmp122_AST = null;
2878: tmp122_AST = astFactory.create(LT(1));
2879: astFactory.makeASTRoot(currentAST, tmp122_AST);
2880: match(STAR_ASSIGN);
2881: break;
2882: }
2883: case DIV_ASSIGN: {
2884: AST tmp123_AST = null;
2885: tmp123_AST = astFactory.create(LT(1));
2886: astFactory.makeASTRoot(currentAST, tmp123_AST);
2887: match(DIV_ASSIGN);
2888: break;
2889: }
2890: case MOD_ASSIGN: {
2891: AST tmp124_AST = null;
2892: tmp124_AST = astFactory.create(LT(1));
2893: astFactory.makeASTRoot(currentAST, tmp124_AST);
2894: match(MOD_ASSIGN);
2895: break;
2896: }
2897: case SR_ASSIGN: {
2898: AST tmp125_AST = null;
2899: tmp125_AST = astFactory.create(LT(1));
2900: astFactory.makeASTRoot(currentAST, tmp125_AST);
2901: match(SR_ASSIGN);
2902: break;
2903: }
2904: case BSR_ASSIGN: {
2905: AST tmp126_AST = null;
2906: tmp126_AST = astFactory.create(LT(1));
2907: astFactory.makeASTRoot(currentAST, tmp126_AST);
2908: match(BSR_ASSIGN);
2909: break;
2910: }
2911: case SL_ASSIGN: {
2912: AST tmp127_AST = null;
2913: tmp127_AST = astFactory.create(LT(1));
2914: astFactory.makeASTRoot(currentAST, tmp127_AST);
2915: match(SL_ASSIGN);
2916: break;
2917: }
2918: case BAND_ASSIGN: {
2919: AST tmp128_AST = null;
2920: tmp128_AST = astFactory.create(LT(1));
2921: astFactory.makeASTRoot(currentAST, tmp128_AST);
2922: match(BAND_ASSIGN);
2923: break;
2924: }
2925: case BXOR_ASSIGN: {
2926: AST tmp129_AST = null;
2927: tmp129_AST = astFactory.create(LT(1));
2928: astFactory.makeASTRoot(currentAST, tmp129_AST);
2929: match(BXOR_ASSIGN);
2930: break;
2931: }
2932: case BOR_ASSIGN: {
2933: AST tmp130_AST = null;
2934: tmp130_AST = astFactory.create(LT(1));
2935: astFactory.makeASTRoot(currentAST, tmp130_AST);
2936: match(BOR_ASSIGN);
2937: break;
2938: }
2939: default: {
2940: throw new NoViableAltException(LT(1),
2941: getFilename());
2942: }
2943: }
2944: }
2945: assignmentExpression();
2946: astFactory.addASTChild(currentAST, returnAST);
2947: break;
2948: }
2949: case SEMI:
2950: case RBRACK:
2951: case RCURLY:
2952: case COMMA:
2953: case RPAREN:
2954: case COLON: {
2955: break;
2956: }
2957: default: {
2958: throw new NoViableAltException(LT(1), getFilename());
2959: }
2960: }
2961: }
2962: assignmentExpression_AST = (AST) currentAST.root;
2963: returnAST = assignmentExpression_AST;
2964: }
2965:
2966: public final void conditionalExpression()
2967: throws RecognitionException, TokenStreamException {
2968:
2969: returnAST = null;
2970: ASTPair currentAST = new ASTPair();
2971: AST conditionalExpression_AST = null;
2972:
2973: logicalOrExpression();
2974: astFactory.addASTChild(currentAST, returnAST);
2975: {
2976: switch (LA(1)) {
2977: case QUESTION: {
2978: AST tmp131_AST = null;
2979: tmp131_AST = astFactory.create(LT(1));
2980: astFactory.makeASTRoot(currentAST, tmp131_AST);
2981: match(QUESTION);
2982: assignmentExpression();
2983: astFactory.addASTChild(currentAST, returnAST);
2984: match(COLON);
2985: conditionalExpression();
2986: astFactory.addASTChild(currentAST, returnAST);
2987: break;
2988: }
2989: case SEMI:
2990: case RBRACK:
2991: case RCURLY:
2992: case COMMA:
2993: case RPAREN:
2994: case ASSIGN:
2995: case COLON:
2996: case PLUS_ASSIGN:
2997: case MINUS_ASSIGN:
2998: case STAR_ASSIGN:
2999: case DIV_ASSIGN:
3000: case MOD_ASSIGN:
3001: case SR_ASSIGN:
3002: case BSR_ASSIGN:
3003: case SL_ASSIGN:
3004: case BAND_ASSIGN:
3005: case BXOR_ASSIGN:
3006: case BOR_ASSIGN: {
3007: break;
3008: }
3009: default: {
3010: throw new NoViableAltException(LT(1), getFilename());
3011: }
3012: }
3013: }
3014: conditionalExpression_AST = (AST) currentAST.root;
3015: returnAST = conditionalExpression_AST;
3016: }
3017:
3018: public final void logicalOrExpression()
3019: throws RecognitionException, TokenStreamException {
3020:
3021: returnAST = null;
3022: ASTPair currentAST = new ASTPair();
3023: AST logicalOrExpression_AST = null;
3024:
3025: logicalAndExpression();
3026: astFactory.addASTChild(currentAST, returnAST);
3027: {
3028: _loop129: do {
3029: if ((LA(1) == LOR)) {
3030: AST tmp133_AST = null;
3031: tmp133_AST = astFactory.create(LT(1));
3032: astFactory.makeASTRoot(currentAST, tmp133_AST);
3033: match(LOR);
3034: logicalAndExpression();
3035: astFactory.addASTChild(currentAST, returnAST);
3036: } else {
3037: break _loop129;
3038: }
3039:
3040: } while (true);
3041: }
3042: logicalOrExpression_AST = (AST) currentAST.root;
3043: returnAST = logicalOrExpression_AST;
3044: }
3045:
3046: public final void logicalAndExpression()
3047: throws RecognitionException, TokenStreamException {
3048:
3049: returnAST = null;
3050: ASTPair currentAST = new ASTPair();
3051: AST logicalAndExpression_AST = null;
3052:
3053: inclusiveOrExpression();
3054: astFactory.addASTChild(currentAST, returnAST);
3055: {
3056: _loop132: do {
3057: if ((LA(1) == LAND)) {
3058: AST tmp134_AST = null;
3059: tmp134_AST = astFactory.create(LT(1));
3060: astFactory.makeASTRoot(currentAST, tmp134_AST);
3061: match(LAND);
3062: inclusiveOrExpression();
3063: astFactory.addASTChild(currentAST, returnAST);
3064: } else {
3065: break _loop132;
3066: }
3067:
3068: } while (true);
3069: }
3070: logicalAndExpression_AST = (AST) currentAST.root;
3071: returnAST = logicalAndExpression_AST;
3072: }
3073:
3074: public final void inclusiveOrExpression()
3075: throws RecognitionException, TokenStreamException {
3076:
3077: returnAST = null;
3078: ASTPair currentAST = new ASTPair();
3079: AST inclusiveOrExpression_AST = null;
3080:
3081: exclusiveOrExpression();
3082: astFactory.addASTChild(currentAST, returnAST);
3083: {
3084: _loop135: do {
3085: if ((LA(1) == BOR)) {
3086: AST tmp135_AST = null;
3087: tmp135_AST = astFactory.create(LT(1));
3088: astFactory.makeASTRoot(currentAST, tmp135_AST);
3089: match(BOR);
3090: exclusiveOrExpression();
3091: astFactory.addASTChild(currentAST, returnAST);
3092: } else {
3093: break _loop135;
3094: }
3095:
3096: } while (true);
3097: }
3098: inclusiveOrExpression_AST = (AST) currentAST.root;
3099: returnAST = inclusiveOrExpression_AST;
3100: }
3101:
3102: public final void exclusiveOrExpression()
3103: throws RecognitionException, TokenStreamException {
3104:
3105: returnAST = null;
3106: ASTPair currentAST = new ASTPair();
3107: AST exclusiveOrExpression_AST = null;
3108:
3109: andExpression();
3110: astFactory.addASTChild(currentAST, returnAST);
3111: {
3112: _loop138: do {
3113: if ((LA(1) == BXOR)) {
3114: AST tmp136_AST = null;
3115: tmp136_AST = astFactory.create(LT(1));
3116: astFactory.makeASTRoot(currentAST, tmp136_AST);
3117: match(BXOR);
3118: andExpression();
3119: astFactory.addASTChild(currentAST, returnAST);
3120: } else {
3121: break _loop138;
3122: }
3123:
3124: } while (true);
3125: }
3126: exclusiveOrExpression_AST = (AST) currentAST.root;
3127: returnAST = exclusiveOrExpression_AST;
3128: }
3129:
3130: public final void andExpression() throws RecognitionException,
3131: TokenStreamException {
3132:
3133: returnAST = null;
3134: ASTPair currentAST = new ASTPair();
3135: AST andExpression_AST = null;
3136:
3137: equalityExpression();
3138: astFactory.addASTChild(currentAST, returnAST);
3139: {
3140: _loop141: do {
3141: if ((LA(1) == BAND)) {
3142: AST tmp137_AST = null;
3143: tmp137_AST = astFactory.create(LT(1));
3144: astFactory.makeASTRoot(currentAST, tmp137_AST);
3145: match(BAND);
3146: equalityExpression();
3147: astFactory.addASTChild(currentAST, returnAST);
3148: } else {
3149: break _loop141;
3150: }
3151:
3152: } while (true);
3153: }
3154: andExpression_AST = (AST) currentAST.root;
3155: returnAST = andExpression_AST;
3156: }
3157:
3158: public final void equalityExpression() throws RecognitionException,
3159: TokenStreamException {
3160:
3161: returnAST = null;
3162: ASTPair currentAST = new ASTPair();
3163: AST equalityExpression_AST = null;
3164:
3165: relationalExpression();
3166: astFactory.addASTChild(currentAST, returnAST);
3167: {
3168: _loop145: do {
3169: if ((LA(1) == NOT_EQUAL || LA(1) == EQUAL)) {
3170: {
3171: switch (LA(1)) {
3172: case NOT_EQUAL: {
3173: AST tmp138_AST = null;
3174: tmp138_AST = astFactory.create(LT(1));
3175: astFactory.makeASTRoot(currentAST,
3176: tmp138_AST);
3177: match(NOT_EQUAL);
3178: break;
3179: }
3180: case EQUAL: {
3181: AST tmp139_AST = null;
3182: tmp139_AST = astFactory.create(LT(1));
3183: astFactory.makeASTRoot(currentAST,
3184: tmp139_AST);
3185: match(EQUAL);
3186: break;
3187: }
3188: default: {
3189: throw new NoViableAltException(LT(1),
3190: getFilename());
3191: }
3192: }
3193: }
3194: relationalExpression();
3195: astFactory.addASTChild(currentAST, returnAST);
3196: } else {
3197: break _loop145;
3198: }
3199:
3200: } while (true);
3201: }
3202: equalityExpression_AST = (AST) currentAST.root;
3203: returnAST = equalityExpression_AST;
3204: }
3205:
3206: public final void relationalExpression()
3207: throws RecognitionException, TokenStreamException {
3208:
3209: returnAST = null;
3210: ASTPair currentAST = new ASTPair();
3211: AST relationalExpression_AST = null;
3212:
3213: shiftExpression();
3214: astFactory.addASTChild(currentAST, returnAST);
3215: {
3216: switch (LA(1)) {
3217: case SEMI:
3218: case RBRACK:
3219: case RCURLY:
3220: case COMMA:
3221: case RPAREN:
3222: case ASSIGN:
3223: case COLON:
3224: case PLUS_ASSIGN:
3225: case MINUS_ASSIGN:
3226: case STAR_ASSIGN:
3227: case DIV_ASSIGN:
3228: case MOD_ASSIGN:
3229: case SR_ASSIGN:
3230: case BSR_ASSIGN:
3231: case SL_ASSIGN:
3232: case BAND_ASSIGN:
3233: case BXOR_ASSIGN:
3234: case BOR_ASSIGN:
3235: case QUESTION:
3236: case LOR:
3237: case LAND:
3238: case BOR:
3239: case BXOR:
3240: case BAND:
3241: case NOT_EQUAL:
3242: case EQUAL:
3243: case LT:
3244: case GT:
3245: case LE:
3246: case GE: {
3247: {
3248: _loop150: do {
3249: if (((LA(1) >= LT && LA(1) <= GE))) {
3250: {
3251: switch (LA(1)) {
3252: case LT: {
3253: AST tmp140_AST = null;
3254: tmp140_AST = astFactory
3255: .create(LT(1));
3256: astFactory.makeASTRoot(currentAST,
3257: tmp140_AST);
3258: match(LT);
3259: break;
3260: }
3261: case GT: {
3262: AST tmp141_AST = null;
3263: tmp141_AST = astFactory
3264: .create(LT(1));
3265: astFactory.makeASTRoot(currentAST,
3266: tmp141_AST);
3267: match(GT);
3268: break;
3269: }
3270: case LE: {
3271: AST tmp142_AST = null;
3272: tmp142_AST = astFactory
3273: .create(LT(1));
3274: astFactory.makeASTRoot(currentAST,
3275: tmp142_AST);
3276: match(LE);
3277: break;
3278: }
3279: case GE: {
3280: AST tmp143_AST = null;
3281: tmp143_AST = astFactory
3282: .create(LT(1));
3283: astFactory.makeASTRoot(currentAST,
3284: tmp143_AST);
3285: match(GE);
3286: break;
3287: }
3288: default: {
3289: throw new NoViableAltException(
3290: LT(1), getFilename());
3291: }
3292: }
3293: }
3294: shiftExpression();
3295: astFactory.addASTChild(currentAST,
3296: returnAST);
3297: } else {
3298: break _loop150;
3299: }
3300:
3301: } while (true);
3302: }
3303: break;
3304: }
3305: case LITERAL_instanceof : {
3306: AST tmp144_AST = null;
3307: tmp144_AST = astFactory.create(LT(1));
3308: astFactory.makeASTRoot(currentAST, tmp144_AST);
3309: match(LITERAL_instanceof );
3310: typeSpec(true);
3311: astFactory.addASTChild(currentAST, returnAST);
3312: break;
3313: }
3314: default: {
3315: throw new NoViableAltException(LT(1), getFilename());
3316: }
3317: }
3318: }
3319: relationalExpression_AST = (AST) currentAST.root;
3320: returnAST = relationalExpression_AST;
3321: }
3322:
3323: public final void shiftExpression() throws RecognitionException,
3324: TokenStreamException {
3325:
3326: returnAST = null;
3327: ASTPair currentAST = new ASTPair();
3328: AST shiftExpression_AST = null;
3329:
3330: additiveExpression();
3331: astFactory.addASTChild(currentAST, returnAST);
3332: {
3333: _loop154: do {
3334: if (((LA(1) >= SL && LA(1) <= BSR))) {
3335: {
3336: switch (LA(1)) {
3337: case SL: {
3338: AST tmp145_AST = null;
3339: tmp145_AST = astFactory.create(LT(1));
3340: astFactory.makeASTRoot(currentAST,
3341: tmp145_AST);
3342: match(SL);
3343: break;
3344: }
3345: case SR: {
3346: AST tmp146_AST = null;
3347: tmp146_AST = astFactory.create(LT(1));
3348: astFactory.makeASTRoot(currentAST,
3349: tmp146_AST);
3350: match(SR);
3351: break;
3352: }
3353: case BSR: {
3354: AST tmp147_AST = null;
3355: tmp147_AST = astFactory.create(LT(1));
3356: astFactory.makeASTRoot(currentAST,
3357: tmp147_AST);
3358: match(BSR);
3359: break;
3360: }
3361: default: {
3362: throw new NoViableAltException(LT(1),
3363: getFilename());
3364: }
3365: }
3366: }
3367: additiveExpression();
3368: astFactory.addASTChild(currentAST, returnAST);
3369: } else {
3370: break _loop154;
3371: }
3372:
3373: } while (true);
3374: }
3375: shiftExpression_AST = (AST) currentAST.root;
3376: returnAST = shiftExpression_AST;
3377: }
3378:
3379: public final void additiveExpression() throws RecognitionException,
3380: TokenStreamException {
3381:
3382: returnAST = null;
3383: ASTPair currentAST = new ASTPair();
3384: AST additiveExpression_AST = null;
3385:
3386: multiplicativeExpression();
3387: astFactory.addASTChild(currentAST, returnAST);
3388: {
3389: _loop158: do {
3390: if ((LA(1) == PLUS || LA(1) == MINUS)) {
3391: {
3392: switch (LA(1)) {
3393: case PLUS: {
3394: AST tmp148_AST = null;
3395: tmp148_AST = astFactory.create(LT(1));
3396: astFactory.makeASTRoot(currentAST,
3397: tmp148_AST);
3398: match(PLUS);
3399: break;
3400: }
3401: case MINUS: {
3402: AST tmp149_AST = null;
3403: tmp149_AST = astFactory.create(LT(1));
3404: astFactory.makeASTRoot(currentAST,
3405: tmp149_AST);
3406: match(MINUS);
3407: break;
3408: }
3409: default: {
3410: throw new NoViableAltException(LT(1),
3411: getFilename());
3412: }
3413: }
3414: }
3415: multiplicativeExpression();
3416: astFactory.addASTChild(currentAST, returnAST);
3417: } else {
3418: break _loop158;
3419: }
3420:
3421: } while (true);
3422: }
3423: additiveExpression_AST = (AST) currentAST.root;
3424: returnAST = additiveExpression_AST;
3425: }
3426:
3427: public final void multiplicativeExpression()
3428: throws RecognitionException, TokenStreamException {
3429:
3430: returnAST = null;
3431: ASTPair currentAST = new ASTPair();
3432: AST multiplicativeExpression_AST = null;
3433:
3434: unaryExpression();
3435: astFactory.addASTChild(currentAST, returnAST);
3436: {
3437: _loop162: do {
3438: if ((_tokenSet_22.member(LA(1)))) {
3439: {
3440: switch (LA(1)) {
3441: case STAR: {
3442: AST tmp150_AST = null;
3443: tmp150_AST = astFactory.create(LT(1));
3444: astFactory.makeASTRoot(currentAST,
3445: tmp150_AST);
3446: match(STAR);
3447: break;
3448: }
3449: case DIV: {
3450: AST tmp151_AST = null;
3451: tmp151_AST = astFactory.create(LT(1));
3452: astFactory.makeASTRoot(currentAST,
3453: tmp151_AST);
3454: match(DIV);
3455: break;
3456: }
3457: case MOD: {
3458: AST tmp152_AST = null;
3459: tmp152_AST = astFactory.create(LT(1));
3460: astFactory.makeASTRoot(currentAST,
3461: tmp152_AST);
3462: match(MOD);
3463: break;
3464: }
3465: default: {
3466: throw new NoViableAltException(LT(1),
3467: getFilename());
3468: }
3469: }
3470: }
3471: unaryExpression();
3472: astFactory.addASTChild(currentAST, returnAST);
3473: } else {
3474: break _loop162;
3475: }
3476:
3477: } while (true);
3478: }
3479: multiplicativeExpression_AST = (AST) currentAST.root;
3480: returnAST = multiplicativeExpression_AST;
3481: }
3482:
3483: public final void unaryExpression() throws RecognitionException,
3484: TokenStreamException {
3485:
3486: returnAST = null;
3487: ASTPair currentAST = new ASTPair();
3488: AST unaryExpression_AST = null;
3489:
3490: switch (LA(1)) {
3491: case INC: {
3492: AST tmp153_AST = null;
3493: tmp153_AST = astFactory.create(LT(1));
3494: astFactory.makeASTRoot(currentAST, tmp153_AST);
3495: match(INC);
3496: unaryExpression();
3497: astFactory.addASTChild(currentAST, returnAST);
3498: unaryExpression_AST = (AST) currentAST.root;
3499: break;
3500: }
3501: case DEC: {
3502: AST tmp154_AST = null;
3503: tmp154_AST = astFactory.create(LT(1));
3504: astFactory.makeASTRoot(currentAST, tmp154_AST);
3505: match(DEC);
3506: unaryExpression();
3507: astFactory.addASTChild(currentAST, returnAST);
3508: unaryExpression_AST = (AST) currentAST.root;
3509: break;
3510: }
3511: case MINUS: {
3512: AST tmp155_AST = null;
3513: tmp155_AST = astFactory.create(LT(1));
3514: astFactory.makeASTRoot(currentAST, tmp155_AST);
3515: match(MINUS);
3516: if (inputState.guessing == 0) {
3517: tmp155_AST.setType(UNARY_MINUS);
3518: }
3519: unaryExpression();
3520: astFactory.addASTChild(currentAST, returnAST);
3521: unaryExpression_AST = (AST) currentAST.root;
3522: break;
3523: }
3524: case PLUS: {
3525: AST tmp156_AST = null;
3526: tmp156_AST = astFactory.create(LT(1));
3527: astFactory.makeASTRoot(currentAST, tmp156_AST);
3528: match(PLUS);
3529: if (inputState.guessing == 0) {
3530: tmp156_AST.setType(UNARY_PLUS);
3531: }
3532: unaryExpression();
3533: astFactory.addASTChild(currentAST, returnAST);
3534: unaryExpression_AST = (AST) currentAST.root;
3535: break;
3536: }
3537: case LITERAL_void:
3538: case LITERAL_boolean:
3539: case LITERAL_byte:
3540: case LITERAL_char:
3541: case LITERAL_short:
3542: case LITERAL_int:
3543: case LITERAL_float:
3544: case LITERAL_long:
3545: case LITERAL_double:
3546: case IDENT:
3547: case LPAREN:
3548: case LITERAL_this :
3549: case LITERAL_super :
3550: case BNOT:
3551: case LNOT:
3552: case LITERAL_true:
3553: case LITERAL_false:
3554: case LITERAL_null:
3555: case LITERAL_new:
3556: case NUM_INT:
3557: case CHAR_LITERAL:
3558: case STRING_LITERAL:
3559: case NUM_FLOAT:
3560: case NUM_LONG:
3561: case NUM_DOUBLE: {
3562: unaryExpressionNotPlusMinus();
3563: astFactory.addASTChild(currentAST, returnAST);
3564: unaryExpression_AST = (AST) currentAST.root;
3565: break;
3566: }
3567: default: {
3568: throw new NoViableAltException(LT(1), getFilename());
3569: }
3570: }
3571: returnAST = unaryExpression_AST;
3572: }
3573:
3574: public final void unaryExpressionNotPlusMinus()
3575: throws RecognitionException, TokenStreamException {
3576:
3577: returnAST = null;
3578: ASTPair currentAST = new ASTPair();
3579: AST unaryExpressionNotPlusMinus_AST = null;
3580: Token lpb = null;
3581: AST lpb_AST = null;
3582: Token lp = null;
3583: AST lp_AST = null;
3584:
3585: switch (LA(1)) {
3586: case BNOT: {
3587: AST tmp157_AST = null;
3588: tmp157_AST = astFactory.create(LT(1));
3589: astFactory.makeASTRoot(currentAST, tmp157_AST);
3590: match(BNOT);
3591: unaryExpression();
3592: astFactory.addASTChild(currentAST, returnAST);
3593: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
3594: break;
3595: }
3596: case LNOT: {
3597: AST tmp158_AST = null;
3598: tmp158_AST = astFactory.create(LT(1));
3599: astFactory.makeASTRoot(currentAST, tmp158_AST);
3600: match(LNOT);
3601: unaryExpression();
3602: astFactory.addASTChild(currentAST, returnAST);
3603: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
3604: break;
3605: }
3606: default:
3607: boolean synPredMatched166 = false;
3608: if (((LA(1) == LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
3609: int _m166 = mark();
3610: synPredMatched166 = true;
3611: inputState.guessing++;
3612: try {
3613: {
3614: match(LPAREN);
3615: builtInTypeSpec(true);
3616: match(RPAREN);
3617: }
3618: } catch (RecognitionException pe) {
3619: synPredMatched166 = false;
3620: }
3621: rewind(_m166);
3622: inputState.guessing--;
3623: }
3624: if (synPredMatched166) {
3625: lpb = LT(1);
3626: lpb_AST = astFactory.create(lpb);
3627: astFactory.makeASTRoot(currentAST, lpb_AST);
3628: match(LPAREN);
3629: if (inputState.guessing == 0) {
3630: lpb_AST.setType(TYPECAST);
3631: }
3632: builtInTypeSpec(true);
3633: astFactory.addASTChild(currentAST, returnAST);
3634: match(RPAREN);
3635: unaryExpression();
3636: astFactory.addASTChild(currentAST, returnAST);
3637: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
3638: } else {
3639: boolean synPredMatched168 = false;
3640: if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
3641: int _m168 = mark();
3642: synPredMatched168 = true;
3643: inputState.guessing++;
3644: try {
3645: {
3646: match(LPAREN);
3647: classTypeSpec(true);
3648: match(RPAREN);
3649: unaryExpressionNotPlusMinus();
3650: }
3651: } catch (RecognitionException pe) {
3652: synPredMatched168 = false;
3653: }
3654: rewind(_m168);
3655: inputState.guessing--;
3656: }
3657: if (synPredMatched168) {
3658: lp = LT(1);
3659: lp_AST = astFactory.create(lp);
3660: astFactory.makeASTRoot(currentAST, lp_AST);
3661: match(LPAREN);
3662: if (inputState.guessing == 0) {
3663: lp_AST.setType(TYPECAST);
3664: }
3665: classTypeSpec(true);
3666: astFactory.addASTChild(currentAST, returnAST);
3667: match(RPAREN);
3668: unaryExpressionNotPlusMinus();
3669: astFactory.addASTChild(currentAST, returnAST);
3670: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
3671: } else if ((_tokenSet_23.member(LA(1)))
3672: && (_tokenSet_24.member(LA(2)))) {
3673: postfixExpression();
3674: astFactory.addASTChild(currentAST, returnAST);
3675: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
3676: } else {
3677: throw new NoViableAltException(LT(1), getFilename());
3678: }
3679: }
3680: }
3681: returnAST = unaryExpressionNotPlusMinus_AST;
3682: }
3683:
3684: public final void postfixExpression() throws RecognitionException,
3685: TokenStreamException {
3686:
3687: returnAST = null;
3688: ASTPair currentAST = new ASTPair();
3689: AST postfixExpression_AST = null;
3690: Token lp = null;
3691: AST lp_AST = null;
3692: Token lp3 = null;
3693: AST lp3_AST = null;
3694: Token lps = null;
3695: AST lps_AST = null;
3696: Token lb = null;
3697: AST lb_AST = null;
3698: Token in = null;
3699: AST in_AST = null;
3700: Token de = null;
3701: AST de_AST = null;
3702:
3703: primaryExpression();
3704: astFactory.addASTChild(currentAST, returnAST);
3705: {
3706: _loop174: do {
3707: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
3708: AST tmp161_AST = null;
3709: tmp161_AST = astFactory.create(LT(1));
3710: astFactory.makeASTRoot(currentAST, tmp161_AST);
3711: match(DOT);
3712: AST tmp162_AST = null;
3713: tmp162_AST = astFactory.create(LT(1));
3714: astFactory.addASTChild(currentAST, tmp162_AST);
3715: match(IDENT);
3716: {
3717: switch (LA(1)) {
3718: case LPAREN: {
3719: lp = LT(1);
3720: lp_AST = astFactory.create(lp);
3721: astFactory.makeASTRoot(currentAST, lp_AST);
3722: match(LPAREN);
3723: if (inputState.guessing == 0) {
3724: lp_AST.setType(METHOD_CALL);
3725: }
3726: argList();
3727: astFactory.addASTChild(currentAST,
3728: returnAST);
3729: match(RPAREN);
3730: break;
3731: }
3732: case SEMI:
3733: case LBRACK:
3734: case RBRACK:
3735: case DOT:
3736: case STAR:
3737: case RCURLY:
3738: case COMMA:
3739: case RPAREN:
3740: case ASSIGN:
3741: case COLON:
3742: case PLUS_ASSIGN:
3743: case MINUS_ASSIGN:
3744: case STAR_ASSIGN:
3745: case DIV_ASSIGN:
3746: case MOD_ASSIGN:
3747: case SR_ASSIGN:
3748: case BSR_ASSIGN:
3749: case SL_ASSIGN:
3750: case BAND_ASSIGN:
3751: case BXOR_ASSIGN:
3752: case BOR_ASSIGN:
3753: case QUESTION:
3754: case LOR:
3755: case LAND:
3756: case BOR:
3757: case BXOR:
3758: case BAND:
3759: case NOT_EQUAL:
3760: case EQUAL:
3761: case LT:
3762: case GT:
3763: case LE:
3764: case GE:
3765: case LITERAL_instanceof :
3766: case SL:
3767: case SR:
3768: case BSR:
3769: case PLUS:
3770: case MINUS:
3771: case DIV:
3772: case MOD:
3773: case INC:
3774: case DEC: {
3775: break;
3776: }
3777: default: {
3778: throw new NoViableAltException(LT(1),
3779: getFilename());
3780: }
3781: }
3782: }
3783: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_this )) {
3784: AST tmp164_AST = null;
3785: tmp164_AST = astFactory.create(LT(1));
3786: astFactory.makeASTRoot(currentAST, tmp164_AST);
3787: match(DOT);
3788: AST tmp165_AST = null;
3789: tmp165_AST = astFactory.create(LT(1));
3790: astFactory.addASTChild(currentAST, tmp165_AST);
3791: match(LITERAL_this );
3792: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_super )) {
3793: AST tmp166_AST = null;
3794: tmp166_AST = astFactory.create(LT(1));
3795: astFactory.makeASTRoot(currentAST, tmp166_AST);
3796: match(DOT);
3797: AST tmp167_AST = null;
3798: tmp167_AST = astFactory.create(LT(1));
3799: astFactory.addASTChild(currentAST, tmp167_AST);
3800: match(LITERAL_super );
3801: {
3802: switch (LA(1)) {
3803: case LPAREN: {
3804: lp3 = LT(1);
3805: lp3_AST = astFactory.create(lp3);
3806: astFactory.makeASTRoot(currentAST, lp3_AST);
3807: match(LPAREN);
3808: argList();
3809: astFactory.addASTChild(currentAST,
3810: returnAST);
3811: match(RPAREN);
3812: if (inputState.guessing == 0) {
3813: lp3_AST.setType(SUPER_CTOR_CALL);
3814: }
3815: break;
3816: }
3817: case DOT: {
3818: AST tmp169_AST = null;
3819: tmp169_AST = astFactory.create(LT(1));
3820: astFactory.makeASTRoot(currentAST,
3821: tmp169_AST);
3822: match(DOT);
3823: AST tmp170_AST = null;
3824: tmp170_AST = astFactory.create(LT(1));
3825: astFactory.addASTChild(currentAST,
3826: tmp170_AST);
3827: match(IDENT);
3828: {
3829: switch (LA(1)) {
3830: case LPAREN: {
3831: lps = LT(1);
3832: lps_AST = astFactory.create(lps);
3833: astFactory.makeASTRoot(currentAST,
3834: lps_AST);
3835: match(LPAREN);
3836: if (inputState.guessing == 0) {
3837: lps_AST.setType(METHOD_CALL);
3838: }
3839: argList();
3840: astFactory.addASTChild(currentAST,
3841: returnAST);
3842: match(RPAREN);
3843: break;
3844: }
3845: case SEMI:
3846: case LBRACK:
3847: case RBRACK:
3848: case DOT:
3849: case STAR:
3850: case RCURLY:
3851: case COMMA:
3852: case RPAREN:
3853: case ASSIGN:
3854: case COLON:
3855: case PLUS_ASSIGN:
3856: case MINUS_ASSIGN:
3857: case STAR_ASSIGN:
3858: case DIV_ASSIGN:
3859: case MOD_ASSIGN:
3860: case SR_ASSIGN:
3861: case BSR_ASSIGN:
3862: case SL_ASSIGN:
3863: case BAND_ASSIGN:
3864: case BXOR_ASSIGN:
3865: case BOR_ASSIGN:
3866: case QUESTION:
3867: case LOR:
3868: case LAND:
3869: case BOR:
3870: case BXOR:
3871: case BAND:
3872: case NOT_EQUAL:
3873: case EQUAL:
3874: case LT:
3875: case GT:
3876: case LE:
3877: case GE:
3878: case LITERAL_instanceof :
3879: case SL:
3880: case SR:
3881: case BSR:
3882: case PLUS:
3883: case MINUS:
3884: case DIV:
3885: case MOD:
3886: case INC:
3887: case DEC: {
3888: break;
3889: }
3890: default: {
3891: throw new NoViableAltException(
3892: LT(1), getFilename());
3893: }
3894: }
3895: }
3896: break;
3897: }
3898: default: {
3899: throw new NoViableAltException(LT(1),
3900: getFilename());
3901: }
3902: }
3903: }
3904: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_new)) {
3905: AST tmp172_AST = null;
3906: tmp172_AST = astFactory.create(LT(1));
3907: astFactory.makeASTRoot(currentAST, tmp172_AST);
3908: match(DOT);
3909: newExpression();
3910: astFactory.addASTChild(currentAST, returnAST);
3911: } else if ((LA(1) == LBRACK)) {
3912: lb = LT(1);
3913: lb_AST = astFactory.create(lb);
3914: astFactory.makeASTRoot(currentAST, lb_AST);
3915: match(LBRACK);
3916: if (inputState.guessing == 0) {
3917: lb_AST.setType(INDEX_OP);
3918: }
3919: expression();
3920: astFactory.addASTChild(currentAST, returnAST);
3921: match(RBRACK);
3922: } else {
3923: break _loop174;
3924: }
3925:
3926: } while (true);
3927: }
3928: {
3929: switch (LA(1)) {
3930: case INC: {
3931: in = LT(1);
3932: in_AST = astFactory.create(in);
3933: astFactory.makeASTRoot(currentAST, in_AST);
3934: match(INC);
3935: if (inputState.guessing == 0) {
3936: in_AST.setType(POST_INC);
3937: }
3938: break;
3939: }
3940: case DEC: {
3941: de = LT(1);
3942: de_AST = astFactory.create(de);
3943: astFactory.makeASTRoot(currentAST, de_AST);
3944: match(DEC);
3945: if (inputState.guessing == 0) {
3946: de_AST.setType(POST_DEC);
3947: }
3948: break;
3949: }
3950: case SEMI:
3951: case RBRACK:
3952: case STAR:
3953: case RCURLY:
3954: case COMMA:
3955: case RPAREN:
3956: case ASSIGN:
3957: case COLON:
3958: case PLUS_ASSIGN:
3959: case MINUS_ASSIGN:
3960: case STAR_ASSIGN:
3961: case DIV_ASSIGN:
3962: case MOD_ASSIGN:
3963: case SR_ASSIGN:
3964: case BSR_ASSIGN:
3965: case SL_ASSIGN:
3966: case BAND_ASSIGN:
3967: case BXOR_ASSIGN:
3968: case BOR_ASSIGN:
3969: case QUESTION:
3970: case LOR:
3971: case LAND:
3972: case BOR:
3973: case BXOR:
3974: case BAND:
3975: case NOT_EQUAL:
3976: case EQUAL:
3977: case LT:
3978: case GT:
3979: case LE:
3980: case GE:
3981: case LITERAL_instanceof :
3982: case SL:
3983: case SR:
3984: case BSR:
3985: case PLUS:
3986: case MINUS:
3987: case DIV:
3988: case MOD: {
3989: break;
3990: }
3991: default: {
3992: throw new NoViableAltException(LT(1), getFilename());
3993: }
3994: }
3995: }
3996: postfixExpression_AST = (AST) currentAST.root;
3997: returnAST = postfixExpression_AST;
3998: }
3999:
4000: public final void primaryExpression() throws RecognitionException,
4001: TokenStreamException {
4002:
4003: returnAST = null;
4004: ASTPair currentAST = new ASTPair();
4005: AST primaryExpression_AST = null;
4006: Token lbt = null;
4007: AST lbt_AST = null;
4008:
4009: switch (LA(1)) {
4010: case IDENT: {
4011: identPrimary();
4012: astFactory.addASTChild(currentAST, returnAST);
4013: {
4014: if ((LA(1) == DOT) && (LA(2) == LITERAL_class)) {
4015: AST tmp174_AST = null;
4016: tmp174_AST = astFactory.create(LT(1));
4017: astFactory.makeASTRoot(currentAST, tmp174_AST);
4018: match(DOT);
4019: AST tmp175_AST = null;
4020: tmp175_AST = astFactory.create(LT(1));
4021: astFactory.addASTChild(currentAST, tmp175_AST);
4022: match(LITERAL_class);
4023: } else if ((_tokenSet_25.member(LA(1)))
4024: && (_tokenSet_26.member(LA(2)))) {
4025: } else {
4026: throw new NoViableAltException(LT(1), getFilename());
4027: }
4028:
4029: }
4030: primaryExpression_AST = (AST) currentAST.root;
4031: break;
4032: }
4033: case NUM_INT:
4034: case CHAR_LITERAL:
4035: case STRING_LITERAL:
4036: case NUM_FLOAT:
4037: case NUM_LONG:
4038: case NUM_DOUBLE: {
4039: constant();
4040: astFactory.addASTChild(currentAST, returnAST);
4041: primaryExpression_AST = (AST) currentAST.root;
4042: break;
4043: }
4044: case LITERAL_true: {
4045: AST tmp176_AST = null;
4046: tmp176_AST = astFactory.create(LT(1));
4047: astFactory.addASTChild(currentAST, tmp176_AST);
4048: match(LITERAL_true);
4049: primaryExpression_AST = (AST) currentAST.root;
4050: break;
4051: }
4052: case LITERAL_false: {
4053: AST tmp177_AST = null;
4054: tmp177_AST = astFactory.create(LT(1));
4055: astFactory.addASTChild(currentAST, tmp177_AST);
4056: match(LITERAL_false);
4057: primaryExpression_AST = (AST) currentAST.root;
4058: break;
4059: }
4060: case LITERAL_null: {
4061: AST tmp178_AST = null;
4062: tmp178_AST = astFactory.create(LT(1));
4063: astFactory.addASTChild(currentAST, tmp178_AST);
4064: match(LITERAL_null);
4065: primaryExpression_AST = (AST) currentAST.root;
4066: break;
4067: }
4068: case LITERAL_new: {
4069: newExpression();
4070: astFactory.addASTChild(currentAST, returnAST);
4071: primaryExpression_AST = (AST) currentAST.root;
4072: break;
4073: }
4074: case LITERAL_this : {
4075: AST tmp179_AST = null;
4076: tmp179_AST = astFactory.create(LT(1));
4077: astFactory.addASTChild(currentAST, tmp179_AST);
4078: match(LITERAL_this );
4079: primaryExpression_AST = (AST) currentAST.root;
4080: break;
4081: }
4082: case LITERAL_super : {
4083: AST tmp180_AST = null;
4084: tmp180_AST = astFactory.create(LT(1));
4085: astFactory.addASTChild(currentAST, tmp180_AST);
4086: match(LITERAL_super );
4087: primaryExpression_AST = (AST) currentAST.root;
4088: break;
4089: }
4090: case LPAREN: {
4091: match(LPAREN);
4092: assignmentExpression();
4093: astFactory.addASTChild(currentAST, returnAST);
4094: match(RPAREN);
4095: primaryExpression_AST = (AST) currentAST.root;
4096: break;
4097: }
4098: case LITERAL_void:
4099: case LITERAL_boolean:
4100: case LITERAL_byte:
4101: case LITERAL_char:
4102: case LITERAL_short:
4103: case LITERAL_int:
4104: case LITERAL_float:
4105: case LITERAL_long:
4106: case LITERAL_double: {
4107: builtInType();
4108: astFactory.addASTChild(currentAST, returnAST);
4109: {
4110: _loop179: do {
4111: if ((LA(1) == LBRACK)) {
4112: lbt = LT(1);
4113: lbt_AST = astFactory.create(lbt);
4114: astFactory.makeASTRoot(currentAST, lbt_AST);
4115: match(LBRACK);
4116: if (inputState.guessing == 0) {
4117: lbt_AST.setType(ARRAY_DECLARATOR);
4118: }
4119: match(RBRACK);
4120: } else {
4121: break _loop179;
4122: }
4123:
4124: } while (true);
4125: }
4126: AST tmp184_AST = null;
4127: tmp184_AST = astFactory.create(LT(1));
4128: astFactory.makeASTRoot(currentAST, tmp184_AST);
4129: match(DOT);
4130: AST tmp185_AST = null;
4131: tmp185_AST = astFactory.create(LT(1));
4132: astFactory.addASTChild(currentAST, tmp185_AST);
4133: match(LITERAL_class);
4134: primaryExpression_AST = (AST) currentAST.root;
4135: break;
4136: }
4137: default: {
4138: throw new NoViableAltException(LT(1), getFilename());
4139: }
4140: }
4141: returnAST = primaryExpression_AST;
4142: }
4143:
4144: /** object instantiation.
4145: * Trees are built as illustrated by the following input/tree pairs:
4146: *
4147: * new T()
4148: *
4149: * new
4150: * |
4151: * T -- ELIST
4152: * |
4153: * arg1 -- arg2 -- .. -- argn
4154: *
4155: * new int[]
4156: *
4157: * new
4158: * |
4159: * int -- ARRAY_DECLARATOR
4160: *
4161: * new int[] {1,2}
4162: *
4163: * new
4164: * |
4165: * int -- ARRAY_DECLARATOR -- ARRAY_INIT
4166: * |
4167: * EXPR -- EXPR
4168: * | |
4169: * 1 2
4170: *
4171: * new int[3]
4172: * new
4173: * |
4174: * int -- ARRAY_DECLARATOR
4175: * |
4176: * EXPR
4177: * |
4178: * 3
4179: *
4180: * new int[1][2]
4181: *
4182: * new
4183: * |
4184: * int -- ARRAY_DECLARATOR
4185: * |
4186: * ARRAY_DECLARATOR -- EXPR
4187: * | |
4188: * EXPR 1
4189: * |
4190: * 2
4191: *
4192: */
4193: public final void newExpression() throws RecognitionException,
4194: TokenStreamException {
4195:
4196: returnAST = null;
4197: ASTPair currentAST = new ASTPair();
4198: AST newExpression_AST = null;
4199:
4200: AST tmp186_AST = null;
4201: tmp186_AST = astFactory.create(LT(1));
4202: astFactory.makeASTRoot(currentAST, tmp186_AST);
4203: match(LITERAL_new);
4204: type();
4205: astFactory.addASTChild(currentAST, returnAST);
4206: {
4207: switch (LA(1)) {
4208: case LPAREN: {
4209: match(LPAREN);
4210: argList();
4211: astFactory.addASTChild(currentAST, returnAST);
4212: match(RPAREN);
4213: {
4214: switch (LA(1)) {
4215: case LCURLY: {
4216: classBlock();
4217: astFactory.addASTChild(currentAST, returnAST);
4218: break;
4219: }
4220: case SEMI:
4221: case LBRACK:
4222: case RBRACK:
4223: case DOT:
4224: case STAR:
4225: case RCURLY:
4226: case COMMA:
4227: case RPAREN:
4228: case ASSIGN:
4229: case COLON:
4230: case PLUS_ASSIGN:
4231: case MINUS_ASSIGN:
4232: case STAR_ASSIGN:
4233: case DIV_ASSIGN:
4234: case MOD_ASSIGN:
4235: case SR_ASSIGN:
4236: case BSR_ASSIGN:
4237: case SL_ASSIGN:
4238: case BAND_ASSIGN:
4239: case BXOR_ASSIGN:
4240: case BOR_ASSIGN:
4241: case QUESTION:
4242: case LOR:
4243: case LAND:
4244: case BOR:
4245: case BXOR:
4246: case BAND:
4247: case NOT_EQUAL:
4248: case EQUAL:
4249: case LT:
4250: case GT:
4251: case LE:
4252: case GE:
4253: case LITERAL_instanceof :
4254: case SL:
4255: case SR:
4256: case BSR:
4257: case PLUS:
4258: case MINUS:
4259: case DIV:
4260: case MOD:
4261: case INC:
4262: case DEC: {
4263: break;
4264: }
4265: default: {
4266: throw new NoViableAltException(LT(1),
4267: getFilename());
4268: }
4269: }
4270: }
4271: break;
4272: }
4273: case LBRACK: {
4274: newArrayDeclarator();
4275: astFactory.addASTChild(currentAST, returnAST);
4276: {
4277: switch (LA(1)) {
4278: case LCURLY: {
4279: arrayInitializer();
4280: astFactory.addASTChild(currentAST, returnAST);
4281: break;
4282: }
4283: case SEMI:
4284: case LBRACK:
4285: case RBRACK:
4286: case DOT:
4287: case STAR:
4288: case RCURLY:
4289: case COMMA:
4290: case RPAREN:
4291: case ASSIGN:
4292: case COLON:
4293: case PLUS_ASSIGN:
4294: case MINUS_ASSIGN:
4295: case STAR_ASSIGN:
4296: case DIV_ASSIGN:
4297: case MOD_ASSIGN:
4298: case SR_ASSIGN:
4299: case BSR_ASSIGN:
4300: case SL_ASSIGN:
4301: case BAND_ASSIGN:
4302: case BXOR_ASSIGN:
4303: case BOR_ASSIGN:
4304: case QUESTION:
4305: case LOR:
4306: case LAND:
4307: case BOR:
4308: case BXOR:
4309: case BAND:
4310: case NOT_EQUAL:
4311: case EQUAL:
4312: case LT:
4313: case GT:
4314: case LE:
4315: case GE:
4316: case LITERAL_instanceof :
4317: case SL:
4318: case SR:
4319: case BSR:
4320: case PLUS:
4321: case MINUS:
4322: case DIV:
4323: case MOD:
4324: case INC:
4325: case DEC: {
4326: break;
4327: }
4328: default: {
4329: throw new NoViableAltException(LT(1),
4330: getFilename());
4331: }
4332: }
4333: }
4334: break;
4335: }
4336: default: {
4337: throw new NoViableAltException(LT(1), getFilename());
4338: }
4339: }
4340: }
4341: newExpression_AST = (AST) currentAST.root;
4342: returnAST = newExpression_AST;
4343: }
4344:
4345: /** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
4346: * and a.b.c.class refs. Also this(...) and super(...). Match
4347: * this or super.
4348: */
4349: public final void identPrimary() throws RecognitionException,
4350: TokenStreamException {
4351:
4352: returnAST = null;
4353: ASTPair currentAST = new ASTPair();
4354: AST identPrimary_AST = null;
4355: Token lp = null;
4356: AST lp_AST = null;
4357: Token lbc = null;
4358: AST lbc_AST = null;
4359:
4360: AST tmp189_AST = null;
4361: tmp189_AST = astFactory.create(LT(1));
4362: astFactory.addASTChild(currentAST, tmp189_AST);
4363: match(IDENT);
4364: {
4365: _loop182: do {
4366: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
4367: AST tmp190_AST = null;
4368: tmp190_AST = astFactory.create(LT(1));
4369: astFactory.makeASTRoot(currentAST, tmp190_AST);
4370: match(DOT);
4371: AST tmp191_AST = null;
4372: tmp191_AST = astFactory.create(LT(1));
4373: astFactory.addASTChild(currentAST, tmp191_AST);
4374: match(IDENT);
4375: } else {
4376: break _loop182;
4377: }
4378:
4379: } while (true);
4380: }
4381: {
4382: if ((LA(1) == LPAREN)) {
4383: {
4384: lp = LT(1);
4385: lp_AST = astFactory.create(lp);
4386: astFactory.makeASTRoot(currentAST, lp_AST);
4387: match(LPAREN);
4388: if (inputState.guessing == 0) {
4389: lp_AST.setType(METHOD_CALL);
4390: }
4391: argList();
4392: astFactory.addASTChild(currentAST, returnAST);
4393: match(RPAREN);
4394: }
4395: } else if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
4396: {
4397: int _cnt186 = 0;
4398: _loop186: do {
4399: if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
4400: lbc = LT(1);
4401: lbc_AST = astFactory.create(lbc);
4402: astFactory.makeASTRoot(currentAST, lbc_AST);
4403: match(LBRACK);
4404: if (inputState.guessing == 0) {
4405: lbc_AST.setType(ARRAY_DECLARATOR);
4406: }
4407: match(RBRACK);
4408: } else {
4409: if (_cnt186 >= 1) {
4410: break _loop186;
4411: } else {
4412: throw new NoViableAltException(LT(1),
4413: getFilename());
4414: }
4415: }
4416:
4417: _cnt186++;
4418: } while (true);
4419: }
4420: } else if ((_tokenSet_25.member(LA(1)))
4421: && (_tokenSet_26.member(LA(2)))) {
4422: } else {
4423: throw new NoViableAltException(LT(1), getFilename());
4424: }
4425:
4426: }
4427: identPrimary_AST = (AST) currentAST.root;
4428: returnAST = identPrimary_AST;
4429: }
4430:
4431: public final void constant() throws RecognitionException,
4432: TokenStreamException {
4433:
4434: returnAST = null;
4435: ASTPair currentAST = new ASTPair();
4436: AST constant_AST = null;
4437:
4438: switch (LA(1)) {
4439: case NUM_INT: {
4440: AST tmp194_AST = null;
4441: tmp194_AST = astFactory.create(LT(1));
4442: astFactory.addASTChild(currentAST, tmp194_AST);
4443: match(NUM_INT);
4444: constant_AST = (AST) currentAST.root;
4445: break;
4446: }
4447: case CHAR_LITERAL: {
4448: AST tmp195_AST = null;
4449: tmp195_AST = astFactory.create(LT(1));
4450: astFactory.addASTChild(currentAST, tmp195_AST);
4451: match(CHAR_LITERAL);
4452: constant_AST = (AST) currentAST.root;
4453: break;
4454: }
4455: case STRING_LITERAL: {
4456: AST tmp196_AST = null;
4457: tmp196_AST = astFactory.create(LT(1));
4458: astFactory.addASTChild(currentAST, tmp196_AST);
4459: match(STRING_LITERAL);
4460: constant_AST = (AST) currentAST.root;
4461: break;
4462: }
4463: case NUM_FLOAT: {
4464: AST tmp197_AST = null;
4465: tmp197_AST = astFactory.create(LT(1));
4466: astFactory.addASTChild(currentAST, tmp197_AST);
4467: match(NUM_FLOAT);
4468: constant_AST = (AST) currentAST.root;
4469: break;
4470: }
4471: case NUM_LONG: {
4472: AST tmp198_AST = null;
4473: tmp198_AST = astFactory.create(LT(1));
4474: astFactory.addASTChild(currentAST, tmp198_AST);
4475: match(NUM_LONG);
4476: constant_AST = (AST) currentAST.root;
4477: break;
4478: }
4479: case NUM_DOUBLE: {
4480: AST tmp199_AST = null;
4481: tmp199_AST = astFactory.create(LT(1));
4482: astFactory.addASTChild(currentAST, tmp199_AST);
4483: match(NUM_DOUBLE);
4484: constant_AST = (AST) currentAST.root;
4485: break;
4486: }
4487: default: {
4488: throw new NoViableAltException(LT(1), getFilename());
4489: }
4490: }
4491: returnAST = constant_AST;
4492: }
4493:
4494: public final void newArrayDeclarator() throws RecognitionException,
4495: TokenStreamException {
4496:
4497: returnAST = null;
4498: ASTPair currentAST = new ASTPair();
4499: AST newArrayDeclarator_AST = null;
4500: Token lb = null;
4501: AST lb_AST = null;
4502:
4503: {
4504: int _cnt196 = 0;
4505: _loop196: do {
4506: if ((LA(1) == LBRACK) && (_tokenSet_27.member(LA(2)))) {
4507: lb = LT(1);
4508: lb_AST = astFactory.create(lb);
4509: astFactory.makeASTRoot(currentAST, lb_AST);
4510: match(LBRACK);
4511: if (inputState.guessing == 0) {
4512: lb_AST.setType(ARRAY_DECLARATOR);
4513: }
4514: {
4515: switch (LA(1)) {
4516: case LITERAL_void:
4517: case LITERAL_boolean:
4518: case LITERAL_byte:
4519: case LITERAL_char:
4520: case LITERAL_short:
4521: case LITERAL_int:
4522: case LITERAL_float:
4523: case LITERAL_long:
4524: case LITERAL_double:
4525: case IDENT:
4526: case LPAREN:
4527: case LITERAL_this :
4528: case LITERAL_super :
4529: case PLUS:
4530: case MINUS:
4531: case INC:
4532: case DEC:
4533: case BNOT:
4534: case LNOT:
4535: case LITERAL_true:
4536: case LITERAL_false:
4537: case LITERAL_null:
4538: case LITERAL_new:
4539: case NUM_INT:
4540: case CHAR_LITERAL:
4541: case STRING_LITERAL:
4542: case NUM_FLOAT:
4543: case NUM_LONG:
4544: case NUM_DOUBLE: {
4545: expression();
4546: astFactory.addASTChild(currentAST,
4547: returnAST);
4548: break;
4549: }
4550: case RBRACK: {
4551: break;
4552: }
4553: default: {
4554: throw new NoViableAltException(LT(1),
4555: getFilename());
4556: }
4557: }
4558: }
4559: match(RBRACK);
4560: } else {
4561: if (_cnt196 >= 1) {
4562: break _loop196;
4563: } else {
4564: throw new NoViableAltException(LT(1),
4565: getFilename());
4566: }
4567: }
4568:
4569: _cnt196++;
4570: } while (true);
4571: }
4572: newArrayDeclarator_AST = (AST) currentAST.root;
4573: returnAST = newArrayDeclarator_AST;
4574: }
4575:
4576: public static final String[] _tokenNames = { "<0>", "EOF", "<2>",
4577: "NULL_TREE_LOOKAHEAD", "BLOCK", "MODIFIERS", "OBJBLOCK",
4578: "SLIST", "CTOR_DEF", "METHOD_DEF", "VARIABLE_DEF",
4579: "INSTANCE_INIT", "STATIC_INIT", "TYPE", "CLASS_DEF",
4580: "INTERFACE_DEF", "PACKAGE_DEF", "ARRAY_DECLARATOR",
4581: "EXTENDS_CLAUSE", "IMPLEMENTS_CLAUSE", "PARAMETERS",
4582: "PARAMETER_DEF", "LABELED_STAT", "TYPECAST", "INDEX_OP",
4583: "POST_INC", "POST_DEC", "METHOD_CALL", "EXPR",
4584: "ARRAY_INIT", "IMPORT", "UNARY_MINUS", "UNARY_PLUS",
4585: "CASE_GROUP", "ELIST", "FOR_INIT", "FOR_CONDITION",
4586: "FOR_ITERATOR", "EMPTY_STAT", "\"final\"", "\"abstract\"",
4587: "\"strictfp\"", "SUPER_CTOR_CALL", "CTOR_CALL",
4588: "\"package\"", "SEMI", "\"import\"", "LBRACK", "RBRACK",
4589: "\"void\"", "\"boolean\"", "\"byte\"", "\"char\"",
4590: "\"short\"", "\"int\"", "\"float\"", "\"long\"",
4591: "\"double\"", "IDENT", "DOT", "STAR", "\"private\"",
4592: "\"public\"", "\"protected\"", "\"static\"",
4593: "\"transient\"", "\"native\"", "\"threadsafe\"",
4594: "\"synchronized\"", "\"volatile\"", "\"class\"",
4595: "\"extends\"", "\"interface\"", "LCURLY", "RCURLY",
4596: "COMMA", "\"implements\"", "LPAREN", "RPAREN", "\"this\"",
4597: "\"super\"", "ASSIGN", "\"throws\"", "COLON", "\"if\"",
4598: "\"else\"", "\"for\"", "\"while\"", "\"do\"", "\"break\"",
4599: "\"continue\"", "\"return\"", "\"switch\"", "\"throw\"",
4600: "\"case\"", "\"default\"", "\"try\"", "\"finally\"",
4601: "\"catch\"", "PLUS_ASSIGN", "MINUS_ASSIGN", "STAR_ASSIGN",
4602: "DIV_ASSIGN", "MOD_ASSIGN", "SR_ASSIGN", "BSR_ASSIGN",
4603: "SL_ASSIGN", "BAND_ASSIGN", "BXOR_ASSIGN", "BOR_ASSIGN",
4604: "QUESTION", "LOR", "LAND", "BOR", "BXOR", "BAND",
4605: "NOT_EQUAL", "EQUAL", "LT", "GT", "LE", "GE",
4606: "\"instanceof\"", "SL", "SR", "BSR", "PLUS", "MINUS",
4607: "DIV", "MOD", "INC", "DEC", "BNOT", "LNOT", "\"true\"",
4608: "\"false\"", "\"null\"", "\"new\"", "NUM_INT",
4609: "CHAR_LITERAL", "STRING_LITERAL", "NUM_FLOAT", "NUM_LONG",
4610: "NUM_DOUBLE", "WS", "SL_COMMENT", "ML_COMMENT", "ESC",
4611: "HEX_DIGIT", "VOCAB", "EXPONENT", "FLOAT_SUFFIX" };
4612:
4613: protected void buildTokenTypeASTClassMap() {
4614: tokenTypeToASTClassMap = null;
4615: };
4616:
4617: private static final long[] mk_tokenSet_0() {
4618: long[] data = { -2305803976550907904L, 383L, 0L, 0L };
4619: return data;
4620: }
4621:
4622: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
4623:
4624: private static final long[] mk_tokenSet_1() {
4625: long[] data = { -2305733607806730238L, 383L, 0L, 0L };
4626: return data;
4627: }
4628:
4629: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
4630:
4631: private static final long[] mk_tokenSet_2() {
4632: long[] data = { -2305803976550907902L, 383L, 0L, 0L };
4633: return data;
4634: }
4635:
4636: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
4637:
4638: private static final long[] mk_tokenSet_3() {
4639: long[] data = { -2305839160922996736L, 63L, 0L, 0L };
4640: return data;
4641: }
4642:
4643: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
4644:
4645: private static final long[] mk_tokenSet_4() {
4646: long[] data = { -1729941358572994560L, 383L, 0L, 0L };
4647: return data;
4648: }
4649:
4650: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
4651:
4652: private static final long[] mk_tokenSet_5() {
4653: long[] data = { -1153339868781215744L, 8575L, 0L, 0L };
4654: return data;
4655: }
4656:
4657: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
4658:
4659: private static final long[] mk_tokenSet_6() {
4660: long[] data = { 864831865943490560L, 0L, 0L };
4661: return data;
4662: }
4663:
4664: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
4665:
4666: private static final long[] mk_tokenSet_7() {
4667: long[] data = { 175921860444160L, 133120L, 0L, 0L };
4668: return data;
4669: }
4670:
4671: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
4672:
4673: private static final long[] mk_tokenSet_8() {
4674: long[] data = { -1729906174200905728L, -4611686013061716353L,
4675: 65532L, 0L, 0L, 0L };
4676: return data;
4677: }
4678:
4679: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
4680:
4681: private static final long[] mk_tokenSet_9() {
4682: long[] data = { -383179802279936L, -28993411201L, 65535L, 0L,
4683: 0L, 0L };
4684: return data;
4685: }
4686:
4687: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
4688:
4689: private static final long[] mk_tokenSet_10() {
4690: long[] data = { -1729906174200905728L, -4611686013061717377L,
4691: 65532L, 0L, 0L, 0L };
4692: return data;
4693: }
4694:
4695: public static final BitSet _tokenSet_10 = new BitSet(
4696: mk_tokenSet_10());
4697:
4698: private static final long[] mk_tokenSet_11() {
4699: long[] data = { -1729906174200905728L, -4611686009838393729L,
4700: 65532L, 0L, 0L, 0L };
4701: return data;
4702: }
4703:
4704: public static final BitSet _tokenSet_11 = new BitSet(
4705: mk_tokenSet_11());
4706:
4707: private static final long[] mk_tokenSet_12() {
4708: long[] data = { -383179802279936L, -284801L, 65535L, 0L, 0L, 0L };
4709: return data;
4710: }
4711:
4712: public static final BitSet _tokenSet_12 = new BitSet(
4713: mk_tokenSet_12());
4714:
4715: private static final long[] mk_tokenSet_13() {
4716: long[] data = { -1729941358572994560L, 63L, 0L, 0L };
4717: return data;
4718: }
4719:
4720: public static final BitSet _tokenSet_13 = new BitSet(
4721: mk_tokenSet_13());
4722:
4723: private static final long[] mk_tokenSet_14() {
4724: long[] data = { -1153339868781215744L, 63L, 0L, 0L };
4725: return data;
4726: }
4727:
4728: public static final BitSet _tokenSet_14 = new BitSet(
4729: mk_tokenSet_14());
4730:
4731: private static final long[] mk_tokenSet_15() {
4732: long[] data = { 575897802350002176L, -4611686018427281408L,
4733: 65532L, 0L, 0L, 0L };
4734: return data;
4735: }
4736:
4737: public static final BitSet _tokenSet_15 = new BitSet(
4738: mk_tokenSet_15());
4739:
4740: private static final long[] mk_tokenSet_16() {
4741: long[] data = { 2305455981120716800L, -34359500800L, 65535L,
4742: 0L, 0L, 0L };
4743: return data;
4744: }
4745:
4746: public static final BitSet _tokenSet_16 = new BitSet(
4747: mk_tokenSet_16());
4748:
4749: private static final long[] mk_tokenSet_17() {
4750: long[] data = { -2305839160922996736L, 127L, 0L, 0L };
4751: return data;
4752: }
4753:
4754: public static final BitSet _tokenSet_17 = new BitSet(
4755: mk_tokenSet_17());
4756:
4757: private static final long[] mk_tokenSet_18() {
4758: long[] data = { -2017608784771284992L, 127L, 0L, 0L };
4759: return data;
4760: }
4761:
4762: public static final BitSet _tokenSet_18 = new BitSet(
4763: mk_tokenSet_18());
4764:
4765: private static final long[] mk_tokenSet_19() {
4766: long[] data = { 575897802350002176L, -4611686018427280896L,
4767: 65532L, 0L, 0L, 0L };
4768: return data;
4769: }
4770:
4771: public static final BitSet _tokenSet_19 = new BitSet(
4772: mk_tokenSet_19());
4773:
4774: private static final long[] mk_tokenSet_20() {
4775: long[] data = { 2305455981120716800L, -34359498752L, 65535L,
4776: 0L, 0L, 0L };
4777: return data;
4778: }
4779:
4780: public static final BitSet _tokenSet_20 = new BitSet(
4781: mk_tokenSet_20());
4782:
4783: private static final long[] mk_tokenSet_21() {
4784: long[] data = { 575897802350002176L, -4611686018426757120L,
4785: 65532L, 0L, 0L, 0L };
4786: return data;
4787: }
4788:
4789: public static final BitSet _tokenSet_21 = new BitSet(
4790: mk_tokenSet_21());
4791:
4792: private static final long[] mk_tokenSet_22() {
4793: long[] data = { 1152921504606846976L, 0L, 3L, 0L, 0L, 0L };
4794: return data;
4795: }
4796:
4797: public static final BitSet _tokenSet_22 = new BitSet(
4798: mk_tokenSet_22());
4799:
4800: private static final long[] mk_tokenSet_23() {
4801: long[] data = { 575897802350002176L, 106496L, 65472L, 0L, 0L,
4802: 0L };
4803: return data;
4804: }
4805:
4806: public static final BitSet _tokenSet_23 = new BitSet(
4807: mk_tokenSet_23());
4808:
4809: private static final long[] mk_tokenSet_24() {
4810: long[] data = { 2305737456097427456L, -34358957056L, 65535L,
4811: 0L, 0L, 0L };
4812: return data;
4813: }
4814:
4815: public static final BitSet _tokenSet_24 = new BitSet(
4816: mk_tokenSet_24());
4817:
4818: private static final long[] mk_tokenSet_25() {
4819: long[] data = { 1729839653747425280L, -34359063552L, 15L, 0L,
4820: 0L, 0L };
4821: return data;
4822: }
4823:
4824: public static final BitSet _tokenSet_25 = new BitSet(
4825: mk_tokenSet_25());
4826:
4827: private static final long[] mk_tokenSet_26() {
4828: long[] data = { -101704825569280L, -25770070145L, 65535L, 0L,
4829: 0L, 0L };
4830: return data;
4831: }
4832:
4833: public static final BitSet _tokenSet_26 = new BitSet(
4834: mk_tokenSet_26());
4835:
4836: private static final long[] mk_tokenSet_27() {
4837: long[] data = { 576179277326712832L, -4611686018427281408L,
4838: 65532L, 0L, 0L, 0L };
4839: return data;
4840: }
4841:
4842: public static final BitSet _tokenSet_27 = new BitSet(
4843: mk_tokenSet_27());
4844:
4845: }
|