0001: // $ANTLR 2.7.2: "java.g" -> "JavaRecognizer.java"$
0002:
0003: package org.codehaus.groovy.antlr.java;
0004:
0005: import org.codehaus.groovy.antlr.*;
0006: import org.codehaus.groovy.antlr.parser.*;
0007: import java.util.*;
0008: import java.io.InputStream;
0009: import java.io.Reader;
0010: import antlr.InputBuffer;
0011: import antlr.LexerSharedInputState;
0012:
0013: import antlr.TokenBuffer;
0014: import antlr.TokenStreamException;
0015: import antlr.TokenStreamIOException;
0016: import antlr.ANTLRException;
0017: import antlr.LLkParser;
0018: import antlr.Token;
0019: import antlr.TokenStream;
0020: import antlr.RecognitionException;
0021: import antlr.NoViableAltException;
0022: import antlr.MismatchedTokenException;
0023: import antlr.SemanticException;
0024: import antlr.ParserSharedInputState;
0025: import antlr.collections.impl.BitSet;
0026: import antlr.collections.AST;
0027: import java.util.Hashtable;
0028: import antlr.ASTFactory;
0029: import antlr.ASTPair;
0030: import antlr.collections.impl.ASTArray;
0031:
0032: /** Java 1.5 Recognizer
0033: *
0034: * Run 'java Main [-showtree] directory-full-of-java-files'
0035: *
0036: * [The -showtree option pops up a Swing frame that shows
0037: * the AST constructed from the parser.]
0038: *
0039: * Run 'java Main <directory full of java files>'
0040: *
0041: * Contributing authors:
0042: * Jeremy Rayner groovy@ross-rayner.com
0043: * John Mitchell johnm@non.net
0044: * Terence Parr parrt@magelang.com
0045: * John Lilley jlilley@empathy.com
0046: * Scott Stanchfield thetick@magelang.com
0047: * Markus Mohnen mohnen@informatik.rwth-aachen.de
0048: * Peter Williams pete.williams@sun.com
0049: * Allan Jacobs Allan.Jacobs@eng.sun.com
0050: * Steve Messick messick@redhills.com
0051: * John Pybus john@pybus.org
0052: *
0053: * Version 1.00 December 9, 1997 -- initial release
0054: * Version 1.01 December 10, 1997
0055: * fixed bug in octal def (0..7 not 0..8)
0056: * Version 1.10 August 1998 (parrt)
0057: * added tree construction
0058: * fixed definition of WS,comments for mac,pc,unix newlines
0059: * added unary plus
0060: * Version 1.11 (Nov 20, 1998)
0061: * Added "shutup" option to turn off last ambig warning.
0062: * Fixed inner class def to allow named class defs as statements
0063: * synchronized requires compound not simple statement
0064: * add [] after builtInType DOT class in primaryExpression
0065: * "const" is reserved but not valid..removed from modifiers
0066: * Version 1.12 (Feb 2, 1999)
0067: * Changed LITERAL_xxx to xxx in tree grammar.
0068: * Updated java.g to use tokens {...} now for 2.6.0 (new feature).
0069: *
0070: * Version 1.13 (Apr 23, 1999)
0071: * Didn't have (stat)? for else clause in tree parser.
0072: * Didn't gen ASTs for interface extends. Updated tree parser too.
0073: * Updated to 2.6.0.
0074: * Version 1.14 (Jun 20, 1999)
0075: * Allowed final/abstract on local classes.
0076: * Removed local interfaces from methods
0077: * Put instanceof precedence where it belongs...in relationalExpr
0078: * It also had expr not type as arg; fixed it.
0079: * Missing ! on SEMI in classBlock
0080: * fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
0081: * fixed: didn't like Object[].class in parser or tree parser
0082: * Version 1.15 (Jun 26, 1999)
0083: * Screwed up rule with instanceof in it. :( Fixed.
0084: * Tree parser didn't like (expr).something; fixed.
0085: * Allowed multiple inheritance in tree grammar. oops.
0086: * Version 1.16 (August 22, 1999)
0087: * Extending an interface built a wacky tree: had extra EXTENDS.
0088: * Tree grammar didn't allow multiple superinterfaces.
0089: * Tree grammar didn't allow empty var initializer: {}
0090: * Version 1.17 (October 12, 1999)
0091: * ESC lexer rule allowed 399 max not 377 max.
0092: * java.tree.g didn't handle the expression of synchronized
0093: * statements.
0094: * Version 1.18 (August 12, 2001)
0095: * Terence updated to Java 2 Version 1.3 by
0096: * observing/combining work of Allan Jacobs and Steve
0097: * Messick. Handles 1.3 src. Summary:
0098: * o primary didn't include boolean.class kind of thing
0099: * o constructor calls parsed explicitly now:
0100: * see explicitConstructorInvocation
0101: * o add strictfp modifier
0102: * o missing objBlock after new expression in tree grammar
0103: * o merged local class definition alternatives, moved after declaration
0104: * o fixed problem with ClassName.super.field
0105: * o reordered some alternatives to make things more efficient
0106: * o long and double constants were not differentiated from int/float
0107: * o whitespace rule was inefficient: matched only one char
0108: * o add an examples directory with some nasty 1.3 cases
0109: * o made Main.java use buffered IO and a Reader for Unicode support
0110: * o supports UNICODE?
0111: * Using Unicode charVocabulay makes code file big, but only
0112: * in the bitsets at the end. I need to make ANTLR generate
0113: * unicode bitsets more efficiently.
0114: * Version 1.19 (April 25, 2002)
0115: * Terence added in nice fixes by John Pybus concerning floating
0116: * constants and problems with super() calls. John did a nice
0117: * reorg of the primary/postfix expression stuff to read better
0118: * and makes f.g.super() parse properly (it was METHOD_CALL not
0119: * a SUPER_CTOR_CALL). Also:
0120: *
0121: * o "finally" clause was a root...made it a child of "try"
0122: * o Added stuff for asserts too for Java 1.4, but *commented out*
0123: * as it is not backward compatible.
0124: *
0125: * Version 1.20 (October 27, 2002)
0126: *
0127: * Terence ended up reorging John Pybus' stuff to
0128: * remove some nondeterminisms and some syntactic predicates.
0129: * Note that the grammar is stricter now; e.g., this(...) must
0130: * be the first statement.
0131: *
0132: * Trinary ?: operator wasn't working as array name:
0133: * (isBig ? bigDigits : digits)[i];
0134: *
0135: * Checked parser/tree parser on source for
0136: * Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
0137: * and the 110k-line jGuru server source.
0138: *
0139: * Version 1.21 (October 17, 2003)
0140: * Fixed lots of problems including:
0141: * Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g
0142: * He found a problem/fix with floating point that start with 0
0143: * Ray also fixed problem that (int.class) was not recognized.
0144: * Thorsten van Ellen noticed that \n are allowed incorrectly in strings.
0145: * TJP fixed CHAR_LITERAL analogously.
0146: *
0147: * Version 1.21.2 (March, 2003)
0148: * Changes by Matt Quail to support generics (as per JDK1.5/JSR14)
0149: * Notes:
0150: * o We only allow the "extends" keyword and not the "implements"
0151: * keyword, since thats what JSR14 seems to imply.
0152: * o Thanks to Monty Zukowski for his help on the antlr-interest
0153: * mail list.
0154: * o Thanks to Alan Eliasen for testing the grammar over his
0155: * Fink source base
0156: *
0157: * Version 1.22 (July, 2004)
0158: * Changes by Michael Studman to support Java 1.5 language extensions
0159: * Notes:
0160: * o Added support for annotations types
0161: * o Finished off Matt Quail's generics enhancements to support bound type arguments
0162: * o Added support for new for statement syntax
0163: * o Added support for static import syntax
0164: * o Added support for enum types
0165: * o Tested against JDK 1.5 source base and source base of jdigraph project
0166: * o Thanks to Matt Quail for doing the hard part by doing most of the generics work
0167: *
0168: * Version 1.22.1 (July 28, 2004)
0169: * Bug/omission fixes for Java 1.5 language support
0170: * o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for
0171: * spotting this
0172: * o Fixed bug where incorrect handling of SR and BSR tokens would cause type
0173: * parameters to be recognised as type arguments.
0174: * o Enabled type parameters on constructors, annotations on enum constants
0175: * and package definitions
0176: * o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua
0177: *
0178: * Version 1.22.2 (July 28, 2004)
0179: * Slight refactoring of Java 1.5 language support
0180: * o Refactored for/"foreach" productions so that original literal "for" literal
0181: * is still used but the for sub-clauses vary by token type
0182: * o Fixed bug where type parameter was not included in generic constructor's branch of AST
0183: *
0184: * Version 1.22.3 (August 26, 2004)
0185: * Bug fixes as identified by Michael Stahl; clean up of tabs/spaces
0186: * and other refactorings
0187: * o Fixed typeParameters omission in identPrimary and newStatement
0188: * o Replaced GT reconcilliation code with simple semantic predicate
0189: * o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar
0190: * o Refactored typeDefinition production and field productions to reduce duplication
0191: *
0192: * Version 1.22.4 (October 21, 2004)
0193: * Small bux fixes
0194: * o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised()
0195: * o Added typeArguments to postfixExpression productions for anonymous inner class super
0196: * constructor invocation, e.g. new Outer().<String>super()
0197: * o Fixed bug in array declarations identified by Geoff Roy
0198: *
0199: * Version 1.22.4.j.1
0200: * Changes by Jeremy Rayner to support java2groovy tool
0201: * o I have taken java.g for Java1.5 from Michael Studman (1.22.4)
0202: * and have made some changes to enable use by java2groovy tool (Jan 2007)
0203: *
0204: * This grammar is in the PUBLIC DOMAIN
0205: */
0206: public class JavaRecognizer extends antlr.LLkParser implements
0207: JavaTokenTypes {
0208:
0209: /** This factory is the correct way to wire together a Groovy parser and lexer. */
0210: public static JavaRecognizer make(JavaLexer lexer) {
0211: JavaRecognizer parser = new JavaRecognizer(lexer.plumb());
0212: // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys
0213: parser.lexer = lexer;
0214: lexer.parser = parser;
0215: parser
0216: .setASTNodeClass("org.codehaus.groovy.antlr.GroovySourceAST");
0217: return parser;
0218: }
0219:
0220: // Create a scanner that reads from the input stream passed to us...
0221: public static JavaRecognizer make(InputStream in) {
0222: return make(new JavaLexer(in));
0223: }
0224:
0225: public static JavaRecognizer make(Reader in) {
0226: return make(new JavaLexer(in));
0227: }
0228:
0229: public static JavaRecognizer make(InputBuffer in) {
0230: return make(new JavaLexer(in));
0231: }
0232:
0233: public static JavaRecognizer make(LexerSharedInputState in) {
0234: return make(new JavaLexer(in));
0235: }
0236:
0237: private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
0238:
0239: JavaLexer lexer;
0240:
0241: public JavaLexer getLexer() {
0242: return lexer;
0243: }
0244:
0245: public void setFilename(String f) {
0246: super .setFilename(f);
0247: lexer.setFilename(f);
0248: }
0249:
0250: private SourceBuffer sourceBuffer;
0251:
0252: public void setSourceBuffer(SourceBuffer sourceBuffer) {
0253: this .sourceBuffer = sourceBuffer;
0254: }
0255:
0256: /** Create an AST node with the token type and text passed in, but
0257: * with the same background information as another supplied Token (e.g. line numbers)
0258: * to be used in place of antlr tree construction syntax,
0259: * i.e. #[TOKEN,"text"] becomes create(TOKEN,"text",anotherToken)
0260: *
0261: * todo - change antlr.ASTFactory to do this instead...
0262: */
0263: public AST create(int type, String txt, Token first, Token last) {
0264: AST t = astFactory.create(type, txt);
0265: if (t != null && first != null) {
0266: // first copy details from first token
0267: t.initialize(first);
0268: // then ensure that type and txt are specific to this new node
0269: t.initialize(type, txt);
0270: }
0271:
0272: if ((t instanceof GroovySourceAST) && last != null) {
0273: GroovySourceAST node = (GroovySourceAST) t;
0274: node.setLast(last);
0275: // This is a good point to call node.setSnippet(),
0276: // but it bulks up the AST too much for production code.
0277: }
0278: return t;
0279: }
0280:
0281: /**
0282: * Counts the number of LT seen in the typeArguments production.
0283: * It is used in semantic predicates to ensure we have seen
0284: * enough closing '>' characters; which actually may have been
0285: * either GT, SR or BSR tokens.
0286: */
0287: private int ltCounter = 0;
0288:
0289: protected JavaRecognizer(TokenBuffer tokenBuf, int k) {
0290: super (tokenBuf, k);
0291: tokenNames = _tokenNames;
0292: buildTokenTypeASTClassMap();
0293: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0294: }
0295:
0296: public JavaRecognizer(TokenBuffer tokenBuf) {
0297: this (tokenBuf, 2);
0298: }
0299:
0300: protected JavaRecognizer(TokenStream lexer, int k) {
0301: super (lexer, k);
0302: tokenNames = _tokenNames;
0303: buildTokenTypeASTClassMap();
0304: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0305: }
0306:
0307: public JavaRecognizer(TokenStream lexer) {
0308: this (lexer, 2);
0309: }
0310:
0311: public JavaRecognizer(ParserSharedInputState state) {
0312: super (state, 2);
0313: tokenNames = _tokenNames;
0314: buildTokenTypeASTClassMap();
0315: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
0316: }
0317:
0318: public final void compilationUnit() throws RecognitionException,
0319: TokenStreamException {
0320:
0321: returnAST = null;
0322: ASTPair currentAST = new ASTPair();
0323: AST compilationUnit_AST = null;
0324:
0325: {
0326: boolean synPredMatched4 = false;
0327: if (((LA(1) == LITERAL_package || LA(1) == AT) && (LA(2) == IDENT))) {
0328: int _m4 = mark();
0329: synPredMatched4 = true;
0330: inputState.guessing++;
0331: try {
0332: {
0333: annotations();
0334: match(LITERAL_package);
0335: }
0336: } catch (RecognitionException pe) {
0337: synPredMatched4 = false;
0338: }
0339: rewind(_m4);
0340: inputState.guessing--;
0341: }
0342: if (synPredMatched4) {
0343: packageDefinition();
0344: astFactory.addASTChild(currentAST, returnAST);
0345: } else if ((_tokenSet_0.member(LA(1)))
0346: && (_tokenSet_1.member(LA(2)))) {
0347: } else {
0348: throw new NoViableAltException(LT(1), getFilename());
0349: }
0350:
0351: }
0352: {
0353: _loop6: do {
0354: if ((LA(1) == LITERAL_import)) {
0355: importDefinition();
0356: astFactory.addASTChild(currentAST, returnAST);
0357: } else {
0358: break _loop6;
0359: }
0360:
0361: } while (true);
0362: }
0363: {
0364: _loop8: do {
0365: if ((_tokenSet_2.member(LA(1)))) {
0366: typeDefinition();
0367: astFactory.addASTChild(currentAST, returnAST);
0368: } else {
0369: break _loop8;
0370: }
0371:
0372: } while (true);
0373: }
0374: match(Token.EOF_TYPE);
0375: compilationUnit_AST = (AST) currentAST.root;
0376: returnAST = compilationUnit_AST;
0377: }
0378:
0379: public final void annotations() throws RecognitionException,
0380: TokenStreamException {
0381:
0382: returnAST = null;
0383: ASTPair currentAST = new ASTPair();
0384: AST annotations_AST = null;
0385: Token first = LT(1);
0386:
0387: {
0388: _loop62: do {
0389: if ((LA(1) == AT)) {
0390: annotation();
0391: astFactory.addASTChild(currentAST, returnAST);
0392: } else {
0393: break _loop62;
0394: }
0395:
0396: } while (true);
0397: }
0398: if (inputState.guessing == 0) {
0399: annotations_AST = (AST) currentAST.root;
0400: annotations_AST = (AST) astFactory.make((new ASTArray(2))
0401: .add(astFactory.create(ANNOTATIONS, "ANNOTATIONS"))
0402: .add(annotations_AST));
0403: currentAST.root = annotations_AST;
0404: currentAST.child = annotations_AST != null
0405: && annotations_AST.getFirstChild() != null ? annotations_AST
0406: .getFirstChild()
0407: : annotations_AST;
0408: currentAST.advanceChildToEnd();
0409: }
0410: annotations_AST = (AST) currentAST.root;
0411: returnAST = annotations_AST;
0412: }
0413:
0414: public final void packageDefinition() throws RecognitionException,
0415: TokenStreamException {
0416:
0417: returnAST = null;
0418: ASTPair currentAST = new ASTPair();
0419: AST packageDefinition_AST = null;
0420: Token p = null;
0421: AST p_AST = null;
0422:
0423: try { // for error handling
0424: annotations();
0425: astFactory.addASTChild(currentAST, returnAST);
0426: p = LT(1);
0427: p_AST = astFactory.create(p);
0428: astFactory.makeASTRoot(currentAST, p_AST);
0429: match(LITERAL_package);
0430: if (inputState.guessing == 0) {
0431: p_AST.setType(PACKAGE_DEF);
0432: }
0433: identifier();
0434: astFactory.addASTChild(currentAST, returnAST);
0435: match(SEMI);
0436: packageDefinition_AST = (AST) currentAST.root;
0437: } catch (RecognitionException ex) {
0438: if (inputState.guessing == 0) {
0439: reportError(ex);
0440: consume();
0441: consumeUntil(_tokenSet_0);
0442: } else {
0443: throw ex;
0444: }
0445: }
0446: returnAST = packageDefinition_AST;
0447: }
0448:
0449: public final void importDefinition() throws RecognitionException,
0450: TokenStreamException {
0451:
0452: returnAST = null;
0453: ASTPair currentAST = new ASTPair();
0454: AST importDefinition_AST = null;
0455: Token i = null;
0456: AST i_AST = null;
0457: boolean isStatic = false;
0458:
0459: try { // for error handling
0460: i = LT(1);
0461: i_AST = astFactory.create(i);
0462: astFactory.makeASTRoot(currentAST, i_AST);
0463: match(LITERAL_import);
0464: if (inputState.guessing == 0) {
0465: i_AST.setType(IMPORT);
0466: }
0467: {
0468: switch (LA(1)) {
0469: case LITERAL_static: {
0470: match(LITERAL_static);
0471: if (inputState.guessing == 0) {
0472: i_AST.setType(STATIC_IMPORT);
0473: }
0474: break;
0475: }
0476: case IDENT: {
0477: break;
0478: }
0479: default: {
0480: throw new NoViableAltException(LT(1), getFilename());
0481: }
0482: }
0483: }
0484: identifierStar();
0485: astFactory.addASTChild(currentAST, returnAST);
0486: match(SEMI);
0487: importDefinition_AST = (AST) currentAST.root;
0488: } catch (RecognitionException ex) {
0489: if (inputState.guessing == 0) {
0490: reportError(ex);
0491: consume();
0492: consumeUntil(_tokenSet_0);
0493: } else {
0494: throw ex;
0495: }
0496: }
0497: returnAST = importDefinition_AST;
0498: }
0499:
0500: public final void typeDefinition() throws RecognitionException,
0501: TokenStreamException {
0502:
0503: returnAST = null;
0504: ASTPair currentAST = new ASTPair();
0505: AST typeDefinition_AST = null;
0506: AST m_AST = null;
0507:
0508: try { // for error handling
0509: switch (LA(1)) {
0510: case FINAL:
0511: case ABSTRACT:
0512: case STRICTFP:
0513: case LITERAL_static:
0514: case LITERAL_private:
0515: case LITERAL_public:
0516: case LITERAL_protected:
0517: case LITERAL_transient:
0518: case LITERAL_native:
0519: case LITERAL_threadsafe:
0520: case LITERAL_synchronized:
0521: case LITERAL_volatile:
0522: case AT:
0523: case LITERAL_class:
0524: case LITERAL_interface:
0525: case LITERAL_enum: {
0526: modifiers();
0527: m_AST = (AST) returnAST;
0528: typeDefinitionInternal(m_AST);
0529: astFactory.addASTChild(currentAST, returnAST);
0530: typeDefinition_AST = (AST) currentAST.root;
0531: break;
0532: }
0533: case SEMI: {
0534: match(SEMI);
0535: typeDefinition_AST = (AST) currentAST.root;
0536: break;
0537: }
0538: default: {
0539: throw new NoViableAltException(LT(1), getFilename());
0540: }
0541: }
0542: } catch (RecognitionException ex) {
0543: if (inputState.guessing == 0) {
0544: reportError(ex);
0545: consume();
0546: consumeUntil(_tokenSet_3);
0547: } else {
0548: throw ex;
0549: }
0550: }
0551: returnAST = typeDefinition_AST;
0552: }
0553:
0554: public final void identifier() throws RecognitionException,
0555: TokenStreamException {
0556:
0557: returnAST = null;
0558: ASTPair currentAST = new ASTPair();
0559: AST identifier_AST = null;
0560:
0561: AST tmp6_AST = null;
0562: tmp6_AST = astFactory.create(LT(1));
0563: astFactory.addASTChild(currentAST, tmp6_AST);
0564: match(IDENT);
0565: {
0566: _loop48: do {
0567: if ((LA(1) == DOT)) {
0568: AST tmp7_AST = null;
0569: tmp7_AST = astFactory.create(LT(1));
0570: astFactory.makeASTRoot(currentAST, tmp7_AST);
0571: match(DOT);
0572: AST tmp8_AST = null;
0573: tmp8_AST = astFactory.create(LT(1));
0574: astFactory.addASTChild(currentAST, tmp8_AST);
0575: match(IDENT);
0576: } else {
0577: break _loop48;
0578: }
0579:
0580: } while (true);
0581: }
0582: identifier_AST = (AST) currentAST.root;
0583: returnAST = identifier_AST;
0584: }
0585:
0586: public final void identifierStar() throws RecognitionException,
0587: TokenStreamException {
0588:
0589: returnAST = null;
0590: ASTPair currentAST = new ASTPair();
0591: AST identifierStar_AST = null;
0592:
0593: AST tmp9_AST = null;
0594: tmp9_AST = astFactory.create(LT(1));
0595: astFactory.addASTChild(currentAST, tmp9_AST);
0596: match(IDENT);
0597: {
0598: _loop51: do {
0599: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
0600: AST tmp10_AST = null;
0601: tmp10_AST = astFactory.create(LT(1));
0602: astFactory.makeASTRoot(currentAST, tmp10_AST);
0603: match(DOT);
0604: AST tmp11_AST = null;
0605: tmp11_AST = astFactory.create(LT(1));
0606: astFactory.addASTChild(currentAST, tmp11_AST);
0607: match(IDENT);
0608: } else {
0609: break _loop51;
0610: }
0611:
0612: } while (true);
0613: }
0614: {
0615: switch (LA(1)) {
0616: case DOT: {
0617: AST tmp12_AST = null;
0618: tmp12_AST = astFactory.create(LT(1));
0619: astFactory.makeASTRoot(currentAST, tmp12_AST);
0620: match(DOT);
0621: AST tmp13_AST = null;
0622: tmp13_AST = astFactory.create(LT(1));
0623: astFactory.addASTChild(currentAST, tmp13_AST);
0624: match(STAR);
0625: break;
0626: }
0627: case SEMI: {
0628: break;
0629: }
0630: default: {
0631: throw new NoViableAltException(LT(1), getFilename());
0632: }
0633: }
0634: }
0635: identifierStar_AST = (AST) currentAST.root;
0636: returnAST = identifierStar_AST;
0637: }
0638:
0639: public final void modifiers() throws RecognitionException,
0640: TokenStreamException {
0641:
0642: returnAST = null;
0643: ASTPair currentAST = new ASTPair();
0644: AST modifiers_AST = null;
0645: Token first = LT(1);
0646:
0647: {
0648: _loop55: do {
0649: if ((_tokenSet_4.member(LA(1)))) {
0650: modifier();
0651: astFactory.addASTChild(currentAST, returnAST);
0652: } else if (((LA(1) == AT) && (LA(2) == IDENT))
0653: && (LA(1) == AT && !LT(2).getText().equals(
0654: "interface"))) {
0655: annotation();
0656: astFactory.addASTChild(currentAST, returnAST);
0657: } else {
0658: break _loop55;
0659: }
0660:
0661: } while (true);
0662: }
0663: if (inputState.guessing == 0) {
0664: modifiers_AST = (AST) currentAST.root;
0665: modifiers_AST = (AST) astFactory.make((new ASTArray(2))
0666: .add(create(MODIFIERS, "MODIFIERS", first, LT(1)))
0667: .add(modifiers_AST));
0668: currentAST.root = modifiers_AST;
0669: currentAST.child = modifiers_AST != null
0670: && modifiers_AST.getFirstChild() != null ? modifiers_AST
0671: .getFirstChild()
0672: : modifiers_AST;
0673: currentAST.advanceChildToEnd();
0674: }
0675: modifiers_AST = (AST) currentAST.root;
0676: returnAST = modifiers_AST;
0677: }
0678:
0679: protected final void typeDefinitionInternal(AST mods)
0680: throws RecognitionException, TokenStreamException {
0681:
0682: returnAST = null;
0683: ASTPair currentAST = new ASTPair();
0684: AST typeDefinitionInternal_AST = null;
0685:
0686: switch (LA(1)) {
0687: case LITERAL_class: {
0688: classDefinition(mods);
0689: astFactory.addASTChild(currentAST, returnAST);
0690: typeDefinitionInternal_AST = (AST) currentAST.root;
0691: break;
0692: }
0693: case LITERAL_interface: {
0694: interfaceDefinition(mods);
0695: astFactory.addASTChild(currentAST, returnAST);
0696: typeDefinitionInternal_AST = (AST) currentAST.root;
0697: break;
0698: }
0699: case LITERAL_enum: {
0700: enumDefinition(mods);
0701: astFactory.addASTChild(currentAST, returnAST);
0702: typeDefinitionInternal_AST = (AST) currentAST.root;
0703: break;
0704: }
0705: case AT: {
0706: annotationDefinition(mods);
0707: astFactory.addASTChild(currentAST, returnAST);
0708: typeDefinitionInternal_AST = (AST) currentAST.root;
0709: break;
0710: }
0711: default: {
0712: throw new NoViableAltException(LT(1), getFilename());
0713: }
0714: }
0715: returnAST = typeDefinitionInternal_AST;
0716: }
0717:
0718: public final void classDefinition(AST modifiers)
0719: throws RecognitionException, TokenStreamException {
0720:
0721: returnAST = null;
0722: ASTPair currentAST = new ASTPair();
0723: AST classDefinition_AST = null;
0724: AST tp_AST = null;
0725: AST sc_AST = null;
0726: AST ic_AST = null;
0727: AST cb_AST = null;
0728: Token first = LT(1);
0729:
0730: match(LITERAL_class);
0731: AST tmp15_AST = null;
0732: tmp15_AST = astFactory.create(LT(1));
0733: match(IDENT);
0734: {
0735: switch (LA(1)) {
0736: case LT: {
0737: typeParameters();
0738: tp_AST = (AST) returnAST;
0739: break;
0740: }
0741: case LITERAL_extends:
0742: case LCURLY:
0743: case LITERAL_implements : {
0744: break;
0745: }
0746: default: {
0747: throw new NoViableAltException(LT(1), getFilename());
0748: }
0749: }
0750: }
0751: super ClassClause();
0752: sc_AST = (AST) returnAST;
0753: implements Clause();
0754: ic_AST = (AST) returnAST;
0755: classBlock();
0756: cb_AST = (AST) returnAST;
0757: if (inputState.guessing == 0) {
0758: classDefinition_AST = (AST) currentAST.root;
0759: classDefinition_AST = (AST) astFactory
0760: .make((new ASTArray(7))
0761: .add(
0762: create(CLASS_DEF, "CLASS_DEF",
0763: first, LT(1))).add(
0764: modifiers).add(tmp15_AST).add(
0765: tp_AST).add(sc_AST).add(ic_AST)
0766: .add(cb_AST));
0767: currentAST.root = classDefinition_AST;
0768: currentAST.child = classDefinition_AST != null
0769: && classDefinition_AST.getFirstChild() != null ? classDefinition_AST
0770: .getFirstChild()
0771: : classDefinition_AST;
0772: currentAST.advanceChildToEnd();
0773: }
0774: returnAST = classDefinition_AST;
0775: }
0776:
0777: public final void interfaceDefinition(AST modifiers)
0778: throws RecognitionException, TokenStreamException {
0779:
0780: returnAST = null;
0781: ASTPair currentAST = new ASTPair();
0782: AST interfaceDefinition_AST = null;
0783: AST tp_AST = null;
0784: AST ie_AST = null;
0785: AST ib_AST = null;
0786: Token first = LT(1);
0787:
0788: match(LITERAL_interface);
0789: AST tmp17_AST = null;
0790: tmp17_AST = astFactory.create(LT(1));
0791: match(IDENT);
0792: {
0793: switch (LA(1)) {
0794: case LT: {
0795: typeParameters();
0796: tp_AST = (AST) returnAST;
0797: break;
0798: }
0799: case LITERAL_extends:
0800: case LCURLY: {
0801: break;
0802: }
0803: default: {
0804: throw new NoViableAltException(LT(1), getFilename());
0805: }
0806: }
0807: }
0808: interfaceExtends();
0809: ie_AST = (AST) returnAST;
0810: interfaceBlock();
0811: ib_AST = (AST) returnAST;
0812: if (inputState.guessing == 0) {
0813: interfaceDefinition_AST = (AST) currentAST.root;
0814: interfaceDefinition_AST = (AST) astFactory
0815: .make((new ASTArray(6)).add(
0816: create(INTERFACE_DEF, "INTERFACE_DEF",
0817: first, LT(1))).add(modifiers).add(
0818: tmp17_AST).add(tp_AST).add(ie_AST).add(
0819: ib_AST));
0820: currentAST.root = interfaceDefinition_AST;
0821: currentAST.child = interfaceDefinition_AST != null
0822: && interfaceDefinition_AST.getFirstChild() != null ? interfaceDefinition_AST
0823: .getFirstChild()
0824: : interfaceDefinition_AST;
0825: currentAST.advanceChildToEnd();
0826: }
0827: returnAST = interfaceDefinition_AST;
0828: }
0829:
0830: public final void enumDefinition(AST modifiers)
0831: throws RecognitionException, TokenStreamException {
0832:
0833: returnAST = null;
0834: ASTPair currentAST = new ASTPair();
0835: AST enumDefinition_AST = null;
0836: AST ic_AST = null;
0837: AST eb_AST = null;
0838: Token first = LT(1);
0839:
0840: match(LITERAL_enum);
0841: AST tmp19_AST = null;
0842: tmp19_AST = astFactory.create(LT(1));
0843: match(IDENT);
0844: implements Clause();
0845: ic_AST = (AST) returnAST;
0846: enumBlock();
0847: eb_AST = (AST) returnAST;
0848: if (inputState.guessing == 0) {
0849: enumDefinition_AST = (AST) currentAST.root;
0850: enumDefinition_AST = (AST) astFactory
0851: .make((new ASTArray(5)).add(
0852: create(ENUM_DEF, "ENUM_DEF", first, LT(1)))
0853: .add(modifiers).add(tmp19_AST).add(ic_AST)
0854: .add(eb_AST));
0855: currentAST.root = enumDefinition_AST;
0856: currentAST.child = enumDefinition_AST != null
0857: && enumDefinition_AST.getFirstChild() != null ? enumDefinition_AST
0858: .getFirstChild()
0859: : enumDefinition_AST;
0860: currentAST.advanceChildToEnd();
0861: }
0862: returnAST = enumDefinition_AST;
0863: }
0864:
0865: public final void annotationDefinition(AST modifiers)
0866: throws RecognitionException, TokenStreamException {
0867:
0868: returnAST = null;
0869: ASTPair currentAST = new ASTPair();
0870: AST annotationDefinition_AST = null;
0871: AST ab_AST = null;
0872: Token first = LT(1);
0873:
0874: AST tmp20_AST = null;
0875: tmp20_AST = astFactory.create(LT(1));
0876: match(AT);
0877: match(LITERAL_interface);
0878: AST tmp22_AST = null;
0879: tmp22_AST = astFactory.create(LT(1));
0880: match(IDENT);
0881: annotationBlock();
0882: ab_AST = (AST) returnAST;
0883: if (inputState.guessing == 0) {
0884: annotationDefinition_AST = (AST) currentAST.root;
0885: annotationDefinition_AST = (AST) astFactory
0886: .make((new ASTArray(4)).add(
0887: create(ANNOTATION_DEF, "ANNOTATION_DEF",
0888: first, LT(1))).add(modifiers).add(
0889: tmp22_AST).add(ab_AST));
0890: currentAST.root = annotationDefinition_AST;
0891: currentAST.child = annotationDefinition_AST != null
0892: && annotationDefinition_AST.getFirstChild() != null ? annotationDefinition_AST
0893: .getFirstChild()
0894: : annotationDefinition_AST;
0895: currentAST.advanceChildToEnd();
0896: }
0897: returnAST = annotationDefinition_AST;
0898: }
0899:
0900: public final void declaration() throws RecognitionException,
0901: TokenStreamException {
0902:
0903: returnAST = null;
0904: ASTPair currentAST = new ASTPair();
0905: AST declaration_AST = null;
0906: AST m_AST = null;
0907: AST t_AST = null;
0908: AST v_AST = null;
0909:
0910: modifiers();
0911: m_AST = (AST) returnAST;
0912: typeSpec(false);
0913: t_AST = (AST) returnAST;
0914: variableDefinitions(m_AST, t_AST);
0915: v_AST = (AST) returnAST;
0916: if (inputState.guessing == 0) {
0917: declaration_AST = (AST) currentAST.root;
0918: declaration_AST = v_AST;
0919: currentAST.root = declaration_AST;
0920: currentAST.child = declaration_AST != null
0921: && declaration_AST.getFirstChild() != null ? declaration_AST
0922: .getFirstChild()
0923: : declaration_AST;
0924: currentAST.advanceChildToEnd();
0925: }
0926: returnAST = declaration_AST;
0927: }
0928:
0929: public final void typeSpec(boolean addImagNode)
0930: throws RecognitionException, TokenStreamException {
0931:
0932: returnAST = null;
0933: ASTPair currentAST = new ASTPair();
0934: AST typeSpec_AST = null;
0935:
0936: switch (LA(1)) {
0937: case IDENT: {
0938: classTypeSpec(addImagNode);
0939: astFactory.addASTChild(currentAST, returnAST);
0940: typeSpec_AST = (AST) currentAST.root;
0941: break;
0942: }
0943: case LITERAL_void:
0944: case LITERAL_boolean:
0945: case LITERAL_byte:
0946: case LITERAL_char:
0947: case LITERAL_short:
0948: case LITERAL_int:
0949: case LITERAL_float:
0950: case LITERAL_long:
0951: case LITERAL_double: {
0952: builtInTypeSpec(addImagNode);
0953: astFactory.addASTChild(currentAST, returnAST);
0954: typeSpec_AST = (AST) currentAST.root;
0955: break;
0956: }
0957: default: {
0958: throw new NoViableAltException(LT(1), getFilename());
0959: }
0960: }
0961: returnAST = typeSpec_AST;
0962: }
0963:
0964: public final void variableDefinitions(AST mods, AST t)
0965: throws RecognitionException, TokenStreamException {
0966:
0967: returnAST = null;
0968: ASTPair currentAST = new ASTPair();
0969: AST variableDefinitions_AST = null;
0970:
0971: variableDeclarator(getASTFactory().dupTree(mods),
0972: getASTFactory().dupTree(t));
0973: astFactory.addASTChild(currentAST, returnAST);
0974: {
0975: _loop155: do {
0976: if ((LA(1) == COMMA)) {
0977: match(COMMA);
0978: variableDeclarator(getASTFactory().dupTree(mods),
0979: getASTFactory().dupTree(t));
0980: astFactory.addASTChild(currentAST, returnAST);
0981: } else {
0982: break _loop155;
0983: }
0984:
0985: } while (true);
0986: }
0987: variableDefinitions_AST = (AST) currentAST.root;
0988: returnAST = variableDefinitions_AST;
0989: }
0990:
0991: public final void classTypeSpec(boolean addImagNode)
0992: throws RecognitionException, TokenStreamException {
0993:
0994: returnAST = null;
0995: ASTPair currentAST = new ASTPair();
0996: AST classTypeSpec_AST = null;
0997: Token lb = null;
0998: AST lb_AST = null;
0999: Token first = LT(1);
1000:
1001: classOrInterfaceType(false);
1002: astFactory.addASTChild(currentAST, returnAST);
1003: {
1004: _loop18: do {
1005: if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
1006: lb = LT(1);
1007: lb_AST = astFactory.create(lb);
1008: astFactory.makeASTRoot(currentAST, lb_AST);
1009: match(LBRACK);
1010: if (inputState.guessing == 0) {
1011: lb_AST.setType(ARRAY_DECLARATOR);
1012: }
1013: match(RBRACK);
1014: } else {
1015: break _loop18;
1016: }
1017:
1018: } while (true);
1019: }
1020: if (inputState.guessing == 0) {
1021: classTypeSpec_AST = (AST) currentAST.root;
1022:
1023: if (addImagNode) {
1024: classTypeSpec_AST = (AST) astFactory
1025: .make((new ASTArray(2)).add(
1026: create(TYPE, "TYPE", first, LT(1)))
1027: .add(classTypeSpec_AST));
1028: }
1029:
1030: currentAST.root = classTypeSpec_AST;
1031: currentAST.child = classTypeSpec_AST != null
1032: && classTypeSpec_AST.getFirstChild() != null ? classTypeSpec_AST
1033: .getFirstChild()
1034: : classTypeSpec_AST;
1035: currentAST.advanceChildToEnd();
1036: }
1037: classTypeSpec_AST = (AST) currentAST.root;
1038: returnAST = classTypeSpec_AST;
1039: }
1040:
1041: public final void builtInTypeSpec(boolean addImagNode)
1042: throws RecognitionException, TokenStreamException {
1043:
1044: returnAST = null;
1045: ASTPair currentAST = new ASTPair();
1046: AST builtInTypeSpec_AST = null;
1047: Token lb = null;
1048: AST lb_AST = null;
1049: Token first = LT(1);
1050:
1051: builtInType();
1052: astFactory.addASTChild(currentAST, returnAST);
1053: {
1054: _loop43: do {
1055: if ((LA(1) == LBRACK)) {
1056: lb = LT(1);
1057: lb_AST = astFactory.create(lb);
1058: astFactory.makeASTRoot(currentAST, lb_AST);
1059: match(LBRACK);
1060: if (inputState.guessing == 0) {
1061: lb_AST.setType(ARRAY_DECLARATOR);
1062: }
1063: match(RBRACK);
1064: } else {
1065: break _loop43;
1066: }
1067:
1068: } while (true);
1069: }
1070: if (inputState.guessing == 0) {
1071: builtInTypeSpec_AST = (AST) currentAST.root;
1072:
1073: if (addImagNode) {
1074: builtInTypeSpec_AST = (AST) astFactory
1075: .make((new ASTArray(2)).add(
1076: create(TYPE, "TYPE", first, LT(1)))
1077: .add(builtInTypeSpec_AST));
1078: }
1079:
1080: currentAST.root = builtInTypeSpec_AST;
1081: currentAST.child = builtInTypeSpec_AST != null
1082: && builtInTypeSpec_AST.getFirstChild() != null ? builtInTypeSpec_AST
1083: .getFirstChild()
1084: : builtInTypeSpec_AST;
1085: currentAST.advanceChildToEnd();
1086: }
1087: builtInTypeSpec_AST = (AST) currentAST.root;
1088: returnAST = builtInTypeSpec_AST;
1089: }
1090:
1091: public final void classOrInterfaceType(boolean addImagNode)
1092: throws RecognitionException, TokenStreamException {
1093:
1094: returnAST = null;
1095: ASTPair currentAST = new ASTPair();
1096: AST classOrInterfaceType_AST = null;
1097: Token first = LT(1);
1098:
1099: AST tmp26_AST = null;
1100: tmp26_AST = astFactory.create(LT(1));
1101: astFactory.makeASTRoot(currentAST, tmp26_AST);
1102: match(IDENT);
1103: {
1104: switch (LA(1)) {
1105: case LT: {
1106: typeArguments();
1107: astFactory.addASTChild(currentAST, returnAST);
1108: break;
1109: }
1110: case SEMI:
1111: case LBRACK:
1112: case RBRACK:
1113: case IDENT:
1114: case DOT:
1115: case QUESTION:
1116: case LITERAL_extends:
1117: case LITERAL_super :
1118: case COMMA:
1119: case GT:
1120: case SR:
1121: case BSR:
1122: case LITERAL_void:
1123: case LITERAL_boolean:
1124: case LITERAL_byte:
1125: case LITERAL_char:
1126: case LITERAL_short:
1127: case LITERAL_int:
1128: case LITERAL_float:
1129: case LITERAL_long:
1130: case LITERAL_double:
1131: case LPAREN:
1132: case RPAREN:
1133: case ASSIGN:
1134: case LCURLY:
1135: case RCURLY:
1136: case BAND:
1137: case LITERAL_implements :
1138: case LITERAL_this :
1139: case TRIPLE_DOT:
1140: case COLON:
1141: case PLUS_ASSIGN:
1142: case MINUS_ASSIGN:
1143: case STAR_ASSIGN:
1144: case DIV_ASSIGN:
1145: case MOD_ASSIGN:
1146: case SR_ASSIGN:
1147: case BSR_ASSIGN:
1148: case SL_ASSIGN:
1149: case BAND_ASSIGN:
1150: case BXOR_ASSIGN:
1151: case BOR_ASSIGN:
1152: case LOR:
1153: case LAND:
1154: case BOR:
1155: case BXOR:
1156: case NOT_EQUAL:
1157: case EQUAL: {
1158: break;
1159: }
1160: default: {
1161: throw new NoViableAltException(LT(1), getFilename());
1162: }
1163: }
1164: }
1165: {
1166: _loop23: do {
1167: if ((LA(1) == DOT) && (LA(2) == IDENT)) {
1168: AST tmp27_AST = null;
1169: tmp27_AST = astFactory.create(LT(1));
1170: astFactory.makeASTRoot(currentAST, tmp27_AST);
1171: match(DOT);
1172: AST tmp28_AST = null;
1173: tmp28_AST = astFactory.create(LT(1));
1174: astFactory.addASTChild(currentAST, tmp28_AST);
1175: match(IDENT);
1176: {
1177: switch (LA(1)) {
1178: case LT: {
1179: typeArguments();
1180: astFactory.addASTChild(currentAST,
1181: returnAST);
1182: break;
1183: }
1184: case SEMI:
1185: case LBRACK:
1186: case RBRACK:
1187: case IDENT:
1188: case DOT:
1189: case QUESTION:
1190: case LITERAL_extends:
1191: case LITERAL_super :
1192: case COMMA:
1193: case GT:
1194: case SR:
1195: case BSR:
1196: case LITERAL_void:
1197: case LITERAL_boolean:
1198: case LITERAL_byte:
1199: case LITERAL_char:
1200: case LITERAL_short:
1201: case LITERAL_int:
1202: case LITERAL_float:
1203: case LITERAL_long:
1204: case LITERAL_double:
1205: case LPAREN:
1206: case RPAREN:
1207: case ASSIGN:
1208: case LCURLY:
1209: case RCURLY:
1210: case BAND:
1211: case LITERAL_implements :
1212: case LITERAL_this :
1213: case TRIPLE_DOT:
1214: case COLON:
1215: case PLUS_ASSIGN:
1216: case MINUS_ASSIGN:
1217: case STAR_ASSIGN:
1218: case DIV_ASSIGN:
1219: case MOD_ASSIGN:
1220: case SR_ASSIGN:
1221: case BSR_ASSIGN:
1222: case SL_ASSIGN:
1223: case BAND_ASSIGN:
1224: case BXOR_ASSIGN:
1225: case BOR_ASSIGN:
1226: case LOR:
1227: case LAND:
1228: case BOR:
1229: case BXOR:
1230: case NOT_EQUAL:
1231: case EQUAL: {
1232: break;
1233: }
1234: default: {
1235: throw new NoViableAltException(LT(1),
1236: getFilename());
1237: }
1238: }
1239: }
1240: } else {
1241: break _loop23;
1242: }
1243:
1244: } while (true);
1245: }
1246: if (inputState.guessing == 0) {
1247: classOrInterfaceType_AST = (AST) currentAST.root;
1248:
1249: if (addImagNode) {
1250: classOrInterfaceType_AST = (AST) astFactory
1251: .make((new ASTArray(2)).add(
1252: create(TYPE, "TYPE", first, LT(1)))
1253: .add(classOrInterfaceType_AST));
1254: }
1255:
1256: currentAST.root = classOrInterfaceType_AST;
1257: currentAST.child = classOrInterfaceType_AST != null
1258: && classOrInterfaceType_AST.getFirstChild() != null ? classOrInterfaceType_AST
1259: .getFirstChild()
1260: : classOrInterfaceType_AST;
1261: currentAST.advanceChildToEnd();
1262: }
1263: classOrInterfaceType_AST = (AST) currentAST.root;
1264: returnAST = classOrInterfaceType_AST;
1265: }
1266:
1267: public final void typeArguments() throws RecognitionException,
1268: TokenStreamException {
1269:
1270: returnAST = null;
1271: ASTPair currentAST = new ASTPair();
1272: AST typeArguments_AST = null;
1273: int currentLtLevel = 0;
1274: Token first = LT(1);
1275:
1276: if (inputState.guessing == 0) {
1277: currentLtLevel = ltCounter;
1278: }
1279: match(LT);
1280: if (inputState.guessing == 0) {
1281: ltCounter++;
1282: }
1283: typeArgument();
1284: astFactory.addASTChild(currentAST, returnAST);
1285: {
1286: _loop33: do {
1287: if (((LA(1) == COMMA) && (_tokenSet_5.member(LA(2))))
1288: && (inputState.guessing != 0 || ltCounter == currentLtLevel + 1)) {
1289: match(COMMA);
1290: typeArgument();
1291: astFactory.addASTChild(currentAST, returnAST);
1292: } else {
1293: break _loop33;
1294: }
1295:
1296: } while (true);
1297: }
1298: {
1299: if (((LA(1) >= GT && LA(1) <= BSR))
1300: && (_tokenSet_6.member(LA(2)))) {
1301: typeArgumentsOrParametersEnd();
1302: astFactory.addASTChild(currentAST, returnAST);
1303: } else if ((_tokenSet_6.member(LA(1)))
1304: && (_tokenSet_7.member(LA(2)))) {
1305: } else {
1306: throw new NoViableAltException(LT(1), getFilename());
1307: }
1308:
1309: }
1310: if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
1311: throw new SemanticException(
1312: "(currentLtLevel != 0) || ltCounter == currentLtLevel");
1313: if (inputState.guessing == 0) {
1314: typeArguments_AST = (AST) currentAST.root;
1315: typeArguments_AST = (AST) astFactory.make((new ASTArray(2))
1316: .add(
1317: create(TYPE_ARGUMENTS, "TYPE_ARGUMENTS",
1318: first, LT(1))).add(
1319: typeArguments_AST));
1320: currentAST.root = typeArguments_AST;
1321: currentAST.child = typeArguments_AST != null
1322: && typeArguments_AST.getFirstChild() != null ? typeArguments_AST
1323: .getFirstChild()
1324: : typeArguments_AST;
1325: currentAST.advanceChildToEnd();
1326: }
1327: typeArguments_AST = (AST) currentAST.root;
1328: returnAST = typeArguments_AST;
1329: }
1330:
1331: public final void typeArgumentSpec() throws RecognitionException,
1332: TokenStreamException {
1333:
1334: returnAST = null;
1335: ASTPair currentAST = new ASTPair();
1336: AST typeArgumentSpec_AST = null;
1337:
1338: switch (LA(1)) {
1339: case IDENT: {
1340: classTypeSpec(true);
1341: astFactory.addASTChild(currentAST, returnAST);
1342: typeArgumentSpec_AST = (AST) currentAST.root;
1343: break;
1344: }
1345: case LITERAL_void:
1346: case LITERAL_boolean:
1347: case LITERAL_byte:
1348: case LITERAL_char:
1349: case LITERAL_short:
1350: case LITERAL_int:
1351: case LITERAL_float:
1352: case LITERAL_long:
1353: case LITERAL_double: {
1354: builtInTypeArraySpec(true);
1355: astFactory.addASTChild(currentAST, returnAST);
1356: typeArgumentSpec_AST = (AST) currentAST.root;
1357: break;
1358: }
1359: default: {
1360: throw new NoViableAltException(LT(1), getFilename());
1361: }
1362: }
1363: returnAST = typeArgumentSpec_AST;
1364: }
1365:
1366: public final void builtInTypeArraySpec(boolean addImagNode)
1367: throws RecognitionException, TokenStreamException {
1368:
1369: returnAST = null;
1370: ASTPair currentAST = new ASTPair();
1371: AST builtInTypeArraySpec_AST = null;
1372: Token lb = null;
1373: AST lb_AST = null;
1374: Token first = LT(1);
1375:
1376: builtInType();
1377: astFactory.addASTChild(currentAST, returnAST);
1378: {
1379: int _cnt40 = 0;
1380: _loop40: do {
1381: if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
1382: lb = LT(1);
1383: lb_AST = astFactory.create(lb);
1384: astFactory.makeASTRoot(currentAST, lb_AST);
1385: match(LBRACK);
1386: if (inputState.guessing == 0) {
1387: lb_AST.setType(ARRAY_DECLARATOR);
1388: }
1389: match(RBRACK);
1390: } else {
1391: if (_cnt40 >= 1) {
1392: break _loop40;
1393: } else {
1394: throw new NoViableAltException(LT(1),
1395: getFilename());
1396: }
1397: }
1398:
1399: _cnt40++;
1400: } while (true);
1401: }
1402: if (inputState.guessing == 0) {
1403: builtInTypeArraySpec_AST = (AST) currentAST.root;
1404:
1405: if (addImagNode) {
1406: builtInTypeArraySpec_AST = (AST) astFactory
1407: .make((new ASTArray(2)).add(
1408: create(TYPE, "TYPE", first, LT(1)))
1409: .add(builtInTypeArraySpec_AST));
1410: }
1411:
1412: currentAST.root = builtInTypeArraySpec_AST;
1413: currentAST.child = builtInTypeArraySpec_AST != null
1414: && builtInTypeArraySpec_AST.getFirstChild() != null ? builtInTypeArraySpec_AST
1415: .getFirstChild()
1416: : builtInTypeArraySpec_AST;
1417: currentAST.advanceChildToEnd();
1418: }
1419: builtInTypeArraySpec_AST = (AST) currentAST.root;
1420: returnAST = builtInTypeArraySpec_AST;
1421: }
1422:
1423: public final void typeArgument() throws RecognitionException,
1424: TokenStreamException {
1425:
1426: returnAST = null;
1427: ASTPair currentAST = new ASTPair();
1428: AST typeArgument_AST = null;
1429: Token first = LT(1);
1430:
1431: {
1432: switch (LA(1)) {
1433: case IDENT:
1434: case LITERAL_void:
1435: case LITERAL_boolean:
1436: case LITERAL_byte:
1437: case LITERAL_char:
1438: case LITERAL_short:
1439: case LITERAL_int:
1440: case LITERAL_float:
1441: case LITERAL_long:
1442: case LITERAL_double: {
1443: typeArgumentSpec();
1444: astFactory.addASTChild(currentAST, returnAST);
1445: break;
1446: }
1447: case QUESTION: {
1448: wildcardType();
1449: astFactory.addASTChild(currentAST, returnAST);
1450: break;
1451: }
1452: default: {
1453: throw new NoViableAltException(LT(1), getFilename());
1454: }
1455: }
1456: }
1457: if (inputState.guessing == 0) {
1458: typeArgument_AST = (AST) currentAST.root;
1459: typeArgument_AST = (AST) astFactory.make((new ASTArray(2))
1460: .add(
1461: create(TYPE_ARGUMENT, "TYPE_ARGUMENT",
1462: first, LT(1)))
1463: .add(typeArgument_AST));
1464: currentAST.root = typeArgument_AST;
1465: currentAST.child = typeArgument_AST != null
1466: && typeArgument_AST.getFirstChild() != null ? typeArgument_AST
1467: .getFirstChild()
1468: : typeArgument_AST;
1469: currentAST.advanceChildToEnd();
1470: }
1471: typeArgument_AST = (AST) currentAST.root;
1472: returnAST = typeArgument_AST;
1473: }
1474:
1475: public final void wildcardType() throws RecognitionException,
1476: TokenStreamException {
1477:
1478: returnAST = null;
1479: ASTPair currentAST = new ASTPair();
1480: AST wildcardType_AST = null;
1481: Token q = null;
1482: AST q_AST = null;
1483:
1484: q = LT(1);
1485: q_AST = astFactory.create(q);
1486: astFactory.makeASTRoot(currentAST, q_AST);
1487: match(QUESTION);
1488: if (inputState.guessing == 0) {
1489: q_AST.setType(WILDCARD_TYPE);
1490: }
1491: {
1492: boolean synPredMatched30 = false;
1493: if (((LA(1) == LITERAL_extends || LA(1) == LITERAL_super ) && (LA(2) == IDENT))) {
1494: int _m30 = mark();
1495: synPredMatched30 = true;
1496: inputState.guessing++;
1497: try {
1498: {
1499: switch (LA(1)) {
1500: case LITERAL_extends: {
1501: match(LITERAL_extends);
1502: break;
1503: }
1504: case LITERAL_super : {
1505: match(LITERAL_super );
1506: break;
1507: }
1508: default: {
1509: throw new NoViableAltException(LT(1),
1510: getFilename());
1511: }
1512: }
1513: }
1514: } catch (RecognitionException pe) {
1515: synPredMatched30 = false;
1516: }
1517: rewind(_m30);
1518: inputState.guessing--;
1519: }
1520: if (synPredMatched30) {
1521: typeArgumentBounds();
1522: astFactory.addASTChild(currentAST, returnAST);
1523: } else if ((_tokenSet_8.member(LA(1)))
1524: && (_tokenSet_9.member(LA(2)))) {
1525: } else {
1526: throw new NoViableAltException(LT(1), getFilename());
1527: }
1528:
1529: }
1530: wildcardType_AST = (AST) currentAST.root;
1531: returnAST = wildcardType_AST;
1532: }
1533:
1534: public final void typeArgumentBounds() throws RecognitionException,
1535: TokenStreamException {
1536:
1537: returnAST = null;
1538: ASTPair currentAST = new ASTPair();
1539: AST typeArgumentBounds_AST = null;
1540: boolean isUpperBounds = false;
1541: Token first = LT(1);
1542:
1543: {
1544: switch (LA(1)) {
1545: case LITERAL_extends: {
1546: match(LITERAL_extends);
1547: if (inputState.guessing == 0) {
1548: isUpperBounds = true;
1549: }
1550: break;
1551: }
1552: case LITERAL_super : {
1553: match(LITERAL_super );
1554: break;
1555: }
1556: default: {
1557: throw new NoViableAltException(LT(1), getFilename());
1558: }
1559: }
1560: }
1561: classOrInterfaceType(false);
1562: astFactory.addASTChild(currentAST, returnAST);
1563: if (inputState.guessing == 0) {
1564: typeArgumentBounds_AST = (AST) currentAST.root;
1565:
1566: if (isUpperBounds) {
1567: typeArgumentBounds_AST = (AST) astFactory
1568: .make((new ASTArray(2)).add(
1569: create(TYPE_UPPER_BOUNDS,
1570: "TYPE_UPPER_BOUNDS", first,
1571: LT(1))).add(
1572: typeArgumentBounds_AST));
1573: } else {
1574: typeArgumentBounds_AST = (AST) astFactory
1575: .make((new ASTArray(2)).add(
1576: create(TYPE_LOWER_BOUNDS,
1577: "TYPE_LOWER_BOUNDS", first,
1578: LT(1))).add(
1579: typeArgumentBounds_AST));
1580: }
1581:
1582: currentAST.root = typeArgumentBounds_AST;
1583: currentAST.child = typeArgumentBounds_AST != null
1584: && typeArgumentBounds_AST.getFirstChild() != null ? typeArgumentBounds_AST
1585: .getFirstChild()
1586: : typeArgumentBounds_AST;
1587: currentAST.advanceChildToEnd();
1588: }
1589: typeArgumentBounds_AST = (AST) currentAST.root;
1590: returnAST = typeArgumentBounds_AST;
1591: }
1592:
1593: protected final void typeArgumentsOrParametersEnd()
1594: throws RecognitionException, TokenStreamException {
1595:
1596: returnAST = null;
1597: ASTPair currentAST = new ASTPair();
1598: AST typeArgumentsOrParametersEnd_AST = null;
1599:
1600: switch (LA(1)) {
1601: case GT: {
1602: match(GT);
1603: if (inputState.guessing == 0) {
1604: ltCounter -= 1;
1605: }
1606: typeArgumentsOrParametersEnd_AST = (AST) currentAST.root;
1607: break;
1608: }
1609: case SR: {
1610: match(SR);
1611: if (inputState.guessing == 0) {
1612: ltCounter -= 2;
1613: }
1614: typeArgumentsOrParametersEnd_AST = (AST) currentAST.root;
1615: break;
1616: }
1617: case BSR: {
1618: match(BSR);
1619: if (inputState.guessing == 0) {
1620: ltCounter -= 3;
1621: }
1622: typeArgumentsOrParametersEnd_AST = (AST) currentAST.root;
1623: break;
1624: }
1625: default: {
1626: throw new NoViableAltException(LT(1), getFilename());
1627: }
1628: }
1629: returnAST = typeArgumentsOrParametersEnd_AST;
1630: }
1631:
1632: public final void builtInType() throws RecognitionException,
1633: TokenStreamException {
1634:
1635: returnAST = null;
1636: ASTPair currentAST = new ASTPair();
1637: AST builtInType_AST = null;
1638:
1639: switch (LA(1)) {
1640: case LITERAL_void: {
1641: AST tmp37_AST = null;
1642: tmp37_AST = astFactory.create(LT(1));
1643: astFactory.addASTChild(currentAST, tmp37_AST);
1644: match(LITERAL_void);
1645: builtInType_AST = (AST) currentAST.root;
1646: break;
1647: }
1648: case LITERAL_boolean: {
1649: AST tmp38_AST = null;
1650: tmp38_AST = astFactory.create(LT(1));
1651: astFactory.addASTChild(currentAST, tmp38_AST);
1652: match(LITERAL_boolean);
1653: builtInType_AST = (AST) currentAST.root;
1654: break;
1655: }
1656: case LITERAL_byte: {
1657: AST tmp39_AST = null;
1658: tmp39_AST = astFactory.create(LT(1));
1659: astFactory.addASTChild(currentAST, tmp39_AST);
1660: match(LITERAL_byte);
1661: builtInType_AST = (AST) currentAST.root;
1662: break;
1663: }
1664: case LITERAL_char: {
1665: AST tmp40_AST = null;
1666: tmp40_AST = astFactory.create(LT(1));
1667: astFactory.addASTChild(currentAST, tmp40_AST);
1668: match(LITERAL_char);
1669: builtInType_AST = (AST) currentAST.root;
1670: break;
1671: }
1672: case LITERAL_short: {
1673: AST tmp41_AST = null;
1674: tmp41_AST = astFactory.create(LT(1));
1675: astFactory.addASTChild(currentAST, tmp41_AST);
1676: match(LITERAL_short);
1677: builtInType_AST = (AST) currentAST.root;
1678: break;
1679: }
1680: case LITERAL_int: {
1681: AST tmp42_AST = null;
1682: tmp42_AST = astFactory.create(LT(1));
1683: astFactory.addASTChild(currentAST, tmp42_AST);
1684: match(LITERAL_int);
1685: builtInType_AST = (AST) currentAST.root;
1686: break;
1687: }
1688: case LITERAL_float: {
1689: AST tmp43_AST = null;
1690: tmp43_AST = astFactory.create(LT(1));
1691: astFactory.addASTChild(currentAST, tmp43_AST);
1692: match(LITERAL_float);
1693: builtInType_AST = (AST) currentAST.root;
1694: break;
1695: }
1696: case LITERAL_long: {
1697: AST tmp44_AST = null;
1698: tmp44_AST = astFactory.create(LT(1));
1699: astFactory.addASTChild(currentAST, tmp44_AST);
1700: match(LITERAL_long);
1701: builtInType_AST = (AST) currentAST.root;
1702: break;
1703: }
1704: case LITERAL_double: {
1705: AST tmp45_AST = null;
1706: tmp45_AST = astFactory.create(LT(1));
1707: astFactory.addASTChild(currentAST, tmp45_AST);
1708: match(LITERAL_double);
1709: builtInType_AST = (AST) currentAST.root;
1710: break;
1711: }
1712: default: {
1713: throw new NoViableAltException(LT(1), getFilename());
1714: }
1715: }
1716: returnAST = builtInType_AST;
1717: }
1718:
1719: public final void type() throws RecognitionException,
1720: TokenStreamException {
1721:
1722: returnAST = null;
1723: ASTPair currentAST = new ASTPair();
1724: AST type_AST = null;
1725:
1726: switch (LA(1)) {
1727: case IDENT: {
1728: classOrInterfaceType(false);
1729: astFactory.addASTChild(currentAST, returnAST);
1730: type_AST = (AST) currentAST.root;
1731: break;
1732: }
1733: case LITERAL_void:
1734: case LITERAL_boolean:
1735: case LITERAL_byte:
1736: case LITERAL_char:
1737: case LITERAL_short:
1738: case LITERAL_int:
1739: case LITERAL_float:
1740: case LITERAL_long:
1741: case LITERAL_double: {
1742: builtInType();
1743: astFactory.addASTChild(currentAST, returnAST);
1744: type_AST = (AST) currentAST.root;
1745: break;
1746: }
1747: default: {
1748: throw new NoViableAltException(LT(1), getFilename());
1749: }
1750: }
1751: returnAST = type_AST;
1752: }
1753:
1754: public final void modifier() throws RecognitionException,
1755: TokenStreamException {
1756:
1757: returnAST = null;
1758: ASTPair currentAST = new ASTPair();
1759: AST modifier_AST = null;
1760:
1761: switch (LA(1)) {
1762: case LITERAL_private: {
1763: AST tmp46_AST = null;
1764: tmp46_AST = astFactory.create(LT(1));
1765: astFactory.addASTChild(currentAST, tmp46_AST);
1766: match(LITERAL_private);
1767: modifier_AST = (AST) currentAST.root;
1768: break;
1769: }
1770: case LITERAL_public: {
1771: AST tmp47_AST = null;
1772: tmp47_AST = astFactory.create(LT(1));
1773: astFactory.addASTChild(currentAST, tmp47_AST);
1774: match(LITERAL_public);
1775: modifier_AST = (AST) currentAST.root;
1776: break;
1777: }
1778: case LITERAL_protected: {
1779: AST tmp48_AST = null;
1780: tmp48_AST = astFactory.create(LT(1));
1781: astFactory.addASTChild(currentAST, tmp48_AST);
1782: match(LITERAL_protected);
1783: modifier_AST = (AST) currentAST.root;
1784: break;
1785: }
1786: case LITERAL_static: {
1787: AST tmp49_AST = null;
1788: tmp49_AST = astFactory.create(LT(1));
1789: astFactory.addASTChild(currentAST, tmp49_AST);
1790: match(LITERAL_static);
1791: modifier_AST = (AST) currentAST.root;
1792: break;
1793: }
1794: case LITERAL_transient: {
1795: AST tmp50_AST = null;
1796: tmp50_AST = astFactory.create(LT(1));
1797: astFactory.addASTChild(currentAST, tmp50_AST);
1798: match(LITERAL_transient);
1799: modifier_AST = (AST) currentAST.root;
1800: break;
1801: }
1802: case FINAL: {
1803: AST tmp51_AST = null;
1804: tmp51_AST = astFactory.create(LT(1));
1805: astFactory.addASTChild(currentAST, tmp51_AST);
1806: match(FINAL);
1807: modifier_AST = (AST) currentAST.root;
1808: break;
1809: }
1810: case ABSTRACT: {
1811: AST tmp52_AST = null;
1812: tmp52_AST = astFactory.create(LT(1));
1813: astFactory.addASTChild(currentAST, tmp52_AST);
1814: match(ABSTRACT);
1815: modifier_AST = (AST) currentAST.root;
1816: break;
1817: }
1818: case LITERAL_native: {
1819: AST tmp53_AST = null;
1820: tmp53_AST = astFactory.create(LT(1));
1821: astFactory.addASTChild(currentAST, tmp53_AST);
1822: match(LITERAL_native);
1823: modifier_AST = (AST) currentAST.root;
1824: break;
1825: }
1826: case LITERAL_threadsafe: {
1827: AST tmp54_AST = null;
1828: tmp54_AST = astFactory.create(LT(1));
1829: astFactory.addASTChild(currentAST, tmp54_AST);
1830: match(LITERAL_threadsafe);
1831: modifier_AST = (AST) currentAST.root;
1832: break;
1833: }
1834: case LITERAL_synchronized: {
1835: AST tmp55_AST = null;
1836: tmp55_AST = astFactory.create(LT(1));
1837: astFactory.addASTChild(currentAST, tmp55_AST);
1838: match(LITERAL_synchronized);
1839: modifier_AST = (AST) currentAST.root;
1840: break;
1841: }
1842: case LITERAL_volatile: {
1843: AST tmp56_AST = null;
1844: tmp56_AST = astFactory.create(LT(1));
1845: astFactory.addASTChild(currentAST, tmp56_AST);
1846: match(LITERAL_volatile);
1847: modifier_AST = (AST) currentAST.root;
1848: break;
1849: }
1850: case STRICTFP: {
1851: AST tmp57_AST = null;
1852: tmp57_AST = astFactory.create(LT(1));
1853: astFactory.addASTChild(currentAST, tmp57_AST);
1854: match(STRICTFP);
1855: modifier_AST = (AST) currentAST.root;
1856: break;
1857: }
1858: default: {
1859: throw new NoViableAltException(LT(1), getFilename());
1860: }
1861: }
1862: returnAST = modifier_AST;
1863: }
1864:
1865: public final void annotation() throws RecognitionException,
1866: TokenStreamException {
1867:
1868: returnAST = null;
1869: ASTPair currentAST = new ASTPair();
1870: AST annotation_AST = null;
1871: AST i_AST = null;
1872: AST args_AST = null;
1873: Token first = LT(1);
1874:
1875: match(AT);
1876: identifier();
1877: i_AST = (AST) returnAST;
1878: {
1879: switch (LA(1)) {
1880: case LPAREN: {
1881: match(LPAREN);
1882: {
1883: switch (LA(1)) {
1884: case IDENT:
1885: case LITERAL_super :
1886: case LT:
1887: case LITERAL_void:
1888: case LITERAL_boolean:
1889: case LITERAL_byte:
1890: case LITERAL_char:
1891: case LITERAL_short:
1892: case LITERAL_int:
1893: case LITERAL_float:
1894: case LITERAL_long:
1895: case LITERAL_double:
1896: case AT:
1897: case LPAREN:
1898: case LCURLY:
1899: case LITERAL_this :
1900: case PLUS:
1901: case MINUS:
1902: case INC:
1903: case DEC:
1904: case BNOT:
1905: case LNOT:
1906: case LITERAL_true:
1907: case LITERAL_false:
1908: case LITERAL_null:
1909: case LITERAL_new:
1910: case NUM_INT:
1911: case STRING_LITERAL:
1912: case NUM_FLOAT:
1913: case NUM_LONG:
1914: case NUM_DOUBLE: {
1915: annotationArguments();
1916: args_AST = (AST) returnAST;
1917: break;
1918: }
1919: case RPAREN: {
1920: break;
1921: }
1922: default: {
1923: throw new NoViableAltException(LT(1),
1924: getFilename());
1925: }
1926: }
1927: }
1928: match(RPAREN);
1929: break;
1930: }
1931: case FINAL:
1932: case ABSTRACT:
1933: case STRICTFP:
1934: case LITERAL_package:
1935: case SEMI:
1936: case LITERAL_static:
1937: case IDENT:
1938: case LT:
1939: case COMMA:
1940: case LITERAL_void:
1941: case LITERAL_boolean:
1942: case LITERAL_byte:
1943: case LITERAL_char:
1944: case LITERAL_short:
1945: case LITERAL_int:
1946: case LITERAL_float:
1947: case LITERAL_long:
1948: case LITERAL_double:
1949: case LITERAL_private:
1950: case LITERAL_public:
1951: case LITERAL_protected:
1952: case LITERAL_transient:
1953: case LITERAL_native:
1954: case LITERAL_threadsafe:
1955: case LITERAL_synchronized:
1956: case LITERAL_volatile:
1957: case AT:
1958: case RPAREN:
1959: case RCURLY:
1960: case LITERAL_class:
1961: case LITERAL_interface:
1962: case LITERAL_enum: {
1963: break;
1964: }
1965: default: {
1966: throw new NoViableAltException(LT(1), getFilename());
1967: }
1968: }
1969: }
1970: if (inputState.guessing == 0) {
1971: annotation_AST = (AST) currentAST.root;
1972: annotation_AST = (AST) astFactory
1973: .make((new ASTArray(3)).add(
1974: create(ANNOTATION, "ANNOTATION", first,
1975: LT(1))).add(i_AST).add(args_AST));
1976: currentAST.root = annotation_AST;
1977: currentAST.child = annotation_AST != null
1978: && annotation_AST.getFirstChild() != null ? annotation_AST
1979: .getFirstChild()
1980: : annotation_AST;
1981: currentAST.advanceChildToEnd();
1982: }
1983: returnAST = annotation_AST;
1984: }
1985:
1986: public final void annotationArguments()
1987: throws RecognitionException, TokenStreamException {
1988:
1989: returnAST = null;
1990: ASTPair currentAST = new ASTPair();
1991: AST annotationArguments_AST = null;
1992:
1993: if ((_tokenSet_10.member(LA(1)))
1994: && (_tokenSet_11.member(LA(2)))) {
1995: annotationMemberValueInitializer();
1996: astFactory.addASTChild(currentAST, returnAST);
1997: annotationArguments_AST = (AST) currentAST.root;
1998: } else if ((LA(1) == IDENT) && (LA(2) == ASSIGN)) {
1999: anntotationMemberValuePairs();
2000: astFactory.addASTChild(currentAST, returnAST);
2001: annotationArguments_AST = (AST) currentAST.root;
2002: } else {
2003: throw new NoViableAltException(LT(1), getFilename());
2004: }
2005:
2006: returnAST = annotationArguments_AST;
2007: }
2008:
2009: public final void annotationMemberValueInitializer()
2010: throws RecognitionException, TokenStreamException {
2011:
2012: returnAST = null;
2013: ASTPair currentAST = new ASTPair();
2014: AST annotationMemberValueInitializer_AST = null;
2015:
2016: switch (LA(1)) {
2017: case IDENT:
2018: case LITERAL_super :
2019: case LT:
2020: case LITERAL_void:
2021: case LITERAL_boolean:
2022: case LITERAL_byte:
2023: case LITERAL_char:
2024: case LITERAL_short:
2025: case LITERAL_int:
2026: case LITERAL_float:
2027: case LITERAL_long:
2028: case LITERAL_double:
2029: case LPAREN:
2030: case LITERAL_this :
2031: case PLUS:
2032: case MINUS:
2033: case INC:
2034: case DEC:
2035: case BNOT:
2036: case LNOT:
2037: case LITERAL_true:
2038: case LITERAL_false:
2039: case LITERAL_null:
2040: case LITERAL_new:
2041: case NUM_INT:
2042: case STRING_LITERAL:
2043: case NUM_FLOAT:
2044: case NUM_LONG:
2045: case NUM_DOUBLE: {
2046: conditionalExpression();
2047: astFactory.addASTChild(currentAST, returnAST);
2048: annotationMemberValueInitializer_AST = (AST) currentAST.root;
2049: break;
2050: }
2051: case AT: {
2052: annotation();
2053: astFactory.addASTChild(currentAST, returnAST);
2054: annotationMemberValueInitializer_AST = (AST) currentAST.root;
2055: break;
2056: }
2057: case LCURLY: {
2058: annotationMemberArrayInitializer();
2059: astFactory.addASTChild(currentAST, returnAST);
2060: annotationMemberValueInitializer_AST = (AST) currentAST.root;
2061: break;
2062: }
2063: default: {
2064: throw new NoViableAltException(LT(1), getFilename());
2065: }
2066: }
2067: returnAST = annotationMemberValueInitializer_AST;
2068: }
2069:
2070: public final void anntotationMemberValuePairs()
2071: throws RecognitionException, TokenStreamException {
2072:
2073: returnAST = null;
2074: ASTPair currentAST = new ASTPair();
2075: AST anntotationMemberValuePairs_AST = null;
2076:
2077: annotationMemberValuePair();
2078: astFactory.addASTChild(currentAST, returnAST);
2079: {
2080: _loop66: do {
2081: if ((LA(1) == COMMA)) {
2082: match(COMMA);
2083: annotationMemberValuePair();
2084: astFactory.addASTChild(currentAST, returnAST);
2085: } else {
2086: break _loop66;
2087: }
2088:
2089: } while (true);
2090: }
2091: anntotationMemberValuePairs_AST = (AST) currentAST.root;
2092: returnAST = anntotationMemberValuePairs_AST;
2093: }
2094:
2095: public final void annotationMemberValuePair()
2096: throws RecognitionException, TokenStreamException {
2097:
2098: returnAST = null;
2099: ASTPair currentAST = new ASTPair();
2100: AST annotationMemberValuePair_AST = null;
2101: Token i = null;
2102: AST i_AST = null;
2103: AST v_AST = null;
2104: Token first = LT(1);
2105:
2106: i = LT(1);
2107: i_AST = astFactory.create(i);
2108: match(IDENT);
2109: match(ASSIGN);
2110: annotationMemberValueInitializer();
2111: v_AST = (AST) returnAST;
2112: if (inputState.guessing == 0) {
2113: annotationMemberValuePair_AST = (AST) currentAST.root;
2114: annotationMemberValuePair_AST = (AST) astFactory
2115: .make((new ASTArray(3)).add(
2116: create(ANNOTATION_MEMBER_VALUE_PAIR,
2117: "ANNOTATION_MEMBER_VALUE_PAIR",
2118: first, LT(1))).add(i_AST)
2119: .add(v_AST));
2120: currentAST.root = annotationMemberValuePair_AST;
2121: currentAST.child = annotationMemberValuePair_AST != null
2122: && annotationMemberValuePair_AST.getFirstChild() != null ? annotationMemberValuePair_AST
2123: .getFirstChild()
2124: : annotationMemberValuePair_AST;
2125: currentAST.advanceChildToEnd();
2126: }
2127: returnAST = annotationMemberValuePair_AST;
2128: }
2129:
2130: public final void conditionalExpression()
2131: throws RecognitionException, TokenStreamException {
2132:
2133: returnAST = null;
2134: ASTPair currentAST = new ASTPair();
2135: AST conditionalExpression_AST = null;
2136:
2137: logicalOrExpression();
2138: astFactory.addASTChild(currentAST, returnAST);
2139: {
2140: switch (LA(1)) {
2141: case QUESTION: {
2142: AST tmp63_AST = null;
2143: tmp63_AST = astFactory.create(LT(1));
2144: astFactory.makeASTRoot(currentAST, tmp63_AST);
2145: match(QUESTION);
2146: assignmentExpression();
2147: astFactory.addASTChild(currentAST, returnAST);
2148: match(COLON);
2149: conditionalExpression();
2150: astFactory.addASTChild(currentAST, returnAST);
2151: break;
2152: }
2153: case SEMI:
2154: case RBRACK:
2155: case COMMA:
2156: case RPAREN:
2157: case ASSIGN:
2158: case RCURLY:
2159: case COLON:
2160: case PLUS_ASSIGN:
2161: case MINUS_ASSIGN:
2162: case STAR_ASSIGN:
2163: case DIV_ASSIGN:
2164: case MOD_ASSIGN:
2165: case SR_ASSIGN:
2166: case BSR_ASSIGN:
2167: case SL_ASSIGN:
2168: case BAND_ASSIGN:
2169: case BXOR_ASSIGN:
2170: case BOR_ASSIGN: {
2171: break;
2172: }
2173: default: {
2174: throw new NoViableAltException(LT(1), getFilename());
2175: }
2176: }
2177: }
2178: conditionalExpression_AST = (AST) currentAST.root;
2179: returnAST = conditionalExpression_AST;
2180: }
2181:
2182: public final void annotationMemberArrayInitializer()
2183: throws RecognitionException, TokenStreamException {
2184:
2185: returnAST = null;
2186: ASTPair currentAST = new ASTPair();
2187: AST annotationMemberArrayInitializer_AST = null;
2188: Token lc = null;
2189: AST lc_AST = null;
2190:
2191: lc = LT(1);
2192: lc_AST = astFactory.create(lc);
2193: astFactory.makeASTRoot(currentAST, lc_AST);
2194: match(LCURLY);
2195: if (inputState.guessing == 0) {
2196: lc_AST.setType(ANNOTATION_ARRAY_INIT);
2197: }
2198: {
2199: switch (LA(1)) {
2200: case IDENT:
2201: case LITERAL_super :
2202: case LT:
2203: case LITERAL_void:
2204: case LITERAL_boolean:
2205: case LITERAL_byte:
2206: case LITERAL_char:
2207: case LITERAL_short:
2208: case LITERAL_int:
2209: case LITERAL_float:
2210: case LITERAL_long:
2211: case LITERAL_double:
2212: case AT:
2213: case LPAREN:
2214: case LITERAL_this :
2215: case PLUS:
2216: case MINUS:
2217: case INC:
2218: case DEC:
2219: case BNOT:
2220: case LNOT:
2221: case LITERAL_true:
2222: case LITERAL_false:
2223: case LITERAL_null:
2224: case LITERAL_new:
2225: case NUM_INT:
2226: case STRING_LITERAL:
2227: case NUM_FLOAT:
2228: case NUM_LONG:
2229: case NUM_DOUBLE: {
2230: annotationMemberArrayValueInitializer();
2231: astFactory.addASTChild(currentAST, returnAST);
2232: {
2233: _loop72: do {
2234: if ((LA(1) == COMMA)
2235: && (_tokenSet_12.member(LA(2)))) {
2236: match(COMMA);
2237: annotationMemberArrayValueInitializer();
2238: astFactory.addASTChild(currentAST,
2239: returnAST);
2240: } else {
2241: break _loop72;
2242: }
2243:
2244: } while (true);
2245: }
2246: {
2247: switch (LA(1)) {
2248: case COMMA: {
2249: match(COMMA);
2250: break;
2251: }
2252: case RCURLY: {
2253: break;
2254: }
2255: default: {
2256: throw new NoViableAltException(LT(1),
2257: getFilename());
2258: }
2259: }
2260: }
2261: break;
2262: }
2263: case RCURLY: {
2264: break;
2265: }
2266: default: {
2267: throw new NoViableAltException(LT(1), getFilename());
2268: }
2269: }
2270: }
2271: match(RCURLY);
2272: annotationMemberArrayInitializer_AST = (AST) currentAST.root;
2273: returnAST = annotationMemberArrayInitializer_AST;
2274: }
2275:
2276: public final void annotationMemberArrayValueInitializer()
2277: throws RecognitionException, TokenStreamException {
2278:
2279: returnAST = null;
2280: ASTPair currentAST = new ASTPair();
2281: AST annotationMemberArrayValueInitializer_AST = null;
2282:
2283: switch (LA(1)) {
2284: case IDENT:
2285: case LITERAL_super :
2286: case LT:
2287: case LITERAL_void:
2288: case LITERAL_boolean:
2289: case LITERAL_byte:
2290: case LITERAL_char:
2291: case LITERAL_short:
2292: case LITERAL_int:
2293: case LITERAL_float:
2294: case LITERAL_long:
2295: case LITERAL_double:
2296: case LPAREN:
2297: case LITERAL_this :
2298: case PLUS:
2299: case MINUS:
2300: case INC:
2301: case DEC:
2302: case BNOT:
2303: case LNOT:
2304: case LITERAL_true:
2305: case LITERAL_false:
2306: case LITERAL_null:
2307: case LITERAL_new:
2308: case NUM_INT:
2309: case STRING_LITERAL:
2310: case NUM_FLOAT:
2311: case NUM_LONG:
2312: case NUM_DOUBLE: {
2313: conditionalExpression();
2314: astFactory.addASTChild(currentAST, returnAST);
2315: annotationMemberArrayValueInitializer_AST = (AST) currentAST.root;
2316: break;
2317: }
2318: case AT: {
2319: annotation();
2320: astFactory.addASTChild(currentAST, returnAST);
2321: annotationMemberArrayValueInitializer_AST = (AST) currentAST.root;
2322: break;
2323: }
2324: default: {
2325: throw new NoViableAltException(LT(1), getFilename());
2326: }
2327: }
2328: returnAST = annotationMemberArrayValueInitializer_AST;
2329: }
2330:
2331: public final void super ClassClause() throws RecognitionException,
2332: TokenStreamException {
2333:
2334: returnAST = null;
2335: ASTPair currentAST = new ASTPair();
2336: AST super ClassClause_AST = null;
2337: AST c_AST = null;
2338: Token first = LT(1);
2339:
2340: {
2341: switch (LA(1)) {
2342: case LITERAL_extends: {
2343: match(LITERAL_extends);
2344: classOrInterfaceType(false);
2345: c_AST = (AST) returnAST;
2346: break;
2347: }
2348: case LCURLY:
2349: case LITERAL_implements : {
2350: break;
2351: }
2352: default: {
2353: throw new NoViableAltException(LT(1), getFilename());
2354: }
2355: }
2356: }
2357: if (inputState.guessing == 0) {
2358: super ClassClause_AST = (AST) currentAST.root;
2359: super ClassClause_AST = (AST) astFactory.make((new ASTArray(
2360: 2)).add(
2361: create(EXTENDS_CLAUSE, "EXTENDS_CLAUSE", first,
2362: LT(1))).add(c_AST));
2363: currentAST.root = super ClassClause_AST;
2364: currentAST.child = super ClassClause_AST != null
2365: && super ClassClause_AST.getFirstChild() != null ? super ClassClause_AST
2366: .getFirstChild()
2367: : super ClassClause_AST;
2368: currentAST.advanceChildToEnd();
2369: }
2370: returnAST = super ClassClause_AST;
2371: }
2372:
2373: public final void typeParameters() throws RecognitionException,
2374: TokenStreamException {
2375:
2376: returnAST = null;
2377: ASTPair currentAST = new ASTPair();
2378: AST typeParameters_AST = null;
2379: int currentLtLevel = 0;
2380: Token first = LT(1);
2381:
2382: if (inputState.guessing == 0) {
2383: currentLtLevel = ltCounter;
2384: }
2385: match(LT);
2386: if (inputState.guessing == 0) {
2387: ltCounter++;
2388: }
2389: typeParameter();
2390: astFactory.addASTChild(currentAST, returnAST);
2391: {
2392: _loop85: do {
2393: if ((LA(1) == COMMA)) {
2394: match(COMMA);
2395: typeParameter();
2396: astFactory.addASTChild(currentAST, returnAST);
2397: } else {
2398: break _loop85;
2399: }
2400:
2401: } while (true);
2402: }
2403: {
2404: switch (LA(1)) {
2405: case GT:
2406: case SR:
2407: case BSR: {
2408: typeArgumentsOrParametersEnd();
2409: astFactory.addASTChild(currentAST, returnAST);
2410: break;
2411: }
2412: case IDENT:
2413: case LITERAL_extends:
2414: case LITERAL_void:
2415: case LITERAL_boolean:
2416: case LITERAL_byte:
2417: case LITERAL_char:
2418: case LITERAL_short:
2419: case LITERAL_int:
2420: case LITERAL_float:
2421: case LITERAL_long:
2422: case LITERAL_double:
2423: case LCURLY:
2424: case LITERAL_implements : {
2425: break;
2426: }
2427: default: {
2428: throw new NoViableAltException(LT(1), getFilename());
2429: }
2430: }
2431: }
2432: if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
2433: throw new SemanticException(
2434: "(currentLtLevel != 0) || ltCounter == currentLtLevel");
2435: if (inputState.guessing == 0) {
2436: typeParameters_AST = (AST) currentAST.root;
2437: typeParameters_AST = (AST) astFactory
2438: .make((new ASTArray(2)).add(
2439: create(TYPE_PARAMETERS, "TYPE_PARAMETERS",
2440: first, LT(1))).add(
2441: typeParameters_AST));
2442: currentAST.root = typeParameters_AST;
2443: currentAST.child = typeParameters_AST != null
2444: && typeParameters_AST.getFirstChild() != null ? typeParameters_AST
2445: .getFirstChild()
2446: : typeParameters_AST;
2447: currentAST.advanceChildToEnd();
2448: }
2449: typeParameters_AST = (AST) currentAST.root;
2450: returnAST = typeParameters_AST;
2451: }
2452:
2453: public final void implements Clause() throws RecognitionException,
2454: TokenStreamException {
2455:
2456: returnAST = null;
2457: ASTPair currentAST = new ASTPair();
2458: AST implements Clause_AST = null;
2459: Token i = null;
2460: AST i_AST = null;
2461: Token first = LT(1);
2462:
2463: {
2464: switch (LA(1)) {
2465: case LITERAL_implements : {
2466: i = LT(1);
2467: i_AST = astFactory.create(i);
2468: match(LITERAL_implements );
2469: classOrInterfaceType(false);
2470: astFactory.addASTChild(currentAST, returnAST);
2471: {
2472: _loop133: do {
2473: if ((LA(1) == COMMA)) {
2474: match(COMMA);
2475: classOrInterfaceType(false);
2476: astFactory.addASTChild(currentAST,
2477: returnAST);
2478: } else {
2479: break _loop133;
2480: }
2481:
2482: } while (true);
2483: }
2484: break;
2485: }
2486: case LCURLY: {
2487: break;
2488: }
2489: default: {
2490: throw new NoViableAltException(LT(1), getFilename());
2491: }
2492: }
2493: }
2494: if (inputState.guessing == 0) {
2495: implements Clause_AST = (AST) currentAST.root;
2496: implements Clause_AST = (AST) astFactory.make((new ASTArray(
2497: 2)).add(
2498: create(IMPLEMENTS_CLAUSE, "IMPLEMENTS_CLAUSE",
2499: first, LT(1))).add(implements Clause_AST));
2500: currentAST.root = implements Clause_AST;
2501: currentAST.child = implements Clause_AST != null
2502: && implements Clause_AST.getFirstChild() != null ? implements Clause_AST
2503: .getFirstChild()
2504: : implements Clause_AST;
2505: currentAST.advanceChildToEnd();
2506: }
2507: implements Clause_AST = (AST) currentAST.root;
2508: returnAST = implements Clause_AST;
2509: }
2510:
2511: public final void classBlock() throws RecognitionException,
2512: TokenStreamException {
2513:
2514: returnAST = null;
2515: ASTPair currentAST = new ASTPair();
2516: AST classBlock_AST = null;
2517:
2518: match(LCURLY);
2519: {
2520: _loop95: do {
2521: switch (LA(1)) {
2522: case FINAL:
2523: case ABSTRACT:
2524: case STRICTFP:
2525: case LITERAL_static:
2526: case IDENT:
2527: case LT:
2528: case LITERAL_void:
2529: case LITERAL_boolean:
2530: case LITERAL_byte:
2531: case LITERAL_char:
2532: case LITERAL_short:
2533: case LITERAL_int:
2534: case LITERAL_float:
2535: case LITERAL_long:
2536: case LITERAL_double:
2537: case LITERAL_private:
2538: case LITERAL_public:
2539: case LITERAL_protected:
2540: case LITERAL_transient:
2541: case LITERAL_native:
2542: case LITERAL_threadsafe:
2543: case LITERAL_synchronized:
2544: case LITERAL_volatile:
2545: case AT:
2546: case LCURLY:
2547: case LITERAL_class:
2548: case LITERAL_interface:
2549: case LITERAL_enum: {
2550: classField();
2551: astFactory.addASTChild(currentAST, returnAST);
2552: break;
2553: }
2554: case SEMI: {
2555: match(SEMI);
2556: break;
2557: }
2558: default: {
2559: break _loop95;
2560: }
2561: }
2562: } while (true);
2563: }
2564: match(RCURLY);
2565: if (inputState.guessing == 0) {
2566: classBlock_AST = (AST) currentAST.root;
2567: classBlock_AST = (AST) astFactory.make((new ASTArray(2))
2568: .add(astFactory.create(OBJBLOCK, "OBJBLOCK")).add(
2569: classBlock_AST));
2570: currentAST.root = classBlock_AST;
2571: currentAST.child = classBlock_AST != null
2572: && classBlock_AST.getFirstChild() != null ? classBlock_AST
2573: .getFirstChild()
2574: : classBlock_AST;
2575: currentAST.advanceChildToEnd();
2576: }
2577: classBlock_AST = (AST) currentAST.root;
2578: returnAST = classBlock_AST;
2579: }
2580:
2581: public final void interfaceExtends() throws RecognitionException,
2582: TokenStreamException {
2583:
2584: returnAST = null;
2585: ASTPair currentAST = new ASTPair();
2586: AST interfaceExtends_AST = null;
2587: Token e = null;
2588: AST e_AST = null;
2589: Token first = LT(1);
2590:
2591: {
2592: switch (LA(1)) {
2593: case LITERAL_extends: {
2594: e = LT(1);
2595: e_AST = astFactory.create(e);
2596: match(LITERAL_extends);
2597: classOrInterfaceType(false);
2598: astFactory.addASTChild(currentAST, returnAST);
2599: {
2600: _loop129: do {
2601: if ((LA(1) == COMMA)) {
2602: match(COMMA);
2603: classOrInterfaceType(false);
2604: astFactory.addASTChild(currentAST,
2605: returnAST);
2606: } else {
2607: break _loop129;
2608: }
2609:
2610: } while (true);
2611: }
2612: break;
2613: }
2614: case LCURLY: {
2615: break;
2616: }
2617: default: {
2618: throw new NoViableAltException(LT(1), getFilename());
2619: }
2620: }
2621: }
2622: if (inputState.guessing == 0) {
2623: interfaceExtends_AST = (AST) currentAST.root;
2624: interfaceExtends_AST = (AST) astFactory.make((new ASTArray(
2625: 2)).add(
2626: create(EXTENDS_CLAUSE, "EXTENDS_CLAUSE", first,
2627: LT(1))).add(interfaceExtends_AST));
2628: currentAST.root = interfaceExtends_AST;
2629: currentAST.child = interfaceExtends_AST != null
2630: && interfaceExtends_AST.getFirstChild() != null ? interfaceExtends_AST
2631: .getFirstChild()
2632: : interfaceExtends_AST;
2633: currentAST.advanceChildToEnd();
2634: }
2635: interfaceExtends_AST = (AST) currentAST.root;
2636: returnAST = interfaceExtends_AST;
2637: }
2638:
2639: public final void interfaceBlock() throws RecognitionException,
2640: TokenStreamException {
2641:
2642: returnAST = null;
2643: ASTPair currentAST = new ASTPair();
2644: AST interfaceBlock_AST = null;
2645:
2646: match(LCURLY);
2647: {
2648: _loop98: do {
2649: switch (LA(1)) {
2650: case FINAL:
2651: case ABSTRACT:
2652: case STRICTFP:
2653: case LITERAL_static:
2654: case IDENT:
2655: case LT:
2656: case LITERAL_void:
2657: case LITERAL_boolean:
2658: case LITERAL_byte:
2659: case LITERAL_char:
2660: case LITERAL_short:
2661: case LITERAL_int:
2662: case LITERAL_float:
2663: case LITERAL_long:
2664: case LITERAL_double:
2665: case LITERAL_private:
2666: case LITERAL_public:
2667: case LITERAL_protected:
2668: case LITERAL_transient:
2669: case LITERAL_native:
2670: case LITERAL_threadsafe:
2671: case LITERAL_synchronized:
2672: case LITERAL_volatile:
2673: case AT:
2674: case LITERAL_class:
2675: case LITERAL_interface:
2676: case LITERAL_enum: {
2677: interfaceField();
2678: astFactory.addASTChild(currentAST, returnAST);
2679: break;
2680: }
2681: case SEMI: {
2682: match(SEMI);
2683: break;
2684: }
2685: default: {
2686: break _loop98;
2687: }
2688: }
2689: } while (true);
2690: }
2691: match(RCURLY);
2692: if (inputState.guessing == 0) {
2693: interfaceBlock_AST = (AST) currentAST.root;
2694: interfaceBlock_AST = (AST) astFactory
2695: .make((new ASTArray(2)).add(
2696: astFactory.create(OBJBLOCK, "OBJBLOCK"))
2697: .add(interfaceBlock_AST));
2698: currentAST.root = interfaceBlock_AST;
2699: currentAST.child = interfaceBlock_AST != null
2700: && interfaceBlock_AST.getFirstChild() != null ? interfaceBlock_AST
2701: .getFirstChild()
2702: : interfaceBlock_AST;
2703: currentAST.advanceChildToEnd();
2704: }
2705: interfaceBlock_AST = (AST) currentAST.root;
2706: returnAST = interfaceBlock_AST;
2707: }
2708:
2709: public final void enumBlock() throws RecognitionException,
2710: TokenStreamException {
2711:
2712: returnAST = null;
2713: ASTPair currentAST = new ASTPair();
2714: AST enumBlock_AST = null;
2715:
2716: match(LCURLY);
2717: {
2718: switch (LA(1)) {
2719: case IDENT:
2720: case AT: {
2721: enumConstant();
2722: astFactory.addASTChild(currentAST, returnAST);
2723: {
2724: _loop105: do {
2725: if ((LA(1) == COMMA)
2726: && (LA(2) == IDENT || LA(2) == AT)) {
2727: match(COMMA);
2728: enumConstant();
2729: astFactory.addASTChild(currentAST,
2730: returnAST);
2731: } else {
2732: break _loop105;
2733: }
2734:
2735: } while (true);
2736: }
2737: {
2738: switch (LA(1)) {
2739: case COMMA: {
2740: match(COMMA);
2741: break;
2742: }
2743: case SEMI:
2744: case RCURLY: {
2745: break;
2746: }
2747: default: {
2748: throw new NoViableAltException(LT(1),
2749: getFilename());
2750: }
2751: }
2752: }
2753: break;
2754: }
2755: case SEMI:
2756: case RCURLY: {
2757: break;
2758: }
2759: default: {
2760: throw new NoViableAltException(LT(1), getFilename());
2761: }
2762: }
2763: }
2764: {
2765: switch (LA(1)) {
2766: case SEMI: {
2767: match(SEMI);
2768: {
2769: _loop109: do {
2770: switch (LA(1)) {
2771: case FINAL:
2772: case ABSTRACT:
2773: case STRICTFP:
2774: case LITERAL_static:
2775: case IDENT:
2776: case LT:
2777: case LITERAL_void:
2778: case LITERAL_boolean:
2779: case LITERAL_byte:
2780: case LITERAL_char:
2781: case LITERAL_short:
2782: case LITERAL_int:
2783: case LITERAL_float:
2784: case LITERAL_long:
2785: case LITERAL_double:
2786: case LITERAL_private:
2787: case LITERAL_public:
2788: case LITERAL_protected:
2789: case LITERAL_transient:
2790: case LITERAL_native:
2791: case LITERAL_threadsafe:
2792: case LITERAL_synchronized:
2793: case LITERAL_volatile:
2794: case AT:
2795: case LCURLY:
2796: case LITERAL_class:
2797: case LITERAL_interface:
2798: case LITERAL_enum: {
2799: classField();
2800: astFactory.addASTChild(currentAST,
2801: returnAST);
2802: break;
2803: }
2804: case SEMI: {
2805: match(SEMI);
2806: break;
2807: }
2808: default: {
2809: break _loop109;
2810: }
2811: }
2812: } while (true);
2813: }
2814: break;
2815: }
2816: case RCURLY: {
2817: break;
2818: }
2819: default: {
2820: throw new NoViableAltException(LT(1), getFilename());
2821: }
2822: }
2823: }
2824: match(RCURLY);
2825: if (inputState.guessing == 0) {
2826: enumBlock_AST = (AST) currentAST.root;
2827: enumBlock_AST = (AST) astFactory.make((new ASTArray(2))
2828: .add(astFactory.create(OBJBLOCK, "OBJBLOCK")).add(
2829: enumBlock_AST));
2830: currentAST.root = enumBlock_AST;
2831: currentAST.child = enumBlock_AST != null
2832: && enumBlock_AST.getFirstChild() != null ? enumBlock_AST
2833: .getFirstChild()
2834: : enumBlock_AST;
2835: currentAST.advanceChildToEnd();
2836: }
2837: enumBlock_AST = (AST) currentAST.root;
2838: returnAST = enumBlock_AST;
2839: }
2840:
2841: public final void annotationBlock() throws RecognitionException,
2842: TokenStreamException {
2843:
2844: returnAST = null;
2845: ASTPair currentAST = new ASTPair();
2846: AST annotationBlock_AST = null;
2847:
2848: match(LCURLY);
2849: {
2850: _loop101: do {
2851: switch (LA(1)) {
2852: case FINAL:
2853: case ABSTRACT:
2854: case STRICTFP:
2855: case LITERAL_static:
2856: case IDENT:
2857: case LITERAL_void:
2858: case LITERAL_boolean:
2859: case LITERAL_byte:
2860: case LITERAL_char:
2861: case LITERAL_short:
2862: case LITERAL_int:
2863: case LITERAL_float:
2864: case LITERAL_long:
2865: case LITERAL_double:
2866: case LITERAL_private:
2867: case LITERAL_public:
2868: case LITERAL_protected:
2869: case LITERAL_transient:
2870: case LITERAL_native:
2871: case LITERAL_threadsafe:
2872: case LITERAL_synchronized:
2873: case LITERAL_volatile:
2874: case AT:
2875: case LITERAL_class:
2876: case LITERAL_interface:
2877: case LITERAL_enum: {
2878: annotationField();
2879: astFactory.addASTChild(currentAST, returnAST);
2880: break;
2881: }
2882: case SEMI: {
2883: match(SEMI);
2884: break;
2885: }
2886: default: {
2887: break _loop101;
2888: }
2889: }
2890: } while (true);
2891: }
2892: match(RCURLY);
2893: if (inputState.guessing == 0) {
2894: annotationBlock_AST = (AST) currentAST.root;
2895: annotationBlock_AST = (AST) astFactory
2896: .make((new ASTArray(2)).add(
2897: astFactory.create(OBJBLOCK, "OBJBLOCK"))
2898: .add(annotationBlock_AST));
2899: currentAST.root = annotationBlock_AST;
2900: currentAST.child = annotationBlock_AST != null
2901: && annotationBlock_AST.getFirstChild() != null ? annotationBlock_AST
2902: .getFirstChild()
2903: : annotationBlock_AST;
2904: currentAST.advanceChildToEnd();
2905: }
2906: annotationBlock_AST = (AST) currentAST.root;
2907: returnAST = annotationBlock_AST;
2908: }
2909:
2910: public final void typeParameter() throws RecognitionException,
2911: TokenStreamException {
2912:
2913: returnAST = null;
2914: ASTPair currentAST = new ASTPair();
2915: AST typeParameter_AST = null;
2916: Token id = null;
2917: AST id_AST = null;
2918: Token first = LT(1);
2919:
2920: {
2921: id = LT(1);
2922: id_AST = astFactory.create(id);
2923: astFactory.addASTChild(currentAST, id_AST);
2924: match(IDENT);
2925: }
2926: {
2927: if ((LA(1) == LITERAL_extends) && (LA(2) == IDENT)) {
2928: typeParameterBounds();
2929: astFactory.addASTChild(currentAST, returnAST);
2930: } else if ((_tokenSet_13.member(LA(1)))
2931: && (_tokenSet_14.member(LA(2)))) {
2932: } else {
2933: throw new NoViableAltException(LT(1), getFilename());
2934: }
2935:
2936: }
2937: if (inputState.guessing == 0) {
2938: typeParameter_AST = (AST) currentAST.root;
2939: typeParameter_AST = (AST) astFactory.make((new ASTArray(2))
2940: .add(
2941: create(TYPE_PARAMETER, "TYPE_PARAMETER",
2942: first, LT(1))).add(
2943: typeParameter_AST));
2944: currentAST.root = typeParameter_AST;
2945: currentAST.child = typeParameter_AST != null
2946: && typeParameter_AST.getFirstChild() != null ? typeParameter_AST
2947: .getFirstChild()
2948: : typeParameter_AST;
2949: currentAST.advanceChildToEnd();
2950: }
2951: typeParameter_AST = (AST) currentAST.root;
2952: returnAST = typeParameter_AST;
2953: }
2954:
2955: public final void typeParameterBounds()
2956: throws RecognitionException, TokenStreamException {
2957:
2958: returnAST = null;
2959: ASTPair currentAST = new ASTPair();
2960: AST typeParameterBounds_AST = null;
2961: Token first = LT(1);
2962:
2963: match(LITERAL_extends);
2964: classOrInterfaceType(false);
2965: astFactory.addASTChild(currentAST, returnAST);
2966: {
2967: _loop92: do {
2968: if ((LA(1) == BAND)) {
2969: match(BAND);
2970: classOrInterfaceType(false);
2971: astFactory.addASTChild(currentAST, returnAST);
2972: } else {
2973: break _loop92;
2974: }
2975:
2976: } while (true);
2977: }
2978: if (inputState.guessing == 0) {
2979: typeParameterBounds_AST = (AST) currentAST.root;
2980: typeParameterBounds_AST = (AST) astFactory
2981: .make((new ASTArray(2)).add(
2982: create(TYPE_UPPER_BOUNDS,
2983: "TYPE_UPPER_BOUNDS", first, LT(1)))
2984: .add(typeParameterBounds_AST));
2985: currentAST.root = typeParameterBounds_AST;
2986: currentAST.child = typeParameterBounds_AST != null
2987: && typeParameterBounds_AST.getFirstChild() != null ? typeParameterBounds_AST
2988: .getFirstChild()
2989: : typeParameterBounds_AST;
2990: currentAST.advanceChildToEnd();
2991: }
2992: typeParameterBounds_AST = (AST) currentAST.root;
2993: returnAST = typeParameterBounds_AST;
2994: }
2995:
2996: public final void classField() throws RecognitionException,
2997: TokenStreamException {
2998:
2999: returnAST = null;
3000: ASTPair currentAST = new ASTPair();
3001: AST classField_AST = null;
3002: AST mods_AST = null;
3003: AST td_AST = null;
3004: AST tp_AST = null;
3005: AST h_AST = null;
3006: AST s_AST = null;
3007: AST t_AST = null;
3008: AST param_AST = null;
3009: AST rt_AST = null;
3010: AST tc_AST = null;
3011: AST s2_AST = null;
3012: AST v_AST = null;
3013: AST s3_AST = null;
3014: AST s4_AST = null;
3015: Token first = LT(1);
3016:
3017: if ((_tokenSet_15.member(LA(1)))
3018: && (_tokenSet_16.member(LA(2)))) {
3019: modifiers();
3020: mods_AST = (AST) returnAST;
3021: {
3022: switch (LA(1)) {
3023: case AT:
3024: case LITERAL_class:
3025: case LITERAL_interface:
3026: case LITERAL_enum: {
3027: typeDefinitionInternal(mods_AST);
3028: td_AST = (AST) returnAST;
3029: if (inputState.guessing == 0) {
3030: classField_AST = (AST) currentAST.root;
3031: classField_AST = td_AST;
3032: currentAST.root = classField_AST;
3033: currentAST.child = classField_AST != null
3034: && classField_AST.getFirstChild() != null ? classField_AST
3035: .getFirstChild()
3036: : classField_AST;
3037: currentAST.advanceChildToEnd();
3038: }
3039: break;
3040: }
3041: case IDENT:
3042: case LT:
3043: case LITERAL_void:
3044: case LITERAL_boolean:
3045: case LITERAL_byte:
3046: case LITERAL_char:
3047: case LITERAL_short:
3048: case LITERAL_int:
3049: case LITERAL_float:
3050: case LITERAL_long:
3051: case LITERAL_double: {
3052: {
3053: switch (LA(1)) {
3054: case LT: {
3055: typeParameters();
3056: tp_AST = (AST) returnAST;
3057: break;
3058: }
3059: case IDENT:
3060: case LITERAL_void:
3061: case LITERAL_boolean:
3062: case LITERAL_byte:
3063: case LITERAL_char:
3064: case LITERAL_short:
3065: case LITERAL_int:
3066: case LITERAL_float:
3067: case LITERAL_long:
3068: case LITERAL_double: {
3069: break;
3070: }
3071: default: {
3072: throw new NoViableAltException(LT(1),
3073: getFilename());
3074: }
3075: }
3076: }
3077: {
3078: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
3079: ctorHead();
3080: h_AST = (AST) returnAST;
3081: constructorBody();
3082: s_AST = (AST) returnAST;
3083: if (inputState.guessing == 0) {
3084: classField_AST = (AST) currentAST.root;
3085: classField_AST = (AST) astFactory
3086: .make((new ASTArray(5)).add(
3087: create(METHOD_DEF,
3088: "METHOD_DEF",
3089: first, LT(1)))
3090: .add(mods_AST).add(
3091: tp_AST).add(
3092: h_AST).add(
3093: s_AST));
3094: currentAST.root = classField_AST;
3095: currentAST.child = classField_AST != null
3096: && classField_AST
3097: .getFirstChild() != null ? classField_AST
3098: .getFirstChild()
3099: : classField_AST;
3100: currentAST.advanceChildToEnd();
3101: }
3102: } else if ((_tokenSet_17.member(LA(1)))
3103: && (_tokenSet_18.member(LA(2)))) {
3104: typeSpec(false);
3105: t_AST = (AST) returnAST;
3106: {
3107: if ((LA(1) == IDENT)
3108: && (LA(2) == LPAREN)) {
3109: AST tmp90_AST = null;
3110: tmp90_AST = astFactory
3111: .create(LT(1));
3112: match(IDENT);
3113: match(LPAREN);
3114: parameterDeclarationList();
3115: param_AST = (AST) returnAST;
3116: match(RPAREN);
3117: declaratorBrackets(t_AST);
3118: rt_AST = (AST) returnAST;
3119: {
3120: switch (LA(1)) {
3121: case LITERAL_throws: {
3122: throwsClause();
3123: tc_AST = (AST) returnAST;
3124: break;
3125: }
3126: case SEMI:
3127: case LCURLY: {
3128: break;
3129: }
3130: default: {
3131: throw new NoViableAltException(
3132: LT(1),
3133: getFilename());
3134: }
3135: }
3136: }
3137: {
3138: switch (LA(1)) {
3139: case LCURLY: {
3140: compoundStatement();
3141: s2_AST = (AST) returnAST;
3142: break;
3143: }
3144: case SEMI: {
3145: AST tmp93_AST = null;
3146: tmp93_AST = astFactory
3147: .create(LT(1));
3148: match(SEMI);
3149: break;
3150: }
3151: default: {
3152: throw new NoViableAltException(
3153: LT(1),
3154: getFilename());
3155: }
3156: }
3157: }
3158: if (inputState.guessing == 0) {
3159: classField_AST = (AST) currentAST.root;
3160: classField_AST = (AST) astFactory
3161: .make((new ASTArray(8))
3162: .add(
3163: create(
3164: METHOD_DEF,
3165: "METHOD_DEF",
3166: first,
3167: LT(1)))
3168: .add(mods_AST)
3169: .add(tp_AST)
3170: .add(
3171: (AST) astFactory
3172: .make((new ASTArray(
3173: 2))
3174: .add(
3175: create(
3176: TYPE,
3177: "TYPE",
3178: first,
3179: LT(1)))
3180: .add(
3181: rt_AST)))
3182: .add(tmp90_AST)
3183: .add(param_AST)
3184: .add(tc_AST)
3185: .add(s2_AST));
3186: currentAST.root = classField_AST;
3187: currentAST.child = classField_AST != null
3188: && classField_AST
3189: .getFirstChild() != null ? classField_AST
3190: .getFirstChild()
3191: : classField_AST;
3192: currentAST.advanceChildToEnd();
3193: }
3194: } else if ((LA(1) == IDENT)
3195: && (_tokenSet_19.member(LA(2)))) {
3196: variableDefinitions(mods_AST, t_AST);
3197: v_AST = (AST) returnAST;
3198: AST tmp94_AST = null;
3199: tmp94_AST = astFactory
3200: .create(LT(1));
3201: match(SEMI);
3202: if (inputState.guessing == 0) {
3203: classField_AST = (AST) currentAST.root;
3204: classField_AST = v_AST;
3205: currentAST.root = classField_AST;
3206: currentAST.child = classField_AST != null
3207: && classField_AST
3208: .getFirstChild() != null ? classField_AST
3209: .getFirstChild()
3210: : classField_AST;
3211: currentAST.advanceChildToEnd();
3212: }
3213: } else {
3214: throw new NoViableAltException(
3215: LT(1), getFilename());
3216: }
3217:
3218: }
3219: } else {
3220: throw new NoViableAltException(LT(1),
3221: getFilename());
3222: }
3223:
3224: }
3225: break;
3226: }
3227: default: {
3228: throw new NoViableAltException(LT(1), getFilename());
3229: }
3230: }
3231: }
3232: } else if ((LA(1) == LITERAL_static) && (LA(2) == LCURLY)) {
3233: match(LITERAL_static);
3234: compoundStatement();
3235: s3_AST = (AST) returnAST;
3236: if (inputState.guessing == 0) {
3237: classField_AST = (AST) currentAST.root;
3238: classField_AST = (AST) astFactory
3239: .make((new ASTArray(2)).add(
3240: create(STATIC_INIT, "STATIC_INIT",
3241: first, LT(1))).add(s3_AST));
3242: currentAST.root = classField_AST;
3243: currentAST.child = classField_AST != null
3244: && classField_AST.getFirstChild() != null ? classField_AST
3245: .getFirstChild()
3246: : classField_AST;
3247: currentAST.advanceChildToEnd();
3248: }
3249: } else if ((LA(1) == LCURLY)) {
3250: compoundStatement();
3251: s4_AST = (AST) returnAST;
3252: if (inputState.guessing == 0) {
3253: classField_AST = (AST) currentAST.root;
3254: classField_AST = (AST) astFactory
3255: .make((new ASTArray(2)).add(
3256: create(INSTANCE_INIT, "INSTANCE_INIT",
3257: first, LT(1))).add(s4_AST));
3258: currentAST.root = classField_AST;
3259: currentAST.child = classField_AST != null
3260: && classField_AST.getFirstChild() != null ? classField_AST
3261: .getFirstChild()
3262: : classField_AST;
3263: currentAST.advanceChildToEnd();
3264: }
3265: } else {
3266: throw new NoViableAltException(LT(1), getFilename());
3267: }
3268:
3269: returnAST = classField_AST;
3270: }
3271:
3272: public final void interfaceField() throws RecognitionException,
3273: TokenStreamException {
3274:
3275: returnAST = null;
3276: ASTPair currentAST = new ASTPair();
3277: AST interfaceField_AST = null;
3278: AST mods_AST = null;
3279: AST td_AST = null;
3280: AST tp_AST = null;
3281: AST t_AST = null;
3282: AST param_AST = null;
3283: AST rt_AST = null;
3284: AST tc_AST = null;
3285: AST v_AST = null;
3286: Token first = LT(1);
3287:
3288: modifiers();
3289: mods_AST = (AST) returnAST;
3290: {
3291: switch (LA(1)) {
3292: case AT:
3293: case LITERAL_class:
3294: case LITERAL_interface:
3295: case LITERAL_enum: {
3296: typeDefinitionInternal(mods_AST);
3297: td_AST = (AST) returnAST;
3298: if (inputState.guessing == 0) {
3299: interfaceField_AST = (AST) currentAST.root;
3300: interfaceField_AST = td_AST;
3301: currentAST.root = interfaceField_AST;
3302: currentAST.child = interfaceField_AST != null
3303: && interfaceField_AST.getFirstChild() != null ? interfaceField_AST
3304: .getFirstChild()
3305: : interfaceField_AST;
3306: currentAST.advanceChildToEnd();
3307: }
3308: break;
3309: }
3310: case IDENT:
3311: case LT:
3312: case LITERAL_void:
3313: case LITERAL_boolean:
3314: case LITERAL_byte:
3315: case LITERAL_char:
3316: case LITERAL_short:
3317: case LITERAL_int:
3318: case LITERAL_float:
3319: case LITERAL_long:
3320: case LITERAL_double: {
3321: {
3322: switch (LA(1)) {
3323: case LT: {
3324: typeParameters();
3325: tp_AST = (AST) returnAST;
3326: break;
3327: }
3328: case IDENT:
3329: case LITERAL_void:
3330: case LITERAL_boolean:
3331: case LITERAL_byte:
3332: case LITERAL_char:
3333: case LITERAL_short:
3334: case LITERAL_int:
3335: case LITERAL_float:
3336: case LITERAL_long:
3337: case LITERAL_double: {
3338: break;
3339: }
3340: default: {
3341: throw new NoViableAltException(LT(1),
3342: getFilename());
3343: }
3344: }
3345: }
3346: typeSpec(false);
3347: t_AST = (AST) returnAST;
3348: {
3349: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
3350: AST tmp96_AST = null;
3351: tmp96_AST = astFactory.create(LT(1));
3352: match(IDENT);
3353: match(LPAREN);
3354: parameterDeclarationList();
3355: param_AST = (AST) returnAST;
3356: match(RPAREN);
3357: declaratorBrackets(t_AST);
3358: rt_AST = (AST) returnAST;
3359: {
3360: switch (LA(1)) {
3361: case LITERAL_throws: {
3362: throwsClause();
3363: tc_AST = (AST) returnAST;
3364: break;
3365: }
3366: case SEMI: {
3367: break;
3368: }
3369: default: {
3370: throw new NoViableAltException(LT(1),
3371: getFilename());
3372: }
3373: }
3374: }
3375: AST tmp99_AST = null;
3376: tmp99_AST = astFactory.create(LT(1));
3377: match(SEMI);
3378: if (inputState.guessing == 0) {
3379: interfaceField_AST = (AST) currentAST.root;
3380: interfaceField_AST = (AST) astFactory
3381: .make((new ASTArray(7))
3382: .add(
3383: create(
3384: METHOD_DEF,
3385: "METHOD_DEF",
3386: first,
3387: LT(1)))
3388: .add(mods_AST)
3389: .add(tp_AST)
3390: .add(
3391: (AST) astFactory
3392: .make((new ASTArray(
3393: 2))
3394: .add(
3395: create(
3396: TYPE,
3397: "TYPE",
3398: first,
3399: LT(1)))
3400: .add(
3401: rt_AST)))
3402: .add(tmp96_AST).add(
3403: param_AST).add(
3404: tc_AST));
3405: currentAST.root = interfaceField_AST;
3406: currentAST.child = interfaceField_AST != null
3407: && interfaceField_AST
3408: .getFirstChild() != null ? interfaceField_AST
3409: .getFirstChild()
3410: : interfaceField_AST;
3411: currentAST.advanceChildToEnd();
3412: }
3413: } else if ((LA(1) == IDENT)
3414: && (_tokenSet_19.member(LA(2)))) {
3415: variableDefinitions(mods_AST, t_AST);
3416: v_AST = (AST) returnAST;
3417: AST tmp100_AST = null;
3418: tmp100_AST = astFactory.create(LT(1));
3419: match(SEMI);
3420: if (inputState.guessing == 0) {
3421: interfaceField_AST = (AST) currentAST.root;
3422: interfaceField_AST = v_AST;
3423: currentAST.root = interfaceField_AST;
3424: currentAST.child = interfaceField_AST != null
3425: && interfaceField_AST
3426: .getFirstChild() != null ? interfaceField_AST
3427: .getFirstChild()
3428: : interfaceField_AST;
3429: currentAST.advanceChildToEnd();
3430: }
3431: } else {
3432: throw new NoViableAltException(LT(1),
3433: getFilename());
3434: }
3435:
3436: }
3437: break;
3438: }
3439: default: {
3440: throw new NoViableAltException(LT(1), getFilename());
3441: }
3442: }
3443: }
3444: returnAST = interfaceField_AST;
3445: }
3446:
3447: public final void annotationField() throws RecognitionException,
3448: TokenStreamException {
3449:
3450: returnAST = null;
3451: ASTPair currentAST = new ASTPair();
3452: AST annotationField_AST = null;
3453: AST mods_AST = null;
3454: AST td_AST = null;
3455: AST t_AST = null;
3456: Token i = null;
3457: AST i_AST = null;
3458: AST rt_AST = null;
3459: AST amvi_AST = null;
3460: AST v_AST = null;
3461: Token first = LT(1);
3462:
3463: modifiers();
3464: mods_AST = (AST) returnAST;
3465: {
3466: switch (LA(1)) {
3467: case AT:
3468: case LITERAL_class:
3469: case LITERAL_interface:
3470: case LITERAL_enum: {
3471: typeDefinitionInternal(mods_AST);
3472: td_AST = (AST) returnAST;
3473: if (inputState.guessing == 0) {
3474: annotationField_AST = (AST) currentAST.root;
3475: annotationField_AST = td_AST;
3476: currentAST.root = annotationField_AST;
3477: currentAST.child = annotationField_AST != null
3478: && annotationField_AST.getFirstChild() != null ? annotationField_AST
3479: .getFirstChild()
3480: : annotationField_AST;
3481: currentAST.advanceChildToEnd();
3482: }
3483: break;
3484: }
3485: case IDENT:
3486: case LITERAL_void:
3487: case LITERAL_boolean:
3488: case LITERAL_byte:
3489: case LITERAL_char:
3490: case LITERAL_short:
3491: case LITERAL_int:
3492: case LITERAL_float:
3493: case LITERAL_long:
3494: case LITERAL_double: {
3495: typeSpec(false);
3496: t_AST = (AST) returnAST;
3497: {
3498: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
3499: i = LT(1);
3500: i_AST = astFactory.create(i);
3501: match(IDENT);
3502: match(LPAREN);
3503: match(RPAREN);
3504: declaratorBrackets(t_AST);
3505: rt_AST = (AST) returnAST;
3506: {
3507: switch (LA(1)) {
3508: case LITERAL_default: {
3509: match(LITERAL_default);
3510: annotationMemberValueInitializer();
3511: amvi_AST = (AST) returnAST;
3512: break;
3513: }
3514: case SEMI: {
3515: break;
3516: }
3517: default: {
3518: throw new NoViableAltException(LT(1),
3519: getFilename());
3520: }
3521: }
3522: }
3523: AST tmp104_AST = null;
3524: tmp104_AST = astFactory.create(LT(1));
3525: match(SEMI);
3526: if (inputState.guessing == 0) {
3527: annotationField_AST = (AST) currentAST.root;
3528: annotationField_AST = (AST) astFactory
3529: .make((new ASTArray(5))
3530: .add(
3531: create(
3532: ANNOTATION_FIELD_DEF,
3533: "ANNOTATION_FIELD_DEF",
3534: first,
3535: LT(1)))
3536: .add(mods_AST)
3537: .add(
3538: (AST) astFactory
3539: .make((new ASTArray(
3540: 2))
3541: .add(
3542: create(
3543: TYPE,
3544: "TYPE",
3545: first,
3546: LT(1)))
3547: .add(
3548: rt_AST)))
3549: .add(i_AST).add(amvi_AST));
3550: currentAST.root = annotationField_AST;
3551: currentAST.child = annotationField_AST != null
3552: && annotationField_AST
3553: .getFirstChild() != null ? annotationField_AST
3554: .getFirstChild()
3555: : annotationField_AST;
3556: currentAST.advanceChildToEnd();
3557: }
3558: } else if ((LA(1) == IDENT)
3559: && (_tokenSet_19.member(LA(2)))) {
3560: variableDefinitions(mods_AST, t_AST);
3561: v_AST = (AST) returnAST;
3562: AST tmp105_AST = null;
3563: tmp105_AST = astFactory.create(LT(1));
3564: match(SEMI);
3565: if (inputState.guessing == 0) {
3566: annotationField_AST = (AST) currentAST.root;
3567: annotationField_AST = v_AST;
3568: currentAST.root = annotationField_AST;
3569: currentAST.child = annotationField_AST != null
3570: && annotationField_AST
3571: .getFirstChild() != null ? annotationField_AST
3572: .getFirstChild()
3573: : annotationField_AST;
3574: currentAST.advanceChildToEnd();
3575: }
3576: } else {
3577: throw new NoViableAltException(LT(1),
3578: getFilename());
3579: }
3580:
3581: }
3582: break;
3583: }
3584: default: {
3585: throw new NoViableAltException(LT(1), getFilename());
3586: }
3587: }
3588: }
3589: returnAST = annotationField_AST;
3590: }
3591:
3592: public final void enumConstant() throws RecognitionException,
3593: TokenStreamException {
3594:
3595: returnAST = null;
3596: ASTPair currentAST = new ASTPair();
3597: AST enumConstant_AST = null;
3598: AST an_AST = null;
3599: Token i = null;
3600: AST i_AST = null;
3601: AST a_AST = null;
3602: AST b_AST = null;
3603:
3604: annotations();
3605: an_AST = (AST) returnAST;
3606: i = LT(1);
3607: i_AST = astFactory.create(i);
3608: match(IDENT);
3609: {
3610: switch (LA(1)) {
3611: case LPAREN: {
3612: match(LPAREN);
3613: argList();
3614: a_AST = (AST) returnAST;
3615: match(RPAREN);
3616: break;
3617: }
3618: case SEMI:
3619: case COMMA:
3620: case LCURLY:
3621: case RCURLY: {
3622: break;
3623: }
3624: default: {
3625: throw new NoViableAltException(LT(1), getFilename());
3626: }
3627: }
3628: }
3629: {
3630: switch (LA(1)) {
3631: case LCURLY: {
3632: enumConstantBlock();
3633: b_AST = (AST) returnAST;
3634: break;
3635: }
3636: case SEMI:
3637: case COMMA:
3638: case RCURLY: {
3639: break;
3640: }
3641: default: {
3642: throw new NoViableAltException(LT(1), getFilename());
3643: }
3644: }
3645: }
3646: if (inputState.guessing == 0) {
3647: enumConstant_AST = (AST) currentAST.root;
3648: enumConstant_AST = (AST) astFactory.make((new ASTArray(5))
3649: .add(
3650: astFactory.create(ENUM_CONSTANT_DEF,
3651: "ENUM_CONSTANT_DEF")).add(an_AST)
3652: .add(i_AST).add(a_AST).add(b_AST));
3653: currentAST.root = enumConstant_AST;
3654: currentAST.child = enumConstant_AST != null
3655: && enumConstant_AST.getFirstChild() != null ? enumConstant_AST
3656: .getFirstChild()
3657: : enumConstant_AST;
3658: currentAST.advanceChildToEnd();
3659: }
3660: returnAST = enumConstant_AST;
3661: }
3662:
3663: public final void declaratorBrackets(AST typ)
3664: throws RecognitionException, TokenStreamException {
3665:
3666: returnAST = null;
3667: ASTPair currentAST = new ASTPair();
3668: AST declaratorBrackets_AST = null;
3669: Token lb = null;
3670: AST lb_AST = null;
3671:
3672: if (inputState.guessing == 0) {
3673: declaratorBrackets_AST = (AST) currentAST.root;
3674: declaratorBrackets_AST = typ;
3675: currentAST.root = declaratorBrackets_AST;
3676: currentAST.child = declaratorBrackets_AST != null
3677: && declaratorBrackets_AST.getFirstChild() != null ? declaratorBrackets_AST
3678: .getFirstChild()
3679: : declaratorBrackets_AST;
3680: currentAST.advanceChildToEnd();
3681: }
3682: {
3683: _loop159: do {
3684: if ((LA(1) == LBRACK)) {
3685: lb = LT(1);
3686: lb_AST = astFactory.create(lb);
3687: astFactory.makeASTRoot(currentAST, lb_AST);
3688: match(LBRACK);
3689: if (inputState.guessing == 0) {
3690: lb_AST.setType(ARRAY_DECLARATOR);
3691: }
3692: match(RBRACK);
3693: } else {
3694: break _loop159;
3695: }
3696:
3697: } while (true);
3698: }
3699: declaratorBrackets_AST = (AST) currentAST.root;
3700: returnAST = declaratorBrackets_AST;
3701: }
3702:
3703: public final void argList() throws RecognitionException,
3704: TokenStreamException {
3705:
3706: returnAST = null;
3707: ASTPair currentAST = new ASTPair();
3708: AST argList_AST = null;
3709: Token first = LT(1);
3710:
3711: {
3712: switch (LA(1)) {
3713: case IDENT:
3714: case LITERAL_super :
3715: case LT:
3716: case LITERAL_void:
3717: case LITERAL_boolean:
3718: case LITERAL_byte:
3719: case LITERAL_char:
3720: case LITERAL_short:
3721: case LITERAL_int:
3722: case LITERAL_float:
3723: case LITERAL_long:
3724: case LITERAL_double:
3725: case LPAREN:
3726: case LITERAL_this :
3727: case PLUS:
3728: case MINUS:
3729: case INC:
3730: case DEC:
3731: case BNOT:
3732: case LNOT:
3733: case LITERAL_true:
3734: case LITERAL_false:
3735: case LITERAL_null:
3736: case LITERAL_new:
3737: case NUM_INT:
3738: case STRING_LITERAL:
3739: case NUM_FLOAT:
3740: case NUM_LONG:
3741: case NUM_DOUBLE: {
3742: expressionList();
3743: astFactory.addASTChild(currentAST, returnAST);
3744: break;
3745: }
3746: case RPAREN: {
3747: if (inputState.guessing == 0) {
3748: argList_AST = (AST) currentAST.root;
3749: argList_AST = create(ELIST, "ELIST", first, LT(1));
3750: currentAST.root = argList_AST;
3751: currentAST.child = argList_AST != null
3752: && argList_AST.getFirstChild() != null ? argList_AST
3753: .getFirstChild()
3754: : argList_AST;
3755: currentAST.advanceChildToEnd();
3756: }
3757: break;
3758: }
3759: default: {
3760: throw new NoViableAltException(LT(1), getFilename());
3761: }
3762: }
3763: }
3764: argList_AST = (AST) currentAST.root;
3765: returnAST = argList_AST;
3766: }
3767:
3768: public final void enumConstantBlock() throws RecognitionException,
3769: TokenStreamException {
3770:
3771: returnAST = null;
3772: ASTPair currentAST = new ASTPair();
3773: AST enumConstantBlock_AST = null;
3774:
3775: match(LCURLY);
3776: {
3777: _loop119: do {
3778: switch (LA(1)) {
3779: case FINAL:
3780: case ABSTRACT:
3781: case STRICTFP:
3782: case LITERAL_static:
3783: case IDENT:
3784: case LT:
3785: case LITERAL_void:
3786: case LITERAL_boolean:
3787: case LITERAL_byte:
3788: case LITERAL_char:
3789: case LITERAL_short:
3790: case LITERAL_int:
3791: case LITERAL_float:
3792: case LITERAL_long:
3793: case LITERAL_double:
3794: case LITERAL_private:
3795: case LITERAL_public:
3796: case LITERAL_protected:
3797: case LITERAL_transient:
3798: case LITERAL_native:
3799: case LITERAL_threadsafe:
3800: case LITERAL_synchronized:
3801: case LITERAL_volatile:
3802: case AT:
3803: case LCURLY:
3804: case LITERAL_class:
3805: case LITERAL_interface:
3806: case LITERAL_enum: {
3807: enumConstantField();
3808: astFactory.addASTChild(currentAST, returnAST);
3809: break;
3810: }
3811: case SEMI: {
3812: match(SEMI);
3813: break;
3814: }
3815: default: {
3816: break _loop119;
3817: }
3818: }
3819: } while (true);
3820: }
3821: match(RCURLY);
3822: if (inputState.guessing == 0) {
3823: enumConstantBlock_AST = (AST) currentAST.root;
3824: enumConstantBlock_AST = (AST) astFactory
3825: .make((new ASTArray(2)).add(
3826: astFactory.create(OBJBLOCK, "OBJBLOCK"))
3827: .add(enumConstantBlock_AST));
3828: currentAST.root = enumConstantBlock_AST;
3829: currentAST.child = enumConstantBlock_AST != null
3830: && enumConstantBlock_AST.getFirstChild() != null ? enumConstantBlock_AST
3831: .getFirstChild()
3832: : enumConstantBlock_AST;
3833: currentAST.advanceChildToEnd();
3834: }
3835: enumConstantBlock_AST = (AST) currentAST.root;
3836: returnAST = enumConstantBlock_AST;
3837: }
3838:
3839: public final void enumConstantField() throws RecognitionException,
3840: TokenStreamException {
3841:
3842: returnAST = null;
3843: ASTPair currentAST = new ASTPair();
3844: AST enumConstantField_AST = null;
3845: AST mods_AST = null;
3846: AST td_AST = null;
3847: AST tp_AST = null;
3848: AST t_AST = null;
3849: AST param_AST = null;
3850: AST rt_AST = null;
3851: AST tc_AST = null;
3852: AST s2_AST = null;
3853: AST v_AST = null;
3854: AST s4_AST = null;
3855: Token first = LT(1);
3856:
3857: switch (LA(1)) {
3858: case FINAL:
3859: case ABSTRACT:
3860: case STRICTFP:
3861: case LITERAL_static:
3862: case IDENT:
3863: case LT:
3864: case LITERAL_void:
3865: case LITERAL_boolean:
3866: case LITERAL_byte:
3867: case LITERAL_char:
3868: case LITERAL_short:
3869: case LITERAL_int:
3870: case LITERAL_float:
3871: case LITERAL_long:
3872: case LITERAL_double:
3873: case LITERAL_private:
3874: case LITERAL_public:
3875: case LITERAL_protected:
3876: case LITERAL_transient:
3877: case LITERAL_native:
3878: case LITERAL_threadsafe:
3879: case LITERAL_synchronized:
3880: case LITERAL_volatile:
3881: case AT:
3882: case LITERAL_class:
3883: case LITERAL_interface:
3884: case LITERAL_enum: {
3885: modifiers();
3886: mods_AST = (AST) returnAST;
3887: {
3888: switch (LA(1)) {
3889: case AT:
3890: case LITERAL_class:
3891: case LITERAL_interface:
3892: case LITERAL_enum: {
3893: typeDefinitionInternal(mods_AST);
3894: td_AST = (AST) returnAST;
3895: if (inputState.guessing == 0) {
3896: enumConstantField_AST = (AST) currentAST.root;
3897: enumConstantField_AST = td_AST;
3898: currentAST.root = enumConstantField_AST;
3899: currentAST.child = enumConstantField_AST != null
3900: && enumConstantField_AST
3901: .getFirstChild() != null ? enumConstantField_AST
3902: .getFirstChild()
3903: : enumConstantField_AST;
3904: currentAST.advanceChildToEnd();
3905: }
3906: break;
3907: }
3908: case IDENT:
3909: case LT:
3910: case LITERAL_void:
3911: case LITERAL_boolean:
3912: case LITERAL_byte:
3913: case LITERAL_char:
3914: case LITERAL_short:
3915: case LITERAL_int:
3916: case LITERAL_float:
3917: case LITERAL_long:
3918: case LITERAL_double: {
3919: {
3920: switch (LA(1)) {
3921: case LT: {
3922: typeParameters();
3923: tp_AST = (AST) returnAST;
3924: break;
3925: }
3926: case IDENT:
3927: case LITERAL_void:
3928: case LITERAL_boolean:
3929: case LITERAL_byte:
3930: case LITERAL_char:
3931: case LITERAL_short:
3932: case LITERAL_int:
3933: case LITERAL_float:
3934: case LITERAL_long:
3935: case LITERAL_double: {
3936: break;
3937: }
3938: default: {
3939: throw new NoViableAltException(LT(1),
3940: getFilename());
3941: }
3942: }
3943: }
3944: typeSpec(false);
3945: t_AST = (AST) returnAST;
3946: {
3947: if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
3948: AST tmp112_AST = null;
3949: tmp112_AST = astFactory.create(LT(1));
3950: match(IDENT);
3951: match(LPAREN);
3952: parameterDeclarationList();
3953: param_AST = (AST) returnAST;
3954: match(RPAREN);
3955: declaratorBrackets(t_AST);
3956: rt_AST = (AST) returnAST;
3957: {
3958: switch (LA(1)) {
3959: case LITERAL_throws: {
3960: throwsClause();
3961: tc_AST = (AST) returnAST;
3962: break;
3963: }
3964: case SEMI:
3965: case LCURLY: {
3966: break;
3967: }
3968: default: {
3969: throw new NoViableAltException(
3970: LT(1), getFilename());
3971: }
3972: }
3973: }
3974: {
3975: switch (LA(1)) {
3976: case LCURLY: {
3977: compoundStatement();
3978: s2_AST = (AST) returnAST;
3979: break;
3980: }
3981: case SEMI: {
3982: AST tmp115_AST = null;
3983: tmp115_AST = astFactory
3984: .create(LT(1));
3985: match(SEMI);
3986: break;
3987: }
3988: default: {
3989: throw new NoViableAltException(
3990: LT(1), getFilename());
3991: }
3992: }
3993: }
3994: if (inputState.guessing == 0) {
3995: enumConstantField_AST = (AST) currentAST.root;
3996: enumConstantField_AST = (AST) astFactory
3997: .make((new ASTArray(8))
3998: .add(
3999: create(
4000: METHOD_DEF,
4001: "METHOD_DEF",
4002: first,
4003: LT(1)))
4004: .add(mods_AST)
4005: .add(tp_AST)
4006: .add(
4007: (AST) astFactory
4008: .make((new ASTArray(
4009: 2))
4010: .add(
4011: create(
4012: TYPE,
4013: "TYPE",
4014: first,
4015: LT(1)))
4016: .add(
4017: rt_AST)))
4018: .add(tmp112_AST).add(
4019: param_AST).add(
4020: tc_AST).add(
4021: s2_AST));
4022: currentAST.root = enumConstantField_AST;
4023: currentAST.child = enumConstantField_AST != null
4024: && enumConstantField_AST
4025: .getFirstChild() != null ? enumConstantField_AST
4026: .getFirstChild()
4027: : enumConstantField_AST;
4028: currentAST.advanceChildToEnd();
4029: }
4030: } else if ((LA(1) == IDENT)
4031: && (_tokenSet_19.member(LA(2)))) {
4032: variableDefinitions(mods_AST, t_AST);
4033: v_AST = (AST) returnAST;
4034: AST tmp116_AST = null;
4035: tmp116_AST = astFactory.create(LT(1));
4036: match(SEMI);
4037: if (inputState.guessing == 0) {
4038: enumConstantField_AST = (AST) currentAST.root;
4039: enumConstantField_AST = v_AST;
4040: currentAST.root = enumConstantField_AST;
4041: currentAST.child = enumConstantField_AST != null
4042: && enumConstantField_AST
4043: .getFirstChild() != null ? enumConstantField_AST
4044: .getFirstChild()
4045: : enumConstantField_AST;
4046: currentAST.advanceChildToEnd();
4047: }
4048: } else {
4049: throw new NoViableAltException(LT(1),
4050: getFilename());
4051: }
4052:
4053: }
4054: break;
4055: }
4056: default: {
4057: throw new NoViableAltException(LT(1), getFilename());
4058: }
4059: }
4060: }
4061: break;
4062: }
4063: case LCURLY: {
4064: compoundStatement();
4065: s4_AST = (AST) returnAST;
4066: if (inputState.guessing == 0) {
4067: enumConstantField_AST = (AST) currentAST.root;
4068: enumConstantField_AST = (AST) astFactory
4069: .make((new ASTArray(2)).add(
4070: create(INSTANCE_INIT, "INSTANCE_INIT",
4071: first, LT(1))).add(s4_AST));
4072: currentAST.root = enumConstantField_AST;
4073: currentAST.child = enumConstantField_AST != null
4074: && enumConstantField_AST.getFirstChild() != null ? enumConstantField_AST
4075: .getFirstChild()
4076: : enumConstantField_AST;
4077: currentAST.advanceChildToEnd();
4078: }
4079: break;
4080: }
4081: default: {
4082: throw new NoViableAltException(LT(1), getFilename());
4083: }
4084: }
4085: returnAST = enumConstantField_AST;
4086: }
4087:
4088: public final void parameterDeclarationList()
4089: throws RecognitionException, TokenStreamException {
4090:
4091: returnAST = null;
4092: ASTPair currentAST = new ASTPair();
4093: AST parameterDeclarationList_AST = null;
4094: Token first = LT(1);
4095:
4096: {
4097: boolean synPredMatched171 = false;
4098: if (((_tokenSet_20.member(LA(1))) && (_tokenSet_21
4099: .member(LA(2))))) {
4100: int _m171 = mark();
4101: synPredMatched171 = true;
4102: inputState.guessing++;
4103: try {
4104: {
4105: parameterDeclaration();
4106: }
4107: } catch (RecognitionException pe) {
4108: synPredMatched171 = false;
4109: }
4110: rewind(_m171);
4111: inputState.guessing--;
4112: }
4113: if (synPredMatched171) {
4114: parameterDeclaration();
4115: astFactory.addASTChild(currentAST, returnAST);
4116: {
4117: _loop175: do {
4118: boolean synPredMatched174 = false;
4119: if (((LA(1) == COMMA) && (_tokenSet_20
4120: .member(LA(2))))) {
4121: int _m174 = mark();
4122: synPredMatched174 = true;
4123: inputState.guessing++;
4124: try {
4125: {
4126: match(COMMA);
4127: parameterDeclaration();
4128: }
4129: } catch (RecognitionException pe) {
4130: synPredMatched174 = false;
4131: }
4132: rewind(_m174);
4133: inputState.guessing--;
4134: }
4135: if (synPredMatched174) {
4136: match(COMMA);
4137: parameterDeclaration();
4138: astFactory.addASTChild(currentAST,
4139: returnAST);
4140: } else {
4141: break _loop175;
4142: }
4143:
4144: } while (true);
4145: }
4146: {
4147: switch (LA(1)) {
4148: case COMMA: {
4149: match(COMMA);
4150: variableLengthParameterDeclaration();
4151: astFactory.addASTChild(currentAST, returnAST);
4152: break;
4153: }
4154: case RPAREN: {
4155: break;
4156: }
4157: default: {
4158: throw new NoViableAltException(LT(1),
4159: getFilename());
4160: }
4161: }
4162: }
4163: } else if ((_tokenSet_20.member(LA(1)))
4164: && (_tokenSet_22.member(LA(2)))) {
4165: variableLengthParameterDeclaration();
4166: astFactory.addASTChild(currentAST, returnAST);
4167: } else if ((LA(1) == RPAREN)) {
4168: } else {
4169: throw new NoViableAltException(LT(1), getFilename());
4170: }
4171:
4172: }
4173: if (inputState.guessing == 0) {
4174: parameterDeclarationList_AST = (AST) currentAST.root;
4175: parameterDeclarationList_AST = (AST) astFactory
4176: .make((new ASTArray(2)).add(
4177: create(PARAMETERS, "PARAMETERS", first,
4178: LT(1))).add(
4179: parameterDeclarationList_AST));
4180: currentAST.root = parameterDeclarationList_AST;
4181: currentAST.child = parameterDeclarationList_AST != null
4182: && parameterDeclarationList_AST.getFirstChild() != null ? parameterDeclarationList_AST
4183: .getFirstChild()
4184: : parameterDeclarationList_AST;
4185: currentAST.advanceChildToEnd();
4186: }
4187: parameterDeclarationList_AST = (AST) currentAST.root;
4188: returnAST = parameterDeclarationList_AST;
4189: }
4190:
4191: public final void throwsClause() throws RecognitionException,
4192: TokenStreamException {
4193:
4194: returnAST = null;
4195: ASTPair currentAST = new ASTPair();
4196: AST throwsClause_AST = null;
4197:
4198: AST tmp119_AST = null;
4199: tmp119_AST = astFactory.create(LT(1));
4200: astFactory.makeASTRoot(currentAST, tmp119_AST);
4201: match(LITERAL_throws);
4202: identifier();
4203: astFactory.addASTChild(currentAST, returnAST);
4204: {
4205: _loop167: do {
4206: if ((LA(1) == COMMA)) {
4207: match(COMMA);
4208: identifier();
4209: astFactory.addASTChild(currentAST, returnAST);
4210: } else {
4211: break _loop167;
4212: }
4213:
4214: } while (true);
4215: }
4216: throwsClause_AST = (AST) currentAST.root;
4217: returnAST = throwsClause_AST;
4218: }
4219:
4220: public final void compoundStatement() throws RecognitionException,
4221: TokenStreamException {
4222:
4223: returnAST = null;
4224: ASTPair currentAST = new ASTPair();
4225: AST compoundStatement_AST = null;
4226: Token lc = null;
4227: AST lc_AST = null;
4228:
4229: lc = LT(1);
4230: lc_AST = astFactory.create(lc);
4231: astFactory.makeASTRoot(currentAST, lc_AST);
4232: match(LCURLY);
4233: if (inputState.guessing == 0) {
4234: lc_AST.setType(SLIST);
4235: }
4236: {
4237: _loop187: do {
4238: if ((_tokenSet_23.member(LA(1)))) {
4239: statement();
4240: astFactory.addASTChild(currentAST, returnAST);
4241: } else {
4242: break _loop187;
4243: }
4244:
4245: } while (true);
4246: }
4247: match(RCURLY);
4248: compoundStatement_AST = (AST) currentAST.root;
4249: returnAST = compoundStatement_AST;
4250: }
4251:
4252: public final void ctorHead() throws RecognitionException,
4253: TokenStreamException {
4254:
4255: returnAST = null;
4256: ASTPair currentAST = new ASTPair();
4257: AST ctorHead_AST = null;
4258:
4259: AST tmp122_AST = null;
4260: tmp122_AST = astFactory.create(LT(1));
4261: astFactory.addASTChild(currentAST, tmp122_AST);
4262: match(IDENT);
4263: match(LPAREN);
4264: parameterDeclarationList();
4265: astFactory.addASTChild(currentAST, returnAST);
4266: match(RPAREN);
4267: {
4268: switch (LA(1)) {
4269: case LITERAL_throws: {
4270: throwsClause();
4271: astFactory.addASTChild(currentAST, returnAST);
4272: break;
4273: }
4274: case LCURLY: {
4275: break;
4276: }
4277: default: {
4278: throw new NoViableAltException(LT(1), getFilename());
4279: }
4280: }
4281: }
4282: ctorHead_AST = (AST) currentAST.root;
4283: returnAST = ctorHead_AST;
4284: }
4285:
4286: public final void constructorBody() throws RecognitionException,
4287: TokenStreamException {
4288:
4289: returnAST = null;
4290: ASTPair currentAST = new ASTPair();
4291: AST constructorBody_AST = null;
4292: Token lc = null;
4293: AST lc_AST = null;
4294:
4295: lc = LT(1);
4296: lc_AST = astFactory.create(lc);
4297: astFactory.makeASTRoot(currentAST, lc_AST);
4298: match(LCURLY);
4299: if (inputState.guessing == 0) {
4300: lc_AST.setType(SLIST);
4301: }
4302: {
4303: if ((_tokenSet_24.member(LA(1)))
4304: && (_tokenSet_25.member(LA(2)))) {
4305: explicitConstructorInvocation();
4306: astFactory.addASTChild(currentAST, returnAST);
4307: } else if ((_tokenSet_26.member(LA(1)))
4308: && (_tokenSet_27.member(LA(2)))) {
4309: } else {
4310: throw new NoViableAltException(LT(1), getFilename());
4311: }
4312:
4313: }
4314: {
4315: _loop149: do {
4316: if ((_tokenSet_23.member(LA(1)))) {
4317: statement();
4318: astFactory.addASTChild(currentAST, returnAST);
4319: } else {
4320: break _loop149;
4321: }
4322:
4323: } while (true);
4324: }
4325: match(RCURLY);
4326: constructorBody_AST = (AST) currentAST.root;
4327: returnAST = constructorBody_AST;
4328: }
4329:
4330: /** Catch obvious constructor calls, but not the expr.super(...) calls */
4331: public final void explicitConstructorInvocation()
4332: throws RecognitionException, TokenStreamException {
4333:
4334: returnAST = null;
4335: ASTPair currentAST = new ASTPair();
4336: AST explicitConstructorInvocation_AST = null;
4337: Token lp1 = null;
4338: AST lp1_AST = null;
4339: Token lp2 = null;
4340: AST lp2_AST = null;
4341:
4342: {
4343: switch (LA(1)) {
4344: case LT: {
4345: typeArguments();
4346: astFactory.addASTChild(currentAST, returnAST);
4347: break;
4348: }
4349: case LITERAL_super :
4350: case LITERAL_this : {
4351: break;
4352: }
4353: default: {
4354: throw new NoViableAltException(LT(1), getFilename());
4355: }
4356: }
4357: }
4358: {
4359: switch (LA(1)) {
4360: case LITERAL_this : {
4361: match(LITERAL_this );
4362: lp1 = LT(1);
4363: lp1_AST = astFactory.create(lp1);
4364: astFactory.makeASTRoot(currentAST, lp1_AST);
4365: match(LPAREN);
4366: argList();
4367: astFactory.addASTChild(currentAST, returnAST);
4368: match(RPAREN);
4369: match(SEMI);
4370: if (inputState.guessing == 0) {
4371: lp1_AST.setType(CTOR_CALL);
4372: }
4373: break;
4374: }
4375: case LITERAL_super : {
4376: match(LITERAL_super );
4377: lp2 = LT(1);
4378: lp2_AST = astFactory.create(lp2);
4379: astFactory.makeASTRoot(currentAST, lp2_AST);
4380: match(LPAREN);
4381: argList();
4382: astFactory.addASTChild(currentAST, returnAST);
4383: match(RPAREN);
4384: match(SEMI);
4385: if (inputState.guessing == 0) {
4386: lp2_AST.setType(SUPER_CTOR_CALL);
4387: }
4388: break;
4389: }
4390: default: {
4391: throw new NoViableAltException(LT(1), getFilename());
4392: }
4393: }
4394: }
4395: explicitConstructorInvocation_AST = (AST) currentAST.root;
4396: returnAST = explicitConstructorInvocation_AST;
4397: }
4398:
4399: public final void statement() throws RecognitionException,
4400: TokenStreamException {
4401:
4402: returnAST = null;
4403: ASTPair currentAST = new ASTPair();
4404: AST statement_AST = null;
4405: AST m_AST = null;
4406: Token c = null;
4407: AST c_AST = null;
4408: Token s = null;
4409: AST s_AST = null;
4410:
4411: switch (LA(1)) {
4412: case LCURLY: {
4413: compoundStatement();
4414: astFactory.addASTChild(currentAST, returnAST);
4415: statement_AST = (AST) currentAST.root;
4416: break;
4417: }
4418: case LITERAL_if: {
4419: AST tmp132_AST = null;
4420: tmp132_AST = astFactory.create(LT(1));
4421: astFactory.makeASTRoot(currentAST, tmp132_AST);
4422: match(LITERAL_if);
4423: match(LPAREN);
4424: expression();
4425: astFactory.addASTChild(currentAST, returnAST);
4426: match(RPAREN);
4427: statement();
4428: astFactory.addASTChild(currentAST, returnAST);
4429: {
4430: if ((LA(1) == LITERAL_else)
4431: && (_tokenSet_23.member(LA(2)))) {
4432: match(LITERAL_else);
4433: statement();
4434: astFactory.addASTChild(currentAST, returnAST);
4435: } else if ((_tokenSet_28.member(LA(1)))
4436: && (_tokenSet_29.member(LA(2)))) {
4437: } else {
4438: throw new NoViableAltException(LT(1), getFilename());
4439: }
4440:
4441: }
4442: statement_AST = (AST) currentAST.root;
4443: break;
4444: }
4445: case LITERAL_for: {
4446: forStatement();
4447: astFactory.addASTChild(currentAST, returnAST);
4448: statement_AST = (AST) currentAST.root;
4449: break;
4450: }
4451: case LITERAL_while: {
4452: AST tmp136_AST = null;
4453: tmp136_AST = astFactory.create(LT(1));
4454: astFactory.makeASTRoot(currentAST, tmp136_AST);
4455: match(LITERAL_while);
4456: match(LPAREN);
4457: expression();
4458: astFactory.addASTChild(currentAST, returnAST);
4459: match(RPAREN);
4460: statement();
4461: astFactory.addASTChild(currentAST, returnAST);
4462: statement_AST = (AST) currentAST.root;
4463: break;
4464: }
4465: case LITERAL_break: {
4466: AST tmp139_AST = null;
4467: tmp139_AST = astFactory.create(LT(1));
4468: astFactory.makeASTRoot(currentAST, tmp139_AST);
4469: match(LITERAL_break);
4470: {
4471: switch (LA(1)) {
4472: case IDENT: {
4473: AST tmp140_AST = null;
4474: tmp140_AST = astFactory.create(LT(1));
4475: astFactory.addASTChild(currentAST, tmp140_AST);
4476: match(IDENT);
4477: break;
4478: }
4479: case SEMI: {
4480: break;
4481: }
4482: default: {
4483: throw new NoViableAltException(LT(1), getFilename());
4484: }
4485: }
4486: }
4487: match(SEMI);
4488: statement_AST = (AST) currentAST.root;
4489: break;
4490: }
4491: case LITERAL_continue: {
4492: AST tmp142_AST = null;
4493: tmp142_AST = astFactory.create(LT(1));
4494: astFactory.makeASTRoot(currentAST, tmp142_AST);
4495: match(LITERAL_continue);
4496: {
4497: switch (LA(1)) {
4498: case IDENT: {
4499: AST tmp143_AST = null;
4500: tmp143_AST = astFactory.create(LT(1));
4501: astFactory.addASTChild(currentAST, tmp143_AST);
4502: match(IDENT);
4503: break;
4504: }
4505: case SEMI: {
4506: break;
4507: }
4508: default: {
4509: throw new NoViableAltException(LT(1), getFilename());
4510: }
4511: }
4512: }
4513: match(SEMI);
4514: statement_AST = (AST) currentAST.root;
4515: break;
4516: }
4517: case LITERAL_return: {
4518: AST tmp145_AST = null;
4519: tmp145_AST = astFactory.create(LT(1));
4520: astFactory.makeASTRoot(currentAST, tmp145_AST);
4521: match(LITERAL_return);
4522: {
4523: switch (LA(1)) {
4524: case IDENT:
4525: case LITERAL_super :
4526: case LT:
4527: case LITERAL_void:
4528: case LITERAL_boolean:
4529: case LITERAL_byte:
4530: case LITERAL_char:
4531: case LITERAL_short:
4532: case LITERAL_int:
4533: case LITERAL_float:
4534: case LITERAL_long:
4535: case LITERAL_double:
4536: case LPAREN:
4537: case LITERAL_this :
4538: case PLUS:
4539: case MINUS:
4540: case INC:
4541: case DEC:
4542: case BNOT:
4543: case LNOT:
4544: case LITERAL_true:
4545: case LITERAL_false:
4546: case LITERAL_null:
4547: case LITERAL_new:
4548: case NUM_INT:
4549: case STRING_LITERAL:
4550: case NUM_FLOAT:
4551: case NUM_LONG:
4552: case NUM_DOUBLE: {
4553: expression();
4554: astFactory.addASTChild(currentAST, returnAST);
4555: break;
4556: }
4557: case SEMI: {
4558: break;
4559: }
4560: default: {
4561: throw new NoViableAltException(LT(1), getFilename());
4562: }
4563: }
4564: }
4565: match(SEMI);
4566: statement_AST = (AST) currentAST.root;
4567: break;
4568: }
4569: case LITERAL_switch: {
4570: AST tmp147_AST = null;
4571: tmp147_AST = astFactory.create(LT(1));
4572: astFactory.makeASTRoot(currentAST, tmp147_AST);
4573: match(LITERAL_switch);
4574: match(LPAREN);
4575: expression();
4576: astFactory.addASTChild(currentAST, returnAST);
4577: match(RPAREN);
4578: match(LCURLY);
4579: {
4580: _loop196: do {
4581: if ((LA(1) == LITERAL_default || LA(1) == LITERAL_case)) {
4582: casesGroup();
4583: astFactory.addASTChild(currentAST, returnAST);
4584: } else {
4585: break _loop196;
4586: }
4587:
4588: } while (true);
4589: }
4590: match(RCURLY);
4591: statement_AST = (AST) currentAST.root;
4592: break;
4593: }
4594: case LITERAL_try: {
4595: tryBlock();
4596: astFactory.addASTChild(currentAST, returnAST);
4597: statement_AST = (AST) currentAST.root;
4598: break;
4599: }
4600: case LITERAL_throw: {
4601: AST tmp152_AST = null;
4602: tmp152_AST = astFactory.create(LT(1));
4603: astFactory.makeASTRoot(currentAST, tmp152_AST);
4604: match(LITERAL_throw);
4605: expression();
4606: astFactory.addASTChild(currentAST, returnAST);
4607: match(SEMI);
4608: statement_AST = (AST) currentAST.root;
4609: break;
4610: }
4611: case LITERAL_assert: {
4612: AST tmp154_AST = null;
4613: tmp154_AST = astFactory.create(LT(1));
4614: astFactory.makeASTRoot(currentAST, tmp154_AST);
4615: match(LITERAL_assert);
4616: expression();
4617: astFactory.addASTChild(currentAST, returnAST);
4618: {
4619: switch (LA(1)) {
4620: case COLON: {
4621: match(COLON);
4622: expression();
4623: astFactory.addASTChild(currentAST, returnAST);
4624: break;
4625: }
4626: case SEMI: {
4627: break;
4628: }
4629: default: {
4630: throw new NoViableAltException(LT(1), getFilename());
4631: }
4632: }
4633: }
4634: match(SEMI);
4635: statement_AST = (AST) currentAST.root;
4636: break;
4637: }
4638: case SEMI: {
4639: s = LT(1);
4640: s_AST = astFactory.create(s);
4641: astFactory.addASTChild(currentAST, s_AST);
4642: match(SEMI);
4643: if (inputState.guessing == 0) {
4644: s_AST.setType(EMPTY_STAT);
4645: }
4646: statement_AST = (AST) currentAST.root;
4647: break;
4648: }
4649: default:
4650: boolean synPredMatched190 = false;
4651: if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31
4652: .member(LA(2))))) {
4653: int _m190 = mark();
4654: synPredMatched190 = true;
4655: inputState.guessing++;
4656: try {
4657: {
4658: declaration();
4659: }
4660: } catch (RecognitionException pe) {
4661: synPredMatched190 = false;
4662: }
4663: rewind(_m190);
4664: inputState.guessing--;
4665: }
4666: if (synPredMatched190) {
4667: declaration();
4668: astFactory.addASTChild(currentAST, returnAST);
4669: match(SEMI);
4670: statement_AST = (AST) currentAST.root;
4671: } else if ((_tokenSet_32.member(LA(1)))
4672: && (_tokenSet_33.member(LA(2)))) {
4673: expression();
4674: astFactory.addASTChild(currentAST, returnAST);
4675: match(SEMI);
4676: statement_AST = (AST) currentAST.root;
4677: } else if ((_tokenSet_34.member(LA(1)))
4678: && (_tokenSet_35.member(LA(2)))) {
4679: modifiers();
4680: m_AST = (AST) returnAST;
4681: classDefinition(m_AST);
4682: astFactory.addASTChild(currentAST, returnAST);
4683: statement_AST = (AST) currentAST.root;
4684: } else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
4685: AST tmp159_AST = null;
4686: tmp159_AST = astFactory.create(LT(1));
4687: astFactory.addASTChild(currentAST, tmp159_AST);
4688: match(IDENT);
4689: c = LT(1);
4690: c_AST = astFactory.create(c);
4691: astFactory.makeASTRoot(currentAST, c_AST);
4692: match(COLON);
4693: if (inputState.guessing == 0) {
4694: c_AST.setType(LABELED_STAT);
4695: }
4696: statement();
4697: astFactory.addASTChild(currentAST, returnAST);
4698: statement_AST = (AST) currentAST.root;
4699: } else if ((LA(1) == LITERAL_synchronized)
4700: && (LA(2) == LPAREN)) {
4701: AST tmp160_AST = null;
4702: tmp160_AST = astFactory.create(LT(1));
4703: astFactory.makeASTRoot(currentAST, tmp160_AST);
4704: match(LITERAL_synchronized);
4705: match(LPAREN);
4706: expression();
4707: astFactory.addASTChild(currentAST, returnAST);
4708: match(RPAREN);
4709: compoundStatement();
4710: astFactory.addASTChild(currentAST, returnAST);
4711: statement_AST = (AST) currentAST.root;
4712: } else {
4713: throw new NoViableAltException(LT(1), getFilename());
4714: }
4715: }
4716: returnAST = statement_AST;
4717: }
4718:
4719: /** Declaration of a variable. This can be a class/instance variable,
4720: * or a local variable in a method
4721: * It can also include possible initialization.
4722: */
4723: public final void variableDeclarator(AST mods, AST t)
4724: throws RecognitionException, TokenStreamException {
4725:
4726: returnAST = null;
4727: ASTPair currentAST = new ASTPair();
4728: AST variableDeclarator_AST = null;
4729: Token id = null;
4730: AST id_AST = null;
4731: AST d_AST = null;
4732: AST v_AST = null;
4733: Token first = LT(1);
4734:
4735: id = LT(1);
4736: id_AST = astFactory.create(id);
4737: match(IDENT);
4738: declaratorBrackets(t);
4739: d_AST = (AST) returnAST;
4740: varInitializer();
4741: v_AST = (AST) returnAST;
4742: if (inputState.guessing == 0) {
4743: variableDeclarator_AST = (AST) currentAST.root;
4744: variableDeclarator_AST = (AST) astFactory
4745: .make((new ASTArray(5))
4746: .add(
4747: create(VARIABLE_DEF,
4748: "VARIABLE_DEF", first,
4749: LT(1)))
4750: .add(mods)
4751: .add(
4752: (AST) astFactory
4753: .make((new ASTArray(2))
4754: .add(
4755: create(
4756: TYPE,
4757: "TYPE",
4758: first,
4759: LT(1)))
4760: .add(d_AST))).add(
4761: id_AST).add(v_AST));
4762: currentAST.root = variableDeclarator_AST;
4763: currentAST.child = variableDeclarator_AST != null
4764: && variableDeclarator_AST.getFirstChild() != null ? variableDeclarator_AST
4765: .getFirstChild()
4766: : variableDeclarator_AST;
4767: currentAST.advanceChildToEnd();
4768: }
4769: returnAST = variableDeclarator_AST;
4770: }
4771:
4772: public final void varInitializer() throws RecognitionException,
4773: TokenStreamException {
4774:
4775: returnAST = null;
4776: ASTPair currentAST = new ASTPair();
4777: AST varInitializer_AST = null;
4778:
4779: {
4780: switch (LA(1)) {
4781: case ASSIGN: {
4782: AST tmp163_AST = null;
4783: tmp163_AST = astFactory.create(LT(1));
4784: astFactory.makeASTRoot(currentAST, tmp163_AST);
4785: match(ASSIGN);
4786: initializer();
4787: astFactory.addASTChild(currentAST, returnAST);
4788: break;
4789: }
4790: case SEMI:
4791: case COMMA: {
4792: break;
4793: }
4794: default: {
4795: throw new NoViableAltException(LT(1), getFilename());
4796: }
4797: }
4798: }
4799: varInitializer_AST = (AST) currentAST.root;
4800: returnAST = varInitializer_AST;
4801: }
4802:
4803: public final void initializer() throws RecognitionException,
4804: TokenStreamException {
4805:
4806: returnAST = null;
4807: ASTPair currentAST = new ASTPair();
4808: AST initializer_AST = null;
4809:
4810: expression();
4811: astFactory.addASTChild(currentAST, returnAST);
4812: initializer_AST = (AST) currentAST.root;
4813: returnAST = initializer_AST;
4814: }
4815:
4816: public final void expression() throws RecognitionException,
4817: TokenStreamException {
4818:
4819: returnAST = null;
4820: ASTPair currentAST = new ASTPair();
4821: AST expression_AST = null;
4822: Token first = LT(1);
4823:
4824: assignmentExpression();
4825: astFactory.addASTChild(currentAST, returnAST);
4826: if (inputState.guessing == 0) {
4827: expression_AST = (AST) currentAST.root;
4828: expression_AST = (AST) astFactory.make((new ASTArray(2))
4829: .add(create(EXPR, "EXPR", first, LT(1))).add(
4830: expression_AST));
4831: currentAST.root = expression_AST;
4832: currentAST.child = expression_AST != null
4833: && expression_AST.getFirstChild() != null ? expression_AST
4834: .getFirstChild()
4835: : expression_AST;
4836: currentAST.advanceChildToEnd();
4837: }
4838: expression_AST = (AST) currentAST.root;
4839: returnAST = expression_AST;
4840: }
4841:
4842: public final void parameterDeclaration()
4843: throws RecognitionException, TokenStreamException {
4844:
4845: returnAST = null;
4846: ASTPair currentAST = new ASTPair();
4847: AST parameterDeclaration_AST = null;
4848: AST pm_AST = null;
4849: AST t_AST = null;
4850: Token id = null;
4851: AST id_AST = null;
4852: AST pd_AST = null;
4853: Token first = LT(1);
4854:
4855: parameterModifier();
4856: pm_AST = (AST) returnAST;
4857: typeSpec(false);
4858: t_AST = (AST) returnAST;
4859: id = LT(1);
4860: id_AST = astFactory.create(id);
4861: match(IDENT);
4862: declaratorBrackets(t_AST);
4863: pd_AST = (AST) returnAST;
4864: if (inputState.guessing == 0) {
4865: parameterDeclaration_AST = (AST) currentAST.root;
4866: parameterDeclaration_AST = (AST) astFactory
4867: .make((new ASTArray(4))
4868: .add(
4869: create(PARAMETER_DEF,
4870: "PARAMETER_DEF", first,
4871: LT(1)))
4872: .add(pm_AST)
4873: .add(
4874: (AST) astFactory
4875: .make((new ASTArray(2))
4876: .add(
4877: create(
4878: TYPE,
4879: "TYPE",
4880: first,
4881: LT(1)))
4882: .add(pd_AST))).add(
4883: id_AST));
4884: currentAST.root = parameterDeclaration_AST;
4885: currentAST.child = parameterDeclaration_AST != null
4886: && parameterDeclaration_AST.getFirstChild() != null ? parameterDeclaration_AST
4887: .getFirstChild()
4888: : parameterDeclaration_AST;
4889: currentAST.advanceChildToEnd();
4890: }
4891: returnAST = parameterDeclaration_AST;
4892: }
4893:
4894: public final void variableLengthParameterDeclaration()
4895: throws RecognitionException, TokenStreamException {
4896:
4897: returnAST = null;
4898: ASTPair currentAST = new ASTPair();
4899: AST variableLengthParameterDeclaration_AST = null;
4900: AST pm_AST = null;
4901: AST t_AST = null;
4902: Token id = null;
4903: AST id_AST = null;
4904: AST pd_AST = null;
4905: Token first = LT(1);
4906:
4907: parameterModifier();
4908: pm_AST = (AST) returnAST;
4909: typeSpec(false);
4910: t_AST = (AST) returnAST;
4911: match(TRIPLE_DOT);
4912: id = LT(1);
4913: id_AST = astFactory.create(id);
4914: match(IDENT);
4915: declaratorBrackets(t_AST);
4916: pd_AST = (AST) returnAST;
4917: if (inputState.guessing == 0) {
4918: variableLengthParameterDeclaration_AST = (AST) currentAST.root;
4919: variableLengthParameterDeclaration_AST = (AST) astFactory
4920: .make((new ASTArray(4))
4921: .add(
4922: create(VARIABLE_PARAMETER_DEF,
4923: "VARIABLE_PARAMETER_DEF",
4924: first, LT(1)))
4925: .add(pm_AST)
4926: .add(
4927: (AST) astFactory
4928: .make((new ASTArray(2))
4929: .add(
4930: create(
4931: TYPE,
4932: "TYPE",
4933: first,
4934: LT(1)))
4935: .add(pd_AST))).add(
4936: id_AST));
4937: currentAST.root = variableLengthParameterDeclaration_AST;
4938: currentAST.child = variableLengthParameterDeclaration_AST != null
4939: && variableLengthParameterDeclaration_AST
4940: .getFirstChild() != null ? variableLengthParameterDeclaration_AST
4941: .getFirstChild()
4942: : variableLengthParameterDeclaration_AST;
4943: currentAST.advanceChildToEnd();
4944: }
4945: returnAST = variableLengthParameterDeclaration_AST;
4946: }
4947:
4948: public final void parameterModifier() throws RecognitionException,
4949: TokenStreamException {
4950:
4951: returnAST = null;
4952: ASTPair currentAST = new ASTPair();
4953: AST parameterModifier_AST = null;
4954: Token f = null;
4955: AST f_AST = null;
4956: Token first = LT(1);
4957:
4958: {
4959: _loop181: do {
4960: if ((LA(1) == AT) && (LA(2) == IDENT)) {
4961: annotation();
4962: astFactory.addASTChild(currentAST, returnAST);
4963: } else {
4964: break _loop181;
4965: }
4966:
4967: } while (true);
4968: }
4969: {
4970: switch (LA(1)) {
4971: case FINAL: {
4972: f = LT(1);
4973: f_AST = astFactory.create(f);
4974: astFactory.addASTChild(currentAST, f_AST);
4975: match(FINAL);
4976: break;
4977: }
4978: case IDENT:
4979: case LITERAL_void:
4980: case LITERAL_boolean:
4981: case LITERAL_byte:
4982: case LITERAL_char:
4983: case LITERAL_short:
4984: case LITERAL_int:
4985: case LITERAL_float:
4986: case LITERAL_long:
4987: case LITERAL_double:
4988: case AT: {
4989: break;
4990: }
4991: default: {
4992: throw new NoViableAltException(LT(1), getFilename());
4993: }
4994: }
4995: }
4996: {
4997: _loop184: do {
4998: if ((LA(1) == AT)) {
4999: annotation();
5000: astFactory.addASTChild(currentAST, returnAST);
5001: } else {
5002: break _loop184;
5003: }
5004:
5005: } while (true);
5006: }
5007: if (inputState.guessing == 0) {
5008: parameterModifier_AST = (AST) currentAST.root;
5009: parameterModifier_AST = (AST) astFactory
5010: .make((new ASTArray(2))
5011: .add(
5012: create(MODIFIERS, "MODIFIERS",
5013: first, LT(1))).add(
5014: parameterModifier_AST));
5015: currentAST.root = parameterModifier_AST;
5016: currentAST.child = parameterModifier_AST != null
5017: && parameterModifier_AST.getFirstChild() != null ? parameterModifier_AST
5018: .getFirstChild()
5019: : parameterModifier_AST;
5020: currentAST.advanceChildToEnd();
5021: }
5022: parameterModifier_AST = (AST) currentAST.root;
5023: returnAST = parameterModifier_AST;
5024: }
5025:
5026: public final void forStatement() throws RecognitionException,
5027: TokenStreamException {
5028:
5029: returnAST = null;
5030: ASTPair currentAST = new ASTPair();
5031: AST forStatement_AST = null;
5032: Token f = null;
5033: AST f_AST = null;
5034:
5035: f = LT(1);
5036: f_AST = astFactory.create(f);
5037: astFactory.makeASTRoot(currentAST, f_AST);
5038: match(LITERAL_for);
5039: match(LPAREN);
5040: {
5041: boolean synPredMatched201 = false;
5042: if (((_tokenSet_36.member(LA(1))) && (_tokenSet_37
5043: .member(LA(2))))) {
5044: int _m201 = mark();
5045: synPredMatched201 = true;
5046: inputState.guessing++;
5047: try {
5048: {
5049: forInit();
5050: match(SEMI);
5051: }
5052: } catch (RecognitionException pe) {
5053: synPredMatched201 = false;
5054: }
5055: rewind(_m201);
5056: inputState.guessing--;
5057: }
5058: if (synPredMatched201) {
5059: traditionalForClause();
5060: astFactory.addASTChild(currentAST, returnAST);
5061: } else if ((_tokenSet_20.member(LA(1)))
5062: && (_tokenSet_21.member(LA(2)))) {
5063: forEachClause();
5064: astFactory.addASTChild(currentAST, returnAST);
5065: } else {
5066: throw new NoViableAltException(LT(1), getFilename());
5067: }
5068:
5069: }
5070: match(RPAREN);
5071: statement();
5072: astFactory.addASTChild(currentAST, returnAST);
5073: forStatement_AST = (AST) currentAST.root;
5074: returnAST = forStatement_AST;
5075: }
5076:
5077: public final void casesGroup() throws RecognitionException,
5078: TokenStreamException {
5079:
5080: returnAST = null;
5081: ASTPair currentAST = new ASTPair();
5082: AST casesGroup_AST = null;
5083:
5084: {
5085: int _cnt206 = 0;
5086: _loop206: do {
5087: if ((LA(1) == LITERAL_default || LA(1) == LITERAL_case)
5088: && (_tokenSet_38.member(LA(2)))) {
5089: aCase();
5090: astFactory.addASTChild(currentAST, returnAST);
5091: } else {
5092: if (_cnt206 >= 1) {
5093: break _loop206;
5094: } else {
5095: throw new NoViableAltException(LT(1),
5096: getFilename());
5097: }
5098: }
5099:
5100: _cnt206++;
5101: } while (true);
5102: }
5103: caseSList();
5104: astFactory.addASTChild(currentAST, returnAST);
5105: if (inputState.guessing == 0) {
5106: casesGroup_AST = (AST) currentAST.root;
5107: casesGroup_AST = (AST) astFactory.make((new ASTArray(2))
5108: .add(astFactory.create(CASE_GROUP, "CASE_GROUP"))
5109: .add(casesGroup_AST));
5110: currentAST.root = casesGroup_AST;
5111: currentAST.child = casesGroup_AST != null
5112: && casesGroup_AST.getFirstChild() != null ? casesGroup_AST
5113: .getFirstChild()
5114: : casesGroup_AST;
5115: currentAST.advanceChildToEnd();
5116: }
5117: casesGroup_AST = (AST) currentAST.root;
5118: returnAST = casesGroup_AST;
5119: }
5120:
5121: public final void tryBlock() throws RecognitionException,
5122: TokenStreamException {
5123:
5124: returnAST = null;
5125: ASTPair currentAST = new ASTPair();
5126: AST tryBlock_AST = null;
5127:
5128: AST tmp167_AST = null;
5129: tmp167_AST = astFactory.create(LT(1));
5130: astFactory.makeASTRoot(currentAST, tmp167_AST);
5131: match(LITERAL_try);
5132: compoundStatement();
5133: astFactory.addASTChild(currentAST, returnAST);
5134: {
5135: _loop222: do {
5136: if ((LA(1) == LITERAL_catch)) {
5137: handler();
5138: astFactory.addASTChild(currentAST, returnAST);
5139: } else {
5140: break _loop222;
5141: }
5142:
5143: } while (true);
5144: }
5145: {
5146: switch (LA(1)) {
5147: case LITERAL_finally: {
5148: finallyClause();
5149: astFactory.addASTChild(currentAST, returnAST);
5150: break;
5151: }
5152: case FINAL:
5153: case ABSTRACT:
5154: case STRICTFP:
5155: case SEMI:
5156: case LITERAL_static:
5157: case IDENT:
5158: case LITERAL_super :
5159: case LT:
5160: case LITERAL_void:
5161: case LITERAL_boolean:
5162: case LITERAL_byte:
5163: case LITERAL_char:
5164: case LITERAL_short:
5165: case LITERAL_int:
5166: case LITERAL_float:
5167: case LITERAL_long:
5168: case LITERAL_double:
5169: case LITERAL_private:
5170: case LITERAL_public:
5171: case LITERAL_protected:
5172: case LITERAL_transient:
5173: case LITERAL_native:
5174: case LITERAL_threadsafe:
5175: case LITERAL_synchronized:
5176: case LITERAL_volatile:
5177: case AT:
5178: case LPAREN:
5179: case LCURLY:
5180: case RCURLY:
5181: case LITERAL_class:
5182: case LITERAL_default:
5183: case LITERAL_this :
5184: case LITERAL_if:
5185: case LITERAL_else:
5186: case LITERAL_while:
5187: case LITERAL_break:
5188: case LITERAL_continue:
5189: case LITERAL_return:
5190: case LITERAL_switch:
5191: case LITERAL_throw:
5192: case LITERAL_assert:
5193: case LITERAL_for:
5194: case LITERAL_case:
5195: case LITERAL_try:
5196: case PLUS:
5197: case MINUS:
5198: case INC:
5199: case DEC:
5200: case BNOT:
5201: case LNOT:
5202: case LITERAL_true:
5203: case LITERAL_false:
5204: case LITERAL_null:
5205: case LITERAL_new:
5206: case NUM_INT:
5207: case STRING_LITERAL:
5208: case NUM_FLOAT:
5209: case NUM_LONG:
5210: case NUM_DOUBLE: {
5211: break;
5212: }
5213: default: {
5214: throw new NoViableAltException(LT(1), getFilename());
5215: }
5216: }
5217: }
5218: tryBlock_AST = (AST) currentAST.root;
5219: returnAST = tryBlock_AST;
5220: }
5221:
5222: public final void forInit() throws RecognitionException,
5223: TokenStreamException {
5224:
5225: returnAST = null;
5226: ASTPair currentAST = new ASTPair();
5227: AST forInit_AST = null;
5228: Token first = LT(1);
5229:
5230: {
5231: boolean synPredMatched215 = false;
5232: if (((_tokenSet_30.member(LA(1))) && (_tokenSet_31
5233: .member(LA(2))))) {
5234: int _m215 = mark();
5235: synPredMatched215 = true;
5236: inputState.guessing++;
5237: try {
5238: {
5239: declaration();
5240: }
5241: } catch (RecognitionException pe) {
5242: synPredMatched215 = false;
5243: }
5244: rewind(_m215);
5245: inputState.guessing--;
5246: }
5247: if (synPredMatched215) {
5248: declaration();
5249: astFactory.addASTChild(currentAST, returnAST);
5250: } else if ((_tokenSet_32.member(LA(1)))
5251: && (_tokenSet_39.member(LA(2)))) {
5252: expressionList();
5253: astFactory.addASTChild(currentAST, returnAST);
5254: } else if ((LA(1) == SEMI)) {
5255: } else {
5256: throw new NoViableAltException(LT(1), getFilename());
5257: }
5258:
5259: }
5260: if (inputState.guessing == 0) {
5261: forInit_AST = (AST) currentAST.root;
5262: forInit_AST = (AST) astFactory.make((new ASTArray(2)).add(
5263: create(FOR_INIT, "FOR_INIT", first, LT(1))).add(
5264: forInit_AST));
5265: currentAST.root = forInit_AST;
5266: currentAST.child = forInit_AST != null
5267: && forInit_AST.getFirstChild() != null ? forInit_AST
5268: .getFirstChild()
5269: : forInit_AST;
5270: currentAST.advanceChildToEnd();
5271: }
5272: forInit_AST = (AST) currentAST.root;
5273: returnAST = forInit_AST;
5274: }
5275:
5276: public final void traditionalForClause()
5277: throws RecognitionException, TokenStreamException {
5278:
5279: returnAST = null;
5280: ASTPair currentAST = new ASTPair();
5281: AST traditionalForClause_AST = null;
5282:
5283: forInit();
5284: astFactory.addASTChild(currentAST, returnAST);
5285: match(SEMI);
5286: forCond();
5287: astFactory.addASTChild(currentAST, returnAST);
5288: match(SEMI);
5289: forIter();
5290: astFactory.addASTChild(currentAST, returnAST);
5291: traditionalForClause_AST = (AST) currentAST.root;
5292: returnAST = traditionalForClause_AST;
5293: }
5294:
5295: public final void forEachClause() throws RecognitionException,
5296: TokenStreamException {
5297:
5298: returnAST = null;
5299: ASTPair currentAST = new ASTPair();
5300: AST forEachClause_AST = null;
5301: AST p_AST = null;
5302: Token first = LT(1);
5303:
5304: parameterDeclaration();
5305: p_AST = (AST) returnAST;
5306: astFactory.addASTChild(currentAST, returnAST);
5307: match(COLON);
5308: expression();
5309: astFactory.addASTChild(currentAST, returnAST);
5310: if (inputState.guessing == 0) {
5311: forEachClause_AST = (AST) currentAST.root;
5312: forEachClause_AST = (AST) astFactory.make((new ASTArray(2))
5313: .add(
5314: create(FOR_EACH_CLAUSE, "FOR_EACH_CLAUSE",
5315: first, LT(1))).add(
5316: forEachClause_AST));
5317: currentAST.root = forEachClause_AST;
5318: currentAST.child = forEachClause_AST != null
5319: && forEachClause_AST.getFirstChild() != null ? forEachClause_AST
5320: .getFirstChild()
5321: : forEachClause_AST;
5322: currentAST.advanceChildToEnd();
5323: }
5324: forEachClause_AST = (AST) currentAST.root;
5325: returnAST = forEachClause_AST;
5326: }
5327:
5328: public final void forCond() throws RecognitionException,
5329: TokenStreamException {
5330:
5331: returnAST = null;
5332: ASTPair currentAST = new ASTPair();
5333: AST forCond_AST = null;
5334: Token first = LT(1);
5335:
5336: {
5337: switch (LA(1)) {
5338: case IDENT:
5339: case LITERAL_super :
5340: case LT:
5341: case LITERAL_void:
5342: case LITERAL_boolean:
5343: case LITERAL_byte:
5344: case LITERAL_char:
5345: case LITERAL_short:
5346: case LITERAL_int:
5347: case LITERAL_float:
5348: case LITERAL_long:
5349: case LITERAL_double:
5350: case LPAREN:
5351: case LITERAL_this :
5352: case PLUS:
5353: case MINUS:
5354: case INC:
5355: case DEC:
5356: case BNOT:
5357: case LNOT:
5358: case LITERAL_true:
5359: case LITERAL_false:
5360: case LITERAL_null:
5361: case LITERAL_new:
5362: case NUM_INT:
5363: case STRING_LITERAL:
5364: case NUM_FLOAT:
5365: case NUM_LONG:
5366: case NUM_DOUBLE: {
5367: expression();
5368: astFactory.addASTChild(currentAST, returnAST);
5369: break;
5370: }
5371: case SEMI: {
5372: break;
5373: }
5374: default: {
5375: throw new NoViableAltException(LT(1), getFilename());
5376: }
5377: }
5378: }
5379: if (inputState.guessing == 0) {
5380: forCond_AST = (AST) currentAST.root;
5381: forCond_AST = (AST) astFactory.make((new ASTArray(2))
5382: .add(
5383: create(FOR_CONDITION, "FOR_CONDITION",
5384: first, LT(1))).add(forCond_AST));
5385: currentAST.root = forCond_AST;
5386: currentAST.child = forCond_AST != null
5387: && forCond_AST.getFirstChild() != null ? forCond_AST
5388: .getFirstChild()
5389: : forCond_AST;
5390: currentAST.advanceChildToEnd();
5391: }
5392: forCond_AST = (AST) currentAST.root;
5393: returnAST = forCond_AST;
5394: }
5395:
5396: public final void forIter() throws RecognitionException,
5397: TokenStreamException {
5398:
5399: returnAST = null;
5400: ASTPair currentAST = new ASTPair();
5401: AST forIter_AST = null;
5402: Token first = LT(1);
5403:
5404: {
5405: switch (LA(1)) {
5406: case IDENT:
5407: case LITERAL_super :
5408: case LT:
5409: case LITERAL_void:
5410: case LITERAL_boolean:
5411: case LITERAL_byte:
5412: case LITERAL_char:
5413: case LITERAL_short:
5414: case LITERAL_int:
5415: case LITERAL_float:
5416: case LITERAL_long:
5417: case LITERAL_double:
5418: case LPAREN:
5419: case LITERAL_this :
5420: case PLUS:
5421: case MINUS:
5422: case INC:
5423: case DEC:
5424: case BNOT:
5425: case LNOT:
5426: case LITERAL_true:
5427: case LITERAL_false:
5428: case LITERAL_null:
5429: case LITERAL_new:
5430: case NUM_INT:
5431: case STRING_LITERAL:
5432: case NUM_FLOAT:
5433: case NUM_LONG:
5434: case NUM_DOUBLE: {
5435: expressionList();
5436: astFactory.addASTChild(currentAST, returnAST);
5437: break;
5438: }
5439: case RPAREN: {
5440: break;
5441: }
5442: default: {
5443: throw new NoViableAltException(LT(1), getFilename());
5444: }
5445: }
5446: }
5447: if (inputState.guessing == 0) {
5448: forIter_AST = (AST) currentAST.root;
5449: forIter_AST = (AST) astFactory.make((new ASTArray(2)).add(
5450: create(FOR_ITERATOR, "FOR_ITERATOR", first, LT(1)))
5451: .add(forIter_AST));
5452: currentAST.root = forIter_AST;
5453: currentAST.child = forIter_AST != null
5454: && forIter_AST.getFirstChild() != null ? forIter_AST
5455: .getFirstChild()
5456: : forIter_AST;
5457: currentAST.advanceChildToEnd();
5458: }
5459: forIter_AST = (AST) currentAST.root;
5460: returnAST = forIter_AST;
5461: }
5462:
5463: public final void aCase() throws RecognitionException,
5464: TokenStreamException {
5465:
5466: returnAST = null;
5467: ASTPair currentAST = new ASTPair();
5468: AST aCase_AST = null;
5469:
5470: {
5471: switch (LA(1)) {
5472: case LITERAL_case: {
5473: AST tmp171_AST = null;
5474: tmp171_AST = astFactory.create(LT(1));
5475: astFactory.makeASTRoot(currentAST, tmp171_AST);
5476: match(LITERAL_case);
5477: expression();
5478: astFactory.addASTChild(currentAST, returnAST);
5479: break;
5480: }
5481: case LITERAL_default: {
5482: AST tmp172_AST = null;
5483: tmp172_AST = astFactory.create(LT(1));
5484: astFactory.addASTChild(currentAST, tmp172_AST);
5485: match(LITERAL_default);
5486: break;
5487: }
5488: default: {
5489: throw new NoViableAltException(LT(1), getFilename());
5490: }
5491: }
5492: }
5493: match(COLON);
5494: aCase_AST = (AST) currentAST.root;
5495: returnAST = aCase_AST;
5496: }
5497:
5498: public final void caseSList() throws RecognitionException,
5499: TokenStreamException {
5500:
5501: returnAST = null;
5502: ASTPair currentAST = new ASTPair();
5503: AST caseSList_AST = null;
5504: Token first = LT(1);
5505:
5506: {
5507: _loop211: do {
5508: if ((_tokenSet_23.member(LA(1)))) {
5509: statement();
5510: astFactory.addASTChild(currentAST, returnAST);
5511: } else {
5512: break _loop211;
5513: }
5514:
5515: } while (true);
5516: }
5517: if (inputState.guessing == 0) {
5518: caseSList_AST = (AST) currentAST.root;
5519: caseSList_AST = (AST) astFactory.make((new ASTArray(2))
5520: .add(create(SLIST, "SLIST", first, LT(1))).add(
5521: caseSList_AST));
5522: currentAST.root = caseSList_AST;
5523: currentAST.child = caseSList_AST != null
5524: && caseSList_AST.getFirstChild() != null ? caseSList_AST
5525: .getFirstChild()
5526: : caseSList_AST;
5527: currentAST.advanceChildToEnd();
5528: }
5529: caseSList_AST = (AST) currentAST.root;
5530: returnAST = caseSList_AST;
5531: }
5532:
5533: public final void expressionList() throws RecognitionException,
5534: TokenStreamException {
5535:
5536: returnAST = null;
5537: ASTPair currentAST = new ASTPair();
5538: AST expressionList_AST = null;
5539: Token first = LT(1);
5540:
5541: expression();
5542: astFactory.addASTChild(currentAST, returnAST);
5543: {
5544: _loop229: do {
5545: if ((LA(1) == COMMA)) {
5546: match(COMMA);
5547: expression();
5548: astFactory.addASTChild(currentAST, returnAST);
5549: } else {
5550: break _loop229;
5551: }
5552:
5553: } while (true);
5554: }
5555: if (inputState.guessing == 0) {
5556: expressionList_AST = (AST) currentAST.root;
5557: expressionList_AST = (AST) astFactory
5558: .make((new ASTArray(2)).add(
5559: create(ELIST, "ELIST", first, LT(1))).add(
5560: expressionList_AST));
5561: currentAST.root = expressionList_AST;
5562: currentAST.child = expressionList_AST != null
5563: && expressionList_AST.getFirstChild() != null ? expressionList_AST
5564: .getFirstChild()
5565: : expressionList_AST;
5566: currentAST.advanceChildToEnd();
5567: }
5568: expressionList_AST = (AST) currentAST.root;
5569: returnAST = expressionList_AST;
5570: }
5571:
5572: public final void handler() throws RecognitionException,
5573: TokenStreamException {
5574:
5575: returnAST = null;
5576: ASTPair currentAST = new ASTPair();
5577: AST handler_AST = null;
5578:
5579: AST tmp175_AST = null;
5580: tmp175_AST = astFactory.create(LT(1));
5581: astFactory.makeASTRoot(currentAST, tmp175_AST);
5582: match(LITERAL_catch);
5583: match(LPAREN);
5584: parameterDeclaration();
5585: astFactory.addASTChild(currentAST, returnAST);
5586: match(RPAREN);
5587: compoundStatement();
5588: astFactory.addASTChild(currentAST, returnAST);
5589: handler_AST = (AST) currentAST.root;
5590: returnAST = handler_AST;
5591: }
5592:
5593: public final void finallyClause() throws RecognitionException,
5594: TokenStreamException {
5595:
5596: returnAST = null;
5597: ASTPair currentAST = new ASTPair();
5598: AST finallyClause_AST = null;
5599:
5600: AST tmp178_AST = null;
5601: tmp178_AST = astFactory.create(LT(1));
5602: astFactory.makeASTRoot(currentAST, tmp178_AST);
5603: match(LITERAL_finally);
5604: compoundStatement();
5605: astFactory.addASTChild(currentAST, returnAST);
5606: finallyClause_AST = (AST) currentAST.root;
5607: returnAST = finallyClause_AST;
5608: }
5609:
5610: public final void assignmentExpression()
5611: throws RecognitionException, TokenStreamException {
5612:
5613: returnAST = null;
5614: ASTPair currentAST = new ASTPair();
5615: AST assignmentExpression_AST = null;
5616:
5617: conditionalExpression();
5618: astFactory.addASTChild(currentAST, returnAST);
5619: {
5620: switch (LA(1)) {
5621: case ASSIGN:
5622: case PLUS_ASSIGN:
5623: case MINUS_ASSIGN:
5624: case STAR_ASSIGN:
5625: case DIV_ASSIGN:
5626: case MOD_ASSIGN:
5627: case SR_ASSIGN:
5628: case BSR_ASSIGN:
5629: case SL_ASSIGN:
5630: case BAND_ASSIGN:
5631: case BXOR_ASSIGN:
5632: case BOR_ASSIGN: {
5633: {
5634: switch (LA(1)) {
5635: case ASSIGN: {
5636: AST tmp179_AST = null;
5637: tmp179_AST = astFactory.create(LT(1));
5638: astFactory.makeASTRoot(currentAST, tmp179_AST);
5639: match(ASSIGN);
5640: break;
5641: }
5642: case PLUS_ASSIGN: {
5643: AST tmp180_AST = null;
5644: tmp180_AST = astFactory.create(LT(1));
5645: astFactory.makeASTRoot(currentAST, tmp180_AST);
5646: match(PLUS_ASSIGN);
5647: break;
5648: }
5649: case MINUS_ASSIGN: {
5650: AST tmp181_AST = null;
5651: tmp181_AST = astFactory.create(LT(1));
5652: astFactory.makeASTRoot(currentAST, tmp181_AST);
5653: match(MINUS_ASSIGN);
5654: break;
5655: }
5656: case STAR_ASSIGN: {
5657: AST tmp182_AST = null;
5658: tmp182_AST = astFactory.create(LT(1));
5659: astFactory.makeASTRoot(currentAST, tmp182_AST);
5660: match(STAR_ASSIGN);
5661: break;
5662: }
5663: case DIV_ASSIGN: {
5664: AST tmp183_AST = null;
5665: tmp183_AST = astFactory.create(LT(1));
5666: astFactory.makeASTRoot(currentAST, tmp183_AST);
5667: match(DIV_ASSIGN);
5668: break;
5669: }
5670: case MOD_ASSIGN: {
5671: AST tmp184_AST = null;
5672: tmp184_AST = astFactory.create(LT(1));
5673: astFactory.makeASTRoot(currentAST, tmp184_AST);
5674: match(MOD_ASSIGN);
5675: break;
5676: }
5677: case SR_ASSIGN: {
5678: AST tmp185_AST = null;
5679: tmp185_AST = astFactory.create(LT(1));
5680: astFactory.makeASTRoot(currentAST, tmp185_AST);
5681: match(SR_ASSIGN);
5682: break;
5683: }
5684: case BSR_ASSIGN: {
5685: AST tmp186_AST = null;
5686: tmp186_AST = astFactory.create(LT(1));
5687: astFactory.makeASTRoot(currentAST, tmp186_AST);
5688: match(BSR_ASSIGN);
5689: break;
5690: }
5691: case SL_ASSIGN: {
5692: AST tmp187_AST = null;
5693: tmp187_AST = astFactory.create(LT(1));
5694: astFactory.makeASTRoot(currentAST, tmp187_AST);
5695: match(SL_ASSIGN);
5696: break;
5697: }
5698: case BAND_ASSIGN: {
5699: AST tmp188_AST = null;
5700: tmp188_AST = astFactory.create(LT(1));
5701: astFactory.makeASTRoot(currentAST, tmp188_AST);
5702: match(BAND_ASSIGN);
5703: break;
5704: }
5705: case BXOR_ASSIGN: {
5706: AST tmp189_AST = null;
5707: tmp189_AST = astFactory.create(LT(1));
5708: astFactory.makeASTRoot(currentAST, tmp189_AST);
5709: match(BXOR_ASSIGN);
5710: break;
5711: }
5712: case BOR_ASSIGN: {
5713: AST tmp190_AST = null;
5714: tmp190_AST = astFactory.create(LT(1));
5715: astFactory.makeASTRoot(currentAST, tmp190_AST);
5716: match(BOR_ASSIGN);
5717: break;
5718: }
5719: default: {
5720: throw new NoViableAltException(LT(1),
5721: getFilename());
5722: }
5723: }
5724: }
5725: assignmentExpression();
5726: astFactory.addASTChild(currentAST, returnAST);
5727: break;
5728: }
5729: case SEMI:
5730: case RBRACK:
5731: case COMMA:
5732: case RPAREN:
5733: case COLON: {
5734: break;
5735: }
5736: default: {
5737: throw new NoViableAltException(LT(1), getFilename());
5738: }
5739: }
5740: }
5741: assignmentExpression_AST = (AST) currentAST.root;
5742: returnAST = assignmentExpression_AST;
5743: }
5744:
5745: public final void logicalOrExpression()
5746: throws RecognitionException, TokenStreamException {
5747:
5748: returnAST = null;
5749: ASTPair currentAST = new ASTPair();
5750: AST logicalOrExpression_AST = null;
5751:
5752: logicalAndExpression();
5753: astFactory.addASTChild(currentAST, returnAST);
5754: {
5755: _loop237: do {
5756: if ((LA(1) == LOR)) {
5757: AST tmp191_AST = null;
5758: tmp191_AST = astFactory.create(LT(1));
5759: astFactory.makeASTRoot(currentAST, tmp191_AST);
5760: match(LOR);
5761: logicalAndExpression();
5762: astFactory.addASTChild(currentAST, returnAST);
5763: } else {
5764: break _loop237;
5765: }
5766:
5767: } while (true);
5768: }
5769: logicalOrExpression_AST = (AST) currentAST.root;
5770: returnAST = logicalOrExpression_AST;
5771: }
5772:
5773: public final void logicalAndExpression()
5774: throws RecognitionException, TokenStreamException {
5775:
5776: returnAST = null;
5777: ASTPair currentAST = new ASTPair();
5778: AST logicalAndExpression_AST = null;
5779:
5780: inclusiveOrExpression();
5781: astFactory.addASTChild(currentAST, returnAST);
5782: {
5783: _loop240: do {
5784: if ((LA(1) == LAND)) {
5785: AST tmp192_AST = null;
5786: tmp192_AST = astFactory.create(LT(1));
5787: astFactory.makeASTRoot(currentAST, tmp192_AST);
5788: match(LAND);
5789: inclusiveOrExpression();
5790: astFactory.addASTChild(currentAST, returnAST);
5791: } else {
5792: break _loop240;
5793: }
5794:
5795: } while (true);
5796: }
5797: logicalAndExpression_AST = (AST) currentAST.root;
5798: returnAST = logicalAndExpression_AST;
5799: }
5800:
5801: public final void inclusiveOrExpression()
5802: throws RecognitionException, TokenStreamException {
5803:
5804: returnAST = null;
5805: ASTPair currentAST = new ASTPair();
5806: AST inclusiveOrExpression_AST = null;
5807:
5808: exclusiveOrExpression();
5809: astFactory.addASTChild(currentAST, returnAST);
5810: {
5811: _loop243: do {
5812: if ((LA(1) == BOR)) {
5813: AST tmp193_AST = null;
5814: tmp193_AST = astFactory.create(LT(1));
5815: astFactory.makeASTRoot(currentAST, tmp193_AST);
5816: match(BOR);
5817: exclusiveOrExpression();
5818: astFactory.addASTChild(currentAST, returnAST);
5819: } else {
5820: break _loop243;
5821: }
5822:
5823: } while (true);
5824: }
5825: inclusiveOrExpression_AST = (AST) currentAST.root;
5826: returnAST = inclusiveOrExpression_AST;
5827: }
5828:
5829: public final void exclusiveOrExpression()
5830: throws RecognitionException, TokenStreamException {
5831:
5832: returnAST = null;
5833: ASTPair currentAST = new ASTPair();
5834: AST exclusiveOrExpression_AST = null;
5835:
5836: andExpression();
5837: astFactory.addASTChild(currentAST, returnAST);
5838: {
5839: _loop246: do {
5840: if ((LA(1) == BXOR)) {
5841: AST tmp194_AST = null;
5842: tmp194_AST = astFactory.create(LT(1));
5843: astFactory.makeASTRoot(currentAST, tmp194_AST);
5844: match(BXOR);
5845: andExpression();
5846: astFactory.addASTChild(currentAST, returnAST);
5847: } else {
5848: break _loop246;
5849: }
5850:
5851: } while (true);
5852: }
5853: exclusiveOrExpression_AST = (AST) currentAST.root;
5854: returnAST = exclusiveOrExpression_AST;
5855: }
5856:
5857: public final void andExpression() throws RecognitionException,
5858: TokenStreamException {
5859:
5860: returnAST = null;
5861: ASTPair currentAST = new ASTPair();
5862: AST andExpression_AST = null;
5863:
5864: equalityExpression();
5865: astFactory.addASTChild(currentAST, returnAST);
5866: {
5867: _loop249: do {
5868: if ((LA(1) == BAND)) {
5869: AST tmp195_AST = null;
5870: tmp195_AST = astFactory.create(LT(1));
5871: astFactory.makeASTRoot(currentAST, tmp195_AST);
5872: match(BAND);
5873: equalityExpression();
5874: astFactory.addASTChild(currentAST, returnAST);
5875: } else {
5876: break _loop249;
5877: }
5878:
5879: } while (true);
5880: }
5881: andExpression_AST = (AST) currentAST.root;
5882: returnAST = andExpression_AST;
5883: }
5884:
5885: public final void equalityExpression() throws RecognitionException,
5886: TokenStreamException {
5887:
5888: returnAST = null;
5889: ASTPair currentAST = new ASTPair();
5890: AST equalityExpression_AST = null;
5891:
5892: relationalExpression();
5893: astFactory.addASTChild(currentAST, returnAST);
5894: {
5895: _loop253: do {
5896: if ((LA(1) == NOT_EQUAL || LA(1) == EQUAL)) {
5897: {
5898: switch (LA(1)) {
5899: case NOT_EQUAL: {
5900: AST tmp196_AST = null;
5901: tmp196_AST = astFactory.create(LT(1));
5902: astFactory.makeASTRoot(currentAST,
5903: tmp196_AST);
5904: match(NOT_EQUAL);
5905: break;
5906: }
5907: case EQUAL: {
5908: AST tmp197_AST = null;
5909: tmp197_AST = astFactory.create(LT(1));
5910: astFactory.makeASTRoot(currentAST,
5911: tmp197_AST);
5912: match(EQUAL);
5913: break;
5914: }
5915: default: {
5916: throw new NoViableAltException(LT(1),
5917: getFilename());
5918: }
5919: }
5920: }
5921: relationalExpression();
5922: astFactory.addASTChild(currentAST, returnAST);
5923: } else {
5924: break _loop253;
5925: }
5926:
5927: } while (true);
5928: }
5929: equalityExpression_AST = (AST) currentAST.root;
5930: returnAST = equalityExpression_AST;
5931: }
5932:
5933: public final void relationalExpression()
5934: throws RecognitionException, TokenStreamException {
5935:
5936: returnAST = null;
5937: ASTPair currentAST = new ASTPair();
5938: AST relationalExpression_AST = null;
5939:
5940: shiftExpression();
5941: astFactory.addASTChild(currentAST, returnAST);
5942: {
5943: switch (LA(1)) {
5944: case SEMI:
5945: case RBRACK:
5946: case QUESTION:
5947: case LT:
5948: case COMMA:
5949: case GT:
5950: case RPAREN:
5951: case ASSIGN:
5952: case RCURLY:
5953: case BAND:
5954: case COLON:
5955: case PLUS_ASSIGN:
5956: case MINUS_ASSIGN:
5957: case STAR_ASSIGN:
5958: case DIV_ASSIGN:
5959: case MOD_ASSIGN:
5960: case SR_ASSIGN:
5961: case BSR_ASSIGN:
5962: case SL_ASSIGN:
5963: case BAND_ASSIGN:
5964: case BXOR_ASSIGN:
5965: case BOR_ASSIGN:
5966: case LOR:
5967: case LAND:
5968: case BOR:
5969: case BXOR:
5970: case NOT_EQUAL:
5971: case EQUAL:
5972: case LE:
5973: case GE: {
5974: {
5975: _loop258: do {
5976: if ((_tokenSet_40.member(LA(1)))) {
5977: {
5978: switch (LA(1)) {
5979: case LT: {
5980: AST tmp198_AST = null;
5981: tmp198_AST = astFactory
5982: .create(LT(1));
5983: astFactory.makeASTRoot(currentAST,
5984: tmp198_AST);
5985: match(LT);
5986: break;
5987: }
5988: case GT: {
5989: AST tmp199_AST = null;
5990: tmp199_AST = astFactory
5991: .create(LT(1));
5992: astFactory.makeASTRoot(currentAST,
5993: tmp199_AST);
5994: match(GT);
5995: break;
5996: }
5997: case LE: {
5998: AST tmp200_AST = null;
5999: tmp200_AST = astFactory
6000: .create(LT(1));
6001: astFactory.makeASTRoot(currentAST,
6002: tmp200_AST);
6003: match(LE);
6004: break;
6005: }
6006: case GE: {
6007: AST tmp201_AST = null;
6008: tmp201_AST = astFactory
6009: .create(LT(1));
6010: astFactory.makeASTRoot(currentAST,
6011: tmp201_AST);
6012: match(GE);
6013: break;
6014: }
6015: default: {
6016: throw new NoViableAltException(
6017: LT(1), getFilename());
6018: }
6019: }
6020: }
6021: shiftExpression();
6022: astFactory.addASTChild(currentAST,
6023: returnAST);
6024: } else {
6025: break _loop258;
6026: }
6027:
6028: } while (true);
6029: }
6030: break;
6031: }
6032: case LITERAL_instanceof : {
6033: AST tmp202_AST = null;
6034: tmp202_AST = astFactory.create(LT(1));
6035: astFactory.makeASTRoot(currentAST, tmp202_AST);
6036: match(LITERAL_instanceof );
6037: typeSpec(true);
6038: astFactory.addASTChild(currentAST, returnAST);
6039: break;
6040: }
6041: default: {
6042: throw new NoViableAltException(LT(1), getFilename());
6043: }
6044: }
6045: }
6046: relationalExpression_AST = (AST) currentAST.root;
6047: returnAST = relationalExpression_AST;
6048: }
6049:
6050: public final void shiftExpression() throws RecognitionException,
6051: TokenStreamException {
6052:
6053: returnAST = null;
6054: ASTPair currentAST = new ASTPair();
6055: AST shiftExpression_AST = null;
6056:
6057: additiveExpression();
6058: astFactory.addASTChild(currentAST, returnAST);
6059: {
6060: _loop262: do {
6061: if ((_tokenSet_41.member(LA(1)))) {
6062: {
6063: switch (LA(1)) {
6064: case SL: {
6065: AST tmp203_AST = null;
6066: tmp203_AST = astFactory.create(LT(1));
6067: astFactory.makeASTRoot(currentAST,
6068: tmp203_AST);
6069: match(SL);
6070: break;
6071: }
6072: case SR: {
6073: AST tmp204_AST = null;
6074: tmp204_AST = astFactory.create(LT(1));
6075: astFactory.makeASTRoot(currentAST,
6076: tmp204_AST);
6077: match(SR);
6078: break;
6079: }
6080: case BSR: {
6081: AST tmp205_AST = null;
6082: tmp205_AST = astFactory.create(LT(1));
6083: astFactory.makeASTRoot(currentAST,
6084: tmp205_AST);
6085: match(BSR);
6086: break;
6087: }
6088: default: {
6089: throw new NoViableAltException(LT(1),
6090: getFilename());
6091: }
6092: }
6093: }
6094: additiveExpression();
6095: astFactory.addASTChild(currentAST, returnAST);
6096: } else {
6097: break _loop262;
6098: }
6099:
6100: } while (true);
6101: }
6102: shiftExpression_AST = (AST) currentAST.root;
6103: returnAST = shiftExpression_AST;
6104: }
6105:
6106: public final void additiveExpression() throws RecognitionException,
6107: TokenStreamException {
6108:
6109: returnAST = null;
6110: ASTPair currentAST = new ASTPair();
6111: AST additiveExpression_AST = null;
6112:
6113: multiplicativeExpression();
6114: astFactory.addASTChild(currentAST, returnAST);
6115: {
6116: _loop266: do {
6117: if ((LA(1) == PLUS || LA(1) == MINUS)) {
6118: {
6119: switch (LA(1)) {
6120: case PLUS: {
6121: AST tmp206_AST = null;
6122: tmp206_AST = astFactory.create(LT(1));
6123: astFactory.makeASTRoot(currentAST,
6124: tmp206_AST);
6125: match(PLUS);
6126: break;
6127: }
6128: case MINUS: {
6129: AST tmp207_AST = null;
6130: tmp207_AST = astFactory.create(LT(1));
6131: astFactory.makeASTRoot(currentAST,
6132: tmp207_AST);
6133: match(MINUS);
6134: break;
6135: }
6136: default: {
6137: throw new NoViableAltException(LT(1),
6138: getFilename());
6139: }
6140: }
6141: }
6142: multiplicativeExpression();
6143: astFactory.addASTChild(currentAST, returnAST);
6144: } else {
6145: break _loop266;
6146: }
6147:
6148: } while (true);
6149: }
6150: additiveExpression_AST = (AST) currentAST.root;
6151: returnAST = additiveExpression_AST;
6152: }
6153:
6154: public final void multiplicativeExpression()
6155: throws RecognitionException, TokenStreamException {
6156:
6157: returnAST = null;
6158: ASTPair currentAST = new ASTPair();
6159: AST multiplicativeExpression_AST = null;
6160:
6161: unaryExpression();
6162: astFactory.addASTChild(currentAST, returnAST);
6163: {
6164: _loop270: do {
6165: if ((_tokenSet_42.member(LA(1)))) {
6166: {
6167: switch (LA(1)) {
6168: case STAR: {
6169: AST tmp208_AST = null;
6170: tmp208_AST = astFactory.create(LT(1));
6171: astFactory.makeASTRoot(currentAST,
6172: tmp208_AST);
6173: match(STAR);
6174: break;
6175: }
6176: case DIV: {
6177: AST tmp209_AST = null;
6178: tmp209_AST = astFactory.create(LT(1));
6179: astFactory.makeASTRoot(currentAST,
6180: tmp209_AST);
6181: match(DIV);
6182: break;
6183: }
6184: case MOD: {
6185: AST tmp210_AST = null;
6186: tmp210_AST = astFactory.create(LT(1));
6187: astFactory.makeASTRoot(currentAST,
6188: tmp210_AST);
6189: match(MOD);
6190: break;
6191: }
6192: default: {
6193: throw new NoViableAltException(LT(1),
6194: getFilename());
6195: }
6196: }
6197: }
6198: unaryExpression();
6199: astFactory.addASTChild(currentAST, returnAST);
6200: } else {
6201: break _loop270;
6202: }
6203:
6204: } while (true);
6205: }
6206: multiplicativeExpression_AST = (AST) currentAST.root;
6207: returnAST = multiplicativeExpression_AST;
6208: }
6209:
6210: public final void unaryExpression() throws RecognitionException,
6211: TokenStreamException {
6212:
6213: returnAST = null;
6214: ASTPair currentAST = new ASTPair();
6215: AST unaryExpression_AST = null;
6216:
6217: switch (LA(1)) {
6218: case INC: {
6219: AST tmp211_AST = null;
6220: tmp211_AST = astFactory.create(LT(1));
6221: astFactory.makeASTRoot(currentAST, tmp211_AST);
6222: match(INC);
6223: unaryExpression();
6224: astFactory.addASTChild(currentAST, returnAST);
6225: unaryExpression_AST = (AST) currentAST.root;
6226: break;
6227: }
6228: case DEC: {
6229: AST tmp212_AST = null;
6230: tmp212_AST = astFactory.create(LT(1));
6231: astFactory.makeASTRoot(currentAST, tmp212_AST);
6232: match(DEC);
6233: unaryExpression();
6234: astFactory.addASTChild(currentAST, returnAST);
6235: unaryExpression_AST = (AST) currentAST.root;
6236: break;
6237: }
6238: case MINUS: {
6239: AST tmp213_AST = null;
6240: tmp213_AST = astFactory.create(LT(1));
6241: astFactory.makeASTRoot(currentAST, tmp213_AST);
6242: match(MINUS);
6243: if (inputState.guessing == 0) {
6244: tmp213_AST.setType(UNARY_MINUS);
6245: }
6246: unaryExpression();
6247: astFactory.addASTChild(currentAST, returnAST);
6248: unaryExpression_AST = (AST) currentAST.root;
6249: break;
6250: }
6251: case PLUS: {
6252: AST tmp214_AST = null;
6253: tmp214_AST = astFactory.create(LT(1));
6254: astFactory.makeASTRoot(currentAST, tmp214_AST);
6255: match(PLUS);
6256: if (inputState.guessing == 0) {
6257: tmp214_AST.setType(UNARY_PLUS);
6258: }
6259: unaryExpression();
6260: astFactory.addASTChild(currentAST, returnAST);
6261: unaryExpression_AST = (AST) currentAST.root;
6262: break;
6263: }
6264: case IDENT:
6265: case LITERAL_super :
6266: case LT:
6267: case LITERAL_void:
6268: case LITERAL_boolean:
6269: case LITERAL_byte:
6270: case LITERAL_char:
6271: case LITERAL_short:
6272: case LITERAL_int:
6273: case LITERAL_float:
6274: case LITERAL_long:
6275: case LITERAL_double:
6276: case LPAREN:
6277: case LITERAL_this :
6278: case BNOT:
6279: case LNOT:
6280: case LITERAL_true:
6281: case LITERAL_false:
6282: case LITERAL_null:
6283: case LITERAL_new:
6284: case NUM_INT:
6285: case STRING_LITERAL:
6286: case NUM_FLOAT:
6287: case NUM_LONG:
6288: case NUM_DOUBLE: {
6289: unaryExpressionNotPlusMinus();
6290: astFactory.addASTChild(currentAST, returnAST);
6291: unaryExpression_AST = (AST) currentAST.root;
6292: break;
6293: }
6294: default: {
6295: throw new NoViableAltException(LT(1), getFilename());
6296: }
6297: }
6298: returnAST = unaryExpression_AST;
6299: }
6300:
6301: public final void unaryExpressionNotPlusMinus()
6302: throws RecognitionException, TokenStreamException {
6303:
6304: returnAST = null;
6305: ASTPair currentAST = new ASTPair();
6306: AST unaryExpressionNotPlusMinus_AST = null;
6307: Token lpb = null;
6308: AST lpb_AST = null;
6309: Token lp = null;
6310: AST lp_AST = null;
6311:
6312: switch (LA(1)) {
6313: case BNOT: {
6314: AST tmp215_AST = null;
6315: tmp215_AST = astFactory.create(LT(1));
6316: astFactory.makeASTRoot(currentAST, tmp215_AST);
6317: match(BNOT);
6318: unaryExpression();
6319: astFactory.addASTChild(currentAST, returnAST);
6320: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
6321: break;
6322: }
6323: case LNOT: {
6324: AST tmp216_AST = null;
6325: tmp216_AST = astFactory.create(LT(1));
6326: astFactory.makeASTRoot(currentAST, tmp216_AST);
6327: match(LNOT);
6328: unaryExpression();
6329: astFactory.addASTChild(currentAST, returnAST);
6330: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
6331: break;
6332: }
6333: case IDENT:
6334: case LITERAL_super :
6335: case LT:
6336: case LITERAL_void:
6337: case LITERAL_boolean:
6338: case LITERAL_byte:
6339: case LITERAL_char:
6340: case LITERAL_short:
6341: case LITERAL_int:
6342: case LITERAL_float:
6343: case LITERAL_long:
6344: case LITERAL_double:
6345: case LPAREN:
6346: case LITERAL_this :
6347: case LITERAL_true:
6348: case LITERAL_false:
6349: case LITERAL_null:
6350: case LITERAL_new:
6351: case NUM_INT:
6352: case STRING_LITERAL:
6353: case NUM_FLOAT:
6354: case NUM_LONG:
6355: case NUM_DOUBLE: {
6356: {
6357: boolean synPredMatched275 = false;
6358: if (((LA(1) == LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double)))) {
6359: int _m275 = mark();
6360: synPredMatched275 = true;
6361: inputState.guessing++;
6362: try {
6363: {
6364: match(LPAREN);
6365: builtInTypeSpec(true);
6366: match(RPAREN);
6367: unaryExpression();
6368: }
6369: } catch (RecognitionException pe) {
6370: synPredMatched275 = false;
6371: }
6372: rewind(_m275);
6373: inputState.guessing--;
6374: }
6375: if (synPredMatched275) {
6376: lpb = LT(1);
6377: lpb_AST = astFactory.create(lpb);
6378: astFactory.makeASTRoot(currentAST, lpb_AST);
6379: match(LPAREN);
6380: if (inputState.guessing == 0) {
6381: lpb_AST.setType(TYPECAST);
6382: }
6383: builtInTypeSpec(true);
6384: astFactory.addASTChild(currentAST, returnAST);
6385: match(RPAREN);
6386: unaryExpression();
6387: astFactory.addASTChild(currentAST, returnAST);
6388: } else {
6389: boolean synPredMatched277 = false;
6390: if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
6391: int _m277 = mark();
6392: synPredMatched277 = true;
6393: inputState.guessing++;
6394: try {
6395: {
6396: match(LPAREN);
6397: classTypeSpec(true);
6398: match(RPAREN);
6399: unaryExpressionNotPlusMinus();
6400: }
6401: } catch (RecognitionException pe) {
6402: synPredMatched277 = false;
6403: }
6404: rewind(_m277);
6405: inputState.guessing--;
6406: }
6407: if (synPredMatched277) {
6408: lp = LT(1);
6409: lp_AST = astFactory.create(lp);
6410: astFactory.makeASTRoot(currentAST, lp_AST);
6411: match(LPAREN);
6412: if (inputState.guessing == 0) {
6413: lp_AST.setType(TYPECAST);
6414: }
6415: classTypeSpec(true);
6416: astFactory.addASTChild(currentAST, returnAST);
6417: match(RPAREN);
6418: unaryExpressionNotPlusMinus();
6419: astFactory.addASTChild(currentAST, returnAST);
6420: } else if ((_tokenSet_43.member(LA(1)))
6421: && (_tokenSet_44.member(LA(2)))) {
6422: postfixExpression();
6423: astFactory.addASTChild(currentAST, returnAST);
6424: } else {
6425: throw new NoViableAltException(LT(1),
6426: getFilename());
6427: }
6428: }
6429: }
6430: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
6431: break;
6432: }
6433: default: {
6434: throw new NoViableAltException(LT(1), getFilename());
6435: }
6436: }
6437: returnAST = unaryExpressionNotPlusMinus_AST;
6438: }
6439:
6440: public final void postfixExpression() throws RecognitionException,
6441: TokenStreamException {
6442:
6443: returnAST = null;
6444: ASTPair currentAST = new ASTPair();
6445: AST postfixExpression_AST = null;
6446: Token lp = null;
6447: AST lp_AST = null;
6448: Token lp3 = null;
6449: AST lp3_AST = null;
6450: Token lps = null;
6451: AST lps_AST = null;
6452: Token lb = null;
6453: AST lb_AST = null;
6454: Token in = null;
6455: AST in_AST = null;
6456: Token de = null;
6457: AST de_AST = null;
6458:
6459: primaryExpression();
6460: astFactory.addASTChild(currentAST, returnAST);
6461: {
6462: _loop286: do {
6463: if ((LA(1) == DOT) && (_tokenSet_45.member(LA(2)))) {
6464: AST tmp219_AST = null;
6465: tmp219_AST = astFactory.create(LT(1));
6466: astFactory.makeASTRoot(currentAST, tmp219_AST);
6467: match(DOT);
6468: {
6469: switch (LA(1)) {
6470: case LT: {
6471: typeArguments();
6472: astFactory.addASTChild(currentAST,
6473: returnAST);
6474: break;
6475: }
6476: case IDENT:
6477: case LITERAL_super : {
6478: break;
6479: }
6480: default: {
6481: throw new NoViableAltException(LT(1),
6482: getFilename());
6483: }
6484: }
6485: }
6486: {
6487: switch (LA(1)) {
6488: case IDENT: {
6489: AST tmp220_AST = null;
6490: tmp220_AST = astFactory.create(LT(1));
6491: astFactory.addASTChild(currentAST,
6492: tmp220_AST);
6493: match(IDENT);
6494: {
6495: switch (LA(1)) {
6496: case LPAREN: {
6497: lp = LT(1);
6498: lp_AST = astFactory.create(lp);
6499: astFactory.makeASTRoot(currentAST,
6500: lp_AST);
6501: match(LPAREN);
6502: if (inputState.guessing == 0) {
6503: lp_AST.setType(METHOD_CALL);
6504: }
6505: argList();
6506: astFactory.addASTChild(currentAST,
6507: returnAST);
6508: match(RPAREN);
6509: break;
6510: }
6511: case SEMI:
6512: case LBRACK:
6513: case RBRACK:
6514: case DOT:
6515: case QUESTION:
6516: case LT:
6517: case COMMA:
6518: case GT:
6519: case SR:
6520: case BSR:
6521: case STAR:
6522: case RPAREN:
6523: case ASSIGN:
6524: case RCURLY:
6525: case BAND:
6526: case COLON:
6527: case PLUS_ASSIGN:
6528: case MINUS_ASSIGN:
6529: case STAR_ASSIGN:
6530: case DIV_ASSIGN:
6531: case MOD_ASSIGN:
6532: case SR_ASSIGN:
6533: case BSR_ASSIGN:
6534: case SL_ASSIGN:
6535: case BAND_ASSIGN:
6536: case BXOR_ASSIGN:
6537: case BOR_ASSIGN:
6538: case LOR:
6539: case LAND:
6540: case BOR:
6541: case BXOR:
6542: case NOT_EQUAL:
6543: case EQUAL:
6544: case LE:
6545: case GE:
6546: case LITERAL_instanceof :
6547: case SL:
6548: case PLUS:
6549: case MINUS:
6550: case DIV:
6551: case MOD:
6552: case INC:
6553: case DEC: {
6554: break;
6555: }
6556: default: {
6557: throw new NoViableAltException(
6558: LT(1), getFilename());
6559: }
6560: }
6561: }
6562: break;
6563: }
6564: case LITERAL_super : {
6565: AST tmp222_AST = null;
6566: tmp222_AST = astFactory.create(LT(1));
6567: astFactory.addASTChild(currentAST,
6568: tmp222_AST);
6569: match(LITERAL_super );
6570: {
6571: switch (LA(1)) {
6572: case LPAREN: {
6573: lp3 = LT(1);
6574: lp3_AST = astFactory.create(lp3);
6575: astFactory.makeASTRoot(currentAST,
6576: lp3_AST);
6577: match(LPAREN);
6578: argList();
6579: astFactory.addASTChild(currentAST,
6580: returnAST);
6581: match(RPAREN);
6582: if (inputState.guessing == 0) {
6583: lp3_AST
6584: .setType(SUPER_CTOR_CALL);
6585: }
6586: break;
6587: }
6588: case DOT: {
6589: AST tmp224_AST = null;
6590: tmp224_AST = astFactory
6591: .create(LT(1));
6592: astFactory.makeASTRoot(currentAST,
6593: tmp224_AST);
6594: match(DOT);
6595: {
6596: switch (LA(1)) {
6597: case LT: {
6598: typeArguments();
6599: astFactory.addASTChild(
6600: currentAST,
6601: returnAST);
6602: break;
6603: }
6604: case IDENT: {
6605: break;
6606: }
6607: default: {
6608: throw new NoViableAltException(
6609: LT(1),
6610: getFilename());
6611: }
6612: }
6613: }
6614: AST tmp225_AST = null;
6615: tmp225_AST = astFactory
6616: .create(LT(1));
6617: astFactory.addASTChild(currentAST,
6618: tmp225_AST);
6619: match(IDENT);
6620: {
6621: switch (LA(1)) {
6622: case LPAREN: {
6623: lps = LT(1);
6624: lps_AST = astFactory
6625: .create(lps);
6626: astFactory
6627: .makeASTRoot(
6628: currentAST,
6629: lps_AST);
6630: match(LPAREN);
6631: if (inputState.guessing == 0) {
6632: lps_AST
6633: .setType(METHOD_CALL);
6634: }
6635: argList();
6636: astFactory.addASTChild(
6637: currentAST,
6638: returnAST);
6639: match(RPAREN);
6640: break;
6641: }
6642: case SEMI:
6643: case LBRACK:
6644: case RBRACK:
6645: case DOT:
6646: case QUESTION:
6647: case LT:
6648: case COMMA:
6649: case GT:
6650: case SR:
6651: case BSR:
6652: case STAR:
6653: case RPAREN:
6654: case ASSIGN:
6655: case RCURLY:
6656: case BAND:
6657: case COLON:
6658: case PLUS_ASSIGN:
6659: case MINUS_ASSIGN:
6660: case STAR_ASSIGN:
6661: case DIV_ASSIGN:
6662: case MOD_ASSIGN:
6663: case SR_ASSIGN:
6664: case BSR_ASSIGN:
6665: case SL_ASSIGN:
6666: case BAND_ASSIGN:
6667: case BXOR_ASSIGN:
6668: case BOR_ASSIGN:
6669: case LOR:
6670: case LAND:
6671: case BOR:
6672: case BXOR:
6673: case NOT_EQUAL:
6674: case EQUAL:
6675: case LE:
6676: case GE:
6677: case LITERAL_instanceof :
6678: case SL:
6679: case PLUS:
6680: case MINUS:
6681: case DIV:
6682: case MOD:
6683: case INC:
6684: case DEC: {
6685: break;
6686: }
6687: default: {
6688: throw new NoViableAltException(
6689: LT(1),
6690: getFilename());
6691: }
6692: }
6693: }
6694: break;
6695: }
6696: default: {
6697: throw new NoViableAltException(
6698: LT(1), getFilename());
6699: }
6700: }
6701: }
6702: break;
6703: }
6704: default: {
6705: throw new NoViableAltException(LT(1),
6706: getFilename());
6707: }
6708: }
6709: }
6710: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_this )) {
6711: AST tmp227_AST = null;
6712: tmp227_AST = astFactory.create(LT(1));
6713: astFactory.makeASTRoot(currentAST, tmp227_AST);
6714: match(DOT);
6715: AST tmp228_AST = null;
6716: tmp228_AST = astFactory.create(LT(1));
6717: astFactory.addASTChild(currentAST, tmp228_AST);
6718: match(LITERAL_this );
6719: } else if ((LA(1) == DOT) && (LA(2) == LITERAL_new)) {
6720: AST tmp229_AST = null;
6721: tmp229_AST = astFactory.create(LT(1));
6722: astFactory.makeASTRoot(currentAST, tmp229_AST);
6723: match(DOT);
6724: newExpression();
6725: astFactory.addASTChild(currentAST, returnAST);
6726: } else if ((LA(1) == LBRACK)) {
6727: lb = LT(1);
6728: lb_AST = astFactory.create(lb);
6729: astFactory.makeASTRoot(currentAST, lb_AST);
6730: match(LBRACK);
6731: if (inputState.guessing == 0) {
6732: lb_AST.setType(INDEX_OP);
6733: }
6734: expression();
6735: astFactory.addASTChild(currentAST, returnAST);
6736: match(RBRACK);
6737: } else {
6738: break _loop286;
6739: }
6740:
6741: } while (true);
6742: }
6743: {
6744: switch (LA(1)) {
6745: case INC: {
6746: in = LT(1);
6747: in_AST = astFactory.create(in);
6748: astFactory.makeASTRoot(currentAST, in_AST);
6749: match(INC);
6750: if (inputState.guessing == 0) {
6751: in_AST.setType(POST_INC);
6752: }
6753: break;
6754: }
6755: case DEC: {
6756: de = LT(1);
6757: de_AST = astFactory.create(de);
6758: astFactory.makeASTRoot(currentAST, de_AST);
6759: match(DEC);
6760: if (inputState.guessing == 0) {
6761: de_AST.setType(POST_DEC);
6762: }
6763: break;
6764: }
6765: case SEMI:
6766: case RBRACK:
6767: case QUESTION:
6768: case LT:
6769: case COMMA:
6770: case GT:
6771: case SR:
6772: case BSR:
6773: case STAR:
6774: case RPAREN:
6775: case ASSIGN:
6776: case RCURLY:
6777: case BAND:
6778: case COLON:
6779: case PLUS_ASSIGN:
6780: case MINUS_ASSIGN:
6781: case STAR_ASSIGN:
6782: case DIV_ASSIGN:
6783: case MOD_ASSIGN:
6784: case SR_ASSIGN:
6785: case BSR_ASSIGN:
6786: case SL_ASSIGN:
6787: case BAND_ASSIGN:
6788: case BXOR_ASSIGN:
6789: case BOR_ASSIGN:
6790: case LOR:
6791: case LAND:
6792: case BOR:
6793: case BXOR:
6794: case NOT_EQUAL:
6795: case EQUAL:
6796: case LE:
6797: case GE:
6798: case LITERAL_instanceof :
6799: case SL:
6800: case PLUS:
6801: case MINUS:
6802: case DIV:
6803: case MOD: {
6804: break;
6805: }
6806: default: {
6807: throw new NoViableAltException(LT(1), getFilename());
6808: }
6809: }
6810: }
6811: postfixExpression_AST = (AST) currentAST.root;
6812: returnAST = postfixExpression_AST;
6813: }
6814:
6815: public final void primaryExpression() throws RecognitionException,
6816: TokenStreamException {
6817:
6818: returnAST = null;
6819: ASTPair currentAST = new ASTPair();
6820: AST primaryExpression_AST = null;
6821: Token lbt = null;
6822: AST lbt_AST = null;
6823:
6824: switch (LA(1)) {
6825: case IDENT:
6826: case LT: {
6827: identPrimary();
6828: astFactory.addASTChild(currentAST, returnAST);
6829: {
6830: if ((LA(1) == DOT) && (LA(2) == LITERAL_class)) {
6831: AST tmp231_AST = null;
6832: tmp231_AST = astFactory.create(LT(1));
6833: astFactory.makeASTRoot(currentAST, tmp231_AST);
6834: match(DOT);
6835: AST tmp232_AST = null;
6836: tmp232_AST = astFactory.create(LT(1));
6837: astFactory.addASTChild(currentAST, tmp232_AST);
6838: match(LITERAL_class);
6839: } else if ((_tokenSet_46.member(LA(1)))
6840: && (_tokenSet_47.member(LA(2)))) {
6841: } else {
6842: throw new NoViableAltException(LT(1), getFilename());
6843: }
6844:
6845: }
6846: primaryExpression_AST = (AST) currentAST.root;
6847: break;
6848: }
6849: case NUM_INT:
6850: case STRING_LITERAL:
6851: case NUM_FLOAT:
6852: case NUM_LONG:
6853: case NUM_DOUBLE: {
6854: constant();
6855: astFactory.addASTChild(currentAST, returnAST);
6856: primaryExpression_AST = (AST) currentAST.root;
6857: break;
6858: }
6859: case LITERAL_true: {
6860: AST tmp233_AST = null;
6861: tmp233_AST = astFactory.create(LT(1));
6862: astFactory.addASTChild(currentAST, tmp233_AST);
6863: match(LITERAL_true);
6864: primaryExpression_AST = (AST) currentAST.root;
6865: break;
6866: }
6867: case LITERAL_false: {
6868: AST tmp234_AST = null;
6869: tmp234_AST = astFactory.create(LT(1));
6870: astFactory.addASTChild(currentAST, tmp234_AST);
6871: match(LITERAL_false);
6872: primaryExpression_AST = (AST) currentAST.root;
6873: break;
6874: }
6875: case LITERAL_null: {
6876: AST tmp235_AST = null;
6877: tmp235_AST = astFactory.create(LT(1));
6878: astFactory.addASTChild(currentAST, tmp235_AST);
6879: match(LITERAL_null);
6880: primaryExpression_AST = (AST) currentAST.root;
6881: break;
6882: }
6883: case LITERAL_new: {
6884: newExpression();
6885: astFactory.addASTChild(currentAST, returnAST);
6886: primaryExpression_AST = (AST) currentAST.root;
6887: break;
6888: }
6889: case LITERAL_this : {
6890: AST tmp236_AST = null;
6891: tmp236_AST = astFactory.create(LT(1));
6892: astFactory.addASTChild(currentAST, tmp236_AST);
6893: match(LITERAL_this );
6894: primaryExpression_AST = (AST) currentAST.root;
6895: break;
6896: }
6897: case LITERAL_super : {
6898: AST tmp237_AST = null;
6899: tmp237_AST = astFactory.create(LT(1));
6900: astFactory.addASTChild(currentAST, tmp237_AST);
6901: match(LITERAL_super );
6902: primaryExpression_AST = (AST) currentAST.root;
6903: break;
6904: }
6905: case LPAREN: {
6906: match(LPAREN);
6907: assignmentExpression();
6908: astFactory.addASTChild(currentAST, returnAST);
6909: match(RPAREN);
6910: primaryExpression_AST = (AST) currentAST.root;
6911: break;
6912: }
6913: case LITERAL_void:
6914: case LITERAL_boolean:
6915: case LITERAL_byte:
6916: case LITERAL_char:
6917: case LITERAL_short:
6918: case LITERAL_int:
6919: case LITERAL_float:
6920: case LITERAL_long:
6921: case LITERAL_double: {
6922: builtInType();
6923: astFactory.addASTChild(currentAST, returnAST);
6924: {
6925: _loop291: do {
6926: if ((LA(1) == LBRACK)) {
6927: lbt = LT(1);
6928: lbt_AST = astFactory.create(lbt);
6929: astFactory.makeASTRoot(currentAST, lbt_AST);
6930: match(LBRACK);
6931: if (inputState.guessing == 0) {
6932: lbt_AST.setType(ARRAY_DECLARATOR);
6933: }
6934: match(RBRACK);
6935: } else {
6936: break _loop291;
6937: }
6938:
6939: } while (true);
6940: }
6941: AST tmp241_AST = null;
6942: tmp241_AST = astFactory.create(LT(1));
6943: astFactory.makeASTRoot(currentAST, tmp241_AST);
6944: match(DOT);
6945: AST tmp242_AST = null;
6946: tmp242_AST = astFactory.create(LT(1));
6947: astFactory.addASTChild(currentAST, tmp242_AST);
6948: match(LITERAL_class);
6949: primaryExpression_AST = (AST) currentAST.root;
6950: break;
6951: }
6952: default: {
6953: throw new NoViableAltException(LT(1), getFilename());
6954: }
6955: }
6956: returnAST = primaryExpression_AST;
6957: }
6958:
6959: /** object instantiation.
6960: * Trees are built as illustrated by the following input/tree pairs:
6961: *
6962: * new T()
6963: *
6964: * new
6965: * |
6966: * T -- ELIST
6967: * |
6968: * arg1 -- arg2 -- .. -- argn
6969: *
6970: * new int[]
6971: *
6972: * new
6973: * |
6974: * int -- ARRAY_DECLARATOR
6975: *
6976: * new int[] {1,2}
6977: *
6978: * new
6979: * |
6980: * int -- ARRAY_DECLARATOR -- ARRAY_INIT
6981: * |
6982: * EXPR -- EXPR
6983: * | |
6984: * 1 2
6985: *
6986: * new int[3]
6987: * new
6988: * |
6989: * int -- ARRAY_DECLARATOR
6990: * |
6991: * EXPR
6992: * |
6993: * 3
6994: *
6995: * new int[1][2]
6996: *
6997: * new
6998: * |
6999: * int -- ARRAY_DECLARATOR
7000: * |
7001: * ARRAY_DECLARATOR -- EXPR
7002: * | |
7003: * EXPR 1
7004: * |
7005: * 2
7006: *
7007: */
7008: public final void newExpression() throws RecognitionException,
7009: TokenStreamException {
7010:
7011: returnAST = null;
7012: ASTPair currentAST = new ASTPair();
7013: AST newExpression_AST = null;
7014:
7015: AST tmp243_AST = null;
7016: tmp243_AST = astFactory.create(LT(1));
7017: astFactory.makeASTRoot(currentAST, tmp243_AST);
7018: match(LITERAL_new);
7019: {
7020: switch (LA(1)) {
7021: case LT: {
7022: typeArguments();
7023: astFactory.addASTChild(currentAST, returnAST);
7024: break;
7025: }
7026: case IDENT:
7027: case LITERAL_void:
7028: case LITERAL_boolean:
7029: case LITERAL_byte:
7030: case LITERAL_char:
7031: case LITERAL_short:
7032: case LITERAL_int:
7033: case LITERAL_float:
7034: case LITERAL_long:
7035: case LITERAL_double: {
7036: break;
7037: }
7038: default: {
7039: throw new NoViableAltException(LT(1), getFilename());
7040: }
7041: }
7042: }
7043: type();
7044: astFactory.addASTChild(currentAST, returnAST);
7045: {
7046: switch (LA(1)) {
7047: case LPAREN: {
7048: match(LPAREN);
7049: argList();
7050: astFactory.addASTChild(currentAST, returnAST);
7051: match(RPAREN);
7052: {
7053: switch (LA(1)) {
7054: case LCURLY: {
7055: classBlock();
7056: astFactory.addASTChild(currentAST, returnAST);
7057: break;
7058: }
7059: case SEMI:
7060: case LBRACK:
7061: case RBRACK:
7062: case DOT:
7063: case QUESTION:
7064: case LT:
7065: case COMMA:
7066: case GT:
7067: case SR:
7068: case BSR:
7069: case STAR:
7070: case RPAREN:
7071: case ASSIGN:
7072: case RCURLY:
7073: case BAND:
7074: case COLON:
7075: case PLUS_ASSIGN:
7076: case MINUS_ASSIGN:
7077: case STAR_ASSIGN:
7078: case DIV_ASSIGN:
7079: case MOD_ASSIGN:
7080: case SR_ASSIGN:
7081: case BSR_ASSIGN:
7082: case SL_ASSIGN:
7083: case BAND_ASSIGN:
7084: case BXOR_ASSIGN:
7085: case BOR_ASSIGN:
7086: case LOR:
7087: case LAND:
7088: case BOR:
7089: case BXOR:
7090: case NOT_EQUAL:
7091: case EQUAL:
7092: case LE:
7093: case GE:
7094: case LITERAL_instanceof :
7095: case SL:
7096: case PLUS:
7097: case MINUS:
7098: case DIV:
7099: case MOD:
7100: case INC:
7101: case DEC: {
7102: break;
7103: }
7104: default: {
7105: throw new NoViableAltException(LT(1),
7106: getFilename());
7107: }
7108: }
7109: }
7110: break;
7111: }
7112: case LBRACK: {
7113: newArrayDeclarator();
7114: astFactory.addASTChild(currentAST, returnAST);
7115: break;
7116: }
7117: default: {
7118: throw new NoViableAltException(LT(1), getFilename());
7119: }
7120: }
7121: }
7122: newExpression_AST = (AST) currentAST.root;
7123: returnAST = newExpression_AST;
7124: }
7125:
7126: /** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
7127: * and a.b.c.class refs. Also this(...) and super(...). Match
7128: * this or super.
7129: */
7130: public final void identPrimary() throws RecognitionException,
7131: TokenStreamException {
7132:
7133: returnAST = null;
7134: ASTPair currentAST = new ASTPair();
7135: AST identPrimary_AST = null;
7136: AST ta1_AST = null;
7137: AST ta2_AST = null;
7138: Token lp = null;
7139: AST lp_AST = null;
7140: Token lbc = null;
7141: AST lbc_AST = null;
7142:
7143: {
7144: switch (LA(1)) {
7145: case LT: {
7146: typeArguments();
7147: ta1_AST = (AST) returnAST;
7148: break;
7149: }
7150: case IDENT: {
7151: break;
7152: }
7153: default: {
7154: throw new NoViableAltException(LT(1), getFilename());
7155: }
7156: }
7157: }
7158: AST tmp246_AST = null;
7159: tmp246_AST = astFactory.create(LT(1));
7160: astFactory.addASTChild(currentAST, tmp246_AST);
7161: match(IDENT);
7162: {
7163: _loop299: do {
7164: boolean synPredMatched297 = false;
7165: if (((LA(1) == DOT) && (LA(2) == IDENT || LA(2) == LT))) {
7166: int _m297 = mark();
7167: synPredMatched297 = true;
7168: inputState.guessing++;
7169: try {
7170: {
7171: match(DOT);
7172: {
7173: switch (LA(1)) {
7174: case LT: {
7175: typeArguments();
7176: break;
7177: }
7178: case IDENT: {
7179: break;
7180: }
7181: default: {
7182: throw new NoViableAltException(
7183: LT(1), getFilename());
7184: }
7185: }
7186: }
7187: match(IDENT);
7188: }
7189: } catch (RecognitionException pe) {
7190: synPredMatched297 = false;
7191: }
7192: rewind(_m297);
7193: inputState.guessing--;
7194: }
7195: if (synPredMatched297) {
7196: AST tmp247_AST = null;
7197: tmp247_AST = astFactory.create(LT(1));
7198: astFactory.makeASTRoot(currentAST, tmp247_AST);
7199: match(DOT);
7200: {
7201: switch (LA(1)) {
7202: case LT: {
7203: typeArguments();
7204: ta2_AST = (AST) returnAST;
7205: break;
7206: }
7207: case IDENT: {
7208: break;
7209: }
7210: default: {
7211: throw new NoViableAltException(LT(1),
7212: getFilename());
7213: }
7214: }
7215: }
7216: AST tmp248_AST = null;
7217: tmp248_AST = astFactory.create(LT(1));
7218: astFactory.addASTChild(currentAST, tmp248_AST);
7219: match(IDENT);
7220: } else if (((_tokenSet_48.member(LA(1))) && (_tokenSet_47
7221: .member(LA(2)))) && (false)) {
7222: } else {
7223: break _loop299;
7224: }
7225:
7226: } while (true);
7227: }
7228: {
7229: if ((LA(1) == LPAREN)) {
7230: {
7231: lp = LT(1);
7232: lp_AST = astFactory.create(lp);
7233: astFactory.makeASTRoot(currentAST, lp_AST);
7234: match(LPAREN);
7235: if (inputState.guessing == 0) {
7236: lp_AST.setType(METHOD_CALL);
7237: }
7238: if (inputState.guessing == 0) {
7239: if (ta2_AST != null)
7240: astFactory.addASTChild(currentAST, ta2_AST);
7241: }
7242: if (inputState.guessing == 0) {
7243: if (ta2_AST == null)
7244: astFactory.addASTChild(currentAST, ta1_AST);
7245: }
7246: argList();
7247: astFactory.addASTChild(currentAST, returnAST);
7248: match(RPAREN);
7249: }
7250: } else if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
7251: {
7252: int _cnt303 = 0;
7253: _loop303: do {
7254: if ((LA(1) == LBRACK) && (LA(2) == RBRACK)) {
7255: lbc = LT(1);
7256: lbc_AST = astFactory.create(lbc);
7257: astFactory.makeASTRoot(currentAST, lbc_AST);
7258: match(LBRACK);
7259: if (inputState.guessing == 0) {
7260: lbc_AST.setType(ARRAY_DECLARATOR);
7261: }
7262: match(RBRACK);
7263: } else {
7264: if (_cnt303 >= 1) {
7265: break _loop303;
7266: } else {
7267: throw new NoViableAltException(LT(1),
7268: getFilename());
7269: }
7270: }
7271:
7272: _cnt303++;
7273: } while (true);
7274: }
7275: } else if ((_tokenSet_46.member(LA(1)))
7276: && (_tokenSet_47.member(LA(2)))) {
7277: } else {
7278: throw new NoViableAltException(LT(1), getFilename());
7279: }
7280:
7281: }
7282: identPrimary_AST = (AST) currentAST.root;
7283: returnAST = identPrimary_AST;
7284: }
7285:
7286: public final void constant() throws RecognitionException,
7287: TokenStreamException {
7288:
7289: returnAST = null;
7290: ASTPair currentAST = new ASTPair();
7291: AST constant_AST = null;
7292:
7293: switch (LA(1)) {
7294: case NUM_INT: {
7295: AST tmp251_AST = null;
7296: tmp251_AST = astFactory.create(LT(1));
7297: astFactory.addASTChild(currentAST, tmp251_AST);
7298: match(NUM_INT);
7299: constant_AST = (AST) currentAST.root;
7300: break;
7301: }
7302: case STRING_LITERAL: {
7303: AST tmp252_AST = null;
7304: tmp252_AST = astFactory.create(LT(1));
7305: astFactory.addASTChild(currentAST, tmp252_AST);
7306: match(STRING_LITERAL);
7307: constant_AST = (AST) currentAST.root;
7308: break;
7309: }
7310: case NUM_FLOAT: {
7311: AST tmp253_AST = null;
7312: tmp253_AST = astFactory.create(LT(1));
7313: astFactory.addASTChild(currentAST, tmp253_AST);
7314: match(NUM_FLOAT);
7315: constant_AST = (AST) currentAST.root;
7316: break;
7317: }
7318: case NUM_LONG: {
7319: AST tmp254_AST = null;
7320: tmp254_AST = astFactory.create(LT(1));
7321: astFactory.addASTChild(currentAST, tmp254_AST);
7322: match(NUM_LONG);
7323: constant_AST = (AST) currentAST.root;
7324: break;
7325: }
7326: case NUM_DOUBLE: {
7327: AST tmp255_AST = null;
7328: tmp255_AST = astFactory.create(LT(1));
7329: astFactory.addASTChild(currentAST, tmp255_AST);
7330: match(NUM_DOUBLE);
7331: constant_AST = (AST) currentAST.root;
7332: break;
7333: }
7334: default: {
7335: throw new NoViableAltException(LT(1), getFilename());
7336: }
7337: }
7338: returnAST = constant_AST;
7339: }
7340:
7341: public final void newArrayDeclarator() throws RecognitionException,
7342: TokenStreamException {
7343:
7344: returnAST = null;
7345: ASTPair currentAST = new ASTPair();
7346: AST newArrayDeclarator_AST = null;
7347: Token lb = null;
7348: AST lb_AST = null;
7349:
7350: {
7351: int _cnt313 = 0;
7352: _loop313: do {
7353: if ((LA(1) == LBRACK) && (_tokenSet_49.member(LA(2)))) {
7354: lb = LT(1);
7355: lb_AST = astFactory.create(lb);
7356: astFactory.makeASTRoot(currentAST, lb_AST);
7357: match(LBRACK);
7358: if (inputState.guessing == 0) {
7359: lb_AST.setType(ARRAY_DECLARATOR);
7360: }
7361: {
7362: switch (LA(1)) {
7363: case IDENT:
7364: case LITERAL_super :
7365: case LT:
7366: case LITERAL_void:
7367: case LITERAL_boolean:
7368: case LITERAL_byte:
7369: case LITERAL_char:
7370: case LITERAL_short:
7371: case LITERAL_int:
7372: case LITERAL_float:
7373: case LITERAL_long:
7374: case LITERAL_double:
7375: case LPAREN:
7376: case LITERAL_this :
7377: case PLUS:
7378: case MINUS:
7379: case INC:
7380: case DEC:
7381: case BNOT:
7382: case LNOT:
7383: case LITERAL_true:
7384: case LITERAL_false:
7385: case LITERAL_null:
7386: case LITERAL_new:
7387: case NUM_INT:
7388: case STRING_LITERAL:
7389: case NUM_FLOAT:
7390: case NUM_LONG:
7391: case NUM_DOUBLE: {
7392: expression();
7393: astFactory.addASTChild(currentAST,
7394: returnAST);
7395: break;
7396: }
7397: case RBRACK: {
7398: break;
7399: }
7400: default: {
7401: throw new NoViableAltException(LT(1),
7402: getFilename());
7403: }
7404: }
7405: }
7406: match(RBRACK);
7407: } else {
7408: if (_cnt313 >= 1) {
7409: break _loop313;
7410: } else {
7411: throw new NoViableAltException(LT(1),
7412: getFilename());
7413: }
7414: }
7415:
7416: _cnt313++;
7417: } while (true);
7418: }
7419: newArrayDeclarator_AST = (AST) currentAST.root;
7420: returnAST = newArrayDeclarator_AST;
7421: }
7422:
7423: public static final String[] _tokenNames = { "<0>", "EOF", "<2>",
7424: "NULL_TREE_LOOKAHEAD", "BLOCK", "MODIFIERS", "OBJBLOCK",
7425: "SLIST", "METHOD_DEF", "VARIABLE_DEF", "INSTANCE_INIT",
7426: "STATIC_INIT", "TYPE", "CLASS_DEF", "INTERFACE_DEF",
7427: "PACKAGE_DEF", "ARRAY_DECLARATOR", "EXTENDS_CLAUSE",
7428: "IMPLEMENTS_CLAUSE", "PARAMETERS", "PARAMETER_DEF",
7429: "LABELED_STAT", "TYPECAST", "INDEX_OP", "POST_INC",
7430: "POST_DEC", "METHOD_CALL", "EXPR", "ARRAY_INIT", "IMPORT",
7431: "UNARY_MINUS", "UNARY_PLUS", "CASE_GROUP", "ELIST",
7432: "FOR_INIT", "FOR_CONDITION", "FOR_ITERATOR", "EMPTY_STAT",
7433: "\"final\"", "\"abstract\"", "\"strictfp\"",
7434: "SUPER_CTOR_CALL", "CTOR_CALL", "VARIABLE_PARAMETER_DEF",
7435: "STATIC_IMPORT", "ENUM_DEF", "ENUM_CONSTANT_DEF",
7436: "FOR_EACH_CLAUSE", "ANNOTATION_DEF", "ANNOTATIONS",
7437: "ANNOTATION", "ANNOTATION_MEMBER_VALUE_PAIR",
7438: "ANNOTATION_FIELD_DEF", "ANNOTATION_ARRAY_INIT",
7439: "TYPE_ARGUMENTS", "TYPE_ARGUMENT", "TYPE_PARAMETERS",
7440: "TYPE_PARAMETER", "WILDCARD_TYPE", "TYPE_UPPER_BOUNDS",
7441: "TYPE_LOWER_BOUNDS", "\"package\"", "SEMI", "\"import\"",
7442: "\"static\"", "LBRACK", "RBRACK", "IDENT", "DOT",
7443: "QUESTION", "\"extends\"", "\"super\"", "LT", "COMMA",
7444: "GT", "SR", "BSR", "\"void\"", "\"boolean\"", "\"byte\"",
7445: "\"char\"", "\"short\"", "\"int\"", "\"float\"",
7446: "\"long\"", "\"double\"", "STAR", "\"private\"",
7447: "\"public\"", "\"protected\"", "\"transient\"",
7448: "\"native\"", "\"threadsafe\"", "\"synchronized\"",
7449: "\"volatile\"", "AT", "LPAREN", "RPAREN", "ASSIGN",
7450: "LCURLY", "RCURLY", "\"class\"", "\"interface\"",
7451: "\"enum\"", "BAND", "\"default\"", "\"implements\"",
7452: "\"this\"", "\"throws\"", "TRIPLE_DOT", "COLON", "\"if\"",
7453: "\"else\"", "\"while\"", "\"break\"", "\"continue\"",
7454: "\"return\"", "\"switch\"", "\"throw\"", "\"assert\"",
7455: "\"for\"", "\"case\"", "\"try\"", "\"finally\"",
7456: "\"catch\"", "PLUS_ASSIGN", "MINUS_ASSIGN", "STAR_ASSIGN",
7457: "DIV_ASSIGN", "MOD_ASSIGN", "SR_ASSIGN", "BSR_ASSIGN",
7458: "SL_ASSIGN", "BAND_ASSIGN", "BXOR_ASSIGN", "BOR_ASSIGN",
7459: "LOR", "LAND", "BOR", "BXOR", "NOT_EQUAL", "EQUAL", "LE",
7460: "GE", "\"instanceof\"", "SL", "PLUS", "MINUS", "DIV",
7461: "MOD", "INC", "DEC", "BNOT", "LNOT", "\"true\"",
7462: "\"false\"", "\"null\"", "\"new\"", "NUM_INT",
7463: "STRING_LITERAL", "NUM_FLOAT", "NUM_LONG", "NUM_DOUBLE",
7464: "WS", "SL_COMMENT", "ML_COMMENT", "ESC", "HEX_DIGIT",
7465: "VOCAB", "EXPONENT", "FLOAT_SUFFIX" };
7466:
7467: protected void buildTokenTypeASTClassMap() {
7468: tokenTypeToASTClassMap = null;
7469: };
7470:
7471: private static final long[] mk_tokenSet_0() {
7472: long[] data = { -4611684094282039294L, 966359252993L, 0L, 0L };
7473: return data;
7474: }
7475:
7476: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
7477:
7478: private static final long[] mk_tokenSet_1() {
7479: long[] data = { 4611687942572736514L, 966359253001L, 0L, 0L };
7480: return data;
7481: }
7482:
7483: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
7484:
7485: private static final long[] mk_tokenSet_2() {
7486: long[] data = { 4611687942572736512L, 966359252993L, 0L, 0L };
7487: return data;
7488: }
7489:
7490: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
7491:
7492: private static final long[] mk_tokenSet_3() {
7493: long[] data = { 4611687942572736514L, 966359252993L, 0L, 0L };
7494: return data;
7495: }
7496:
7497: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
7498:
7499: private static final long[] mk_tokenSet_4() {
7500: long[] data = { 1924145348608L, 2139095041L, 0L, 0L };
7501: return data;
7502: }
7503:
7504: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
7505:
7506: private static final long[] mk_tokenSet_5() {
7507: long[] data = { 0L, 4186152L, 0L, 0L };
7508: return data;
7509: }
7510:
7511: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
7512:
7513: private static final long[] mk_tokenSet_6() {
7514: long[] data = { 4611686018427387904L, -2305723029298086146L,
7515: 16383L, 0L, 0L, 0L };
7516: return data;
7517: }
7518:
7519: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
7520:
7521: private static final long[] mk_tokenSet_7() {
7522: long[] data = { 6917530951786430464L, -1729399849096314881L,
7523: 34359738367L, 0L, 0L, 0L };
7524: return data;
7525: }
7526:
7527: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
7528:
7529: private static final long[] mk_tokenSet_8() {
7530: long[] data = { 0L, 14332310060762L, 0L, 0L };
7531: return data;
7532: }
7533:
7534: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
7535:
7536: private static final long[] mk_tokenSet_9() {
7537: long[] data = { 4611687942572736512L, -2305722062934638593L,
7538: 34359738367L, 0L, 0L, 0L };
7539: return data;
7540: }
7541:
7542: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
7543:
7544: private static final long[] mk_tokenSet_10() {
7545: long[] data = { 0L, 8836899398024L, 34356330496L, 0L, 0L, 0L };
7546: return data;
7547: }
7548:
7549: public static final BitSet _tokenSet_10 = new BitSet(
7550: mk_tokenSet_10());
7551:
7552: private static final long[] mk_tokenSet_11() {
7553: long[] data = { 0L, 9979364900282L, 34359738112L, 0L, 0L, 0L };
7554: return data;
7555: }
7556:
7557: public static final BitSet _tokenSet_11 = new BitSet(
7558: mk_tokenSet_11());
7559:
7560: private static final long[] mk_tokenSet_12() {
7561: long[] data = { 0L, 8802539659656L, 34356330496L, 0L, 0L, 0L };
7562: return data;
7563: }
7564:
7565: public static final BitSet _tokenSet_12 = new BitSet(
7566: mk_tokenSet_12());
7567:
7568: private static final long[] mk_tokenSet_13() {
7569: long[] data = { 0L, 4432410443336L, 0L, 0L };
7570: return data;
7571: }
7572:
7573: public static final BitSet _tokenSet_13 = new BitSet(
7574: mk_tokenSet_13());
7575:
7576: private static final long[] mk_tokenSet_14() {
7577: long[] data = { 4611687942572736512L, 5471784132955L, 0L, 0L };
7578: return data;
7579: }
7580:
7581: public static final BitSet _tokenSet_14 = new BitSet(
7582: mk_tokenSet_14());
7583:
7584: private static final long[] mk_tokenSet_15() {
7585: long[] data = { 1924145348608L, 966363439369L, 0L, 0L };
7586: return data;
7587: }
7588:
7589: public static final BitSet _tokenSet_15 = new BitSet(
7590: mk_tokenSet_15());
7591:
7592: private static final long[] mk_tokenSet_16() {
7593: long[] data = { 1924145348608L, 970658406683L, 0L, 0L };
7594: return data;
7595: }
7596:
7597: public static final BitSet _tokenSet_16 = new BitSet(
7598: mk_tokenSet_16());
7599:
7600: private static final long[] mk_tokenSet_17() {
7601: long[] data = { 0L, 4186120L, 0L, 0L };
7602: return data;
7603: }
7604:
7605: public static final BitSet _tokenSet_17 = new BitSet(
7606: mk_tokenSet_17());
7607:
7608: private static final long[] mk_tokenSet_18() {
7609: long[] data = { 0L, 282L, 0L, 0L };
7610: return data;
7611: }
7612:
7613: public static final BitSet _tokenSet_18 = new BitSet(
7614: mk_tokenSet_18());
7615:
7616: private static final long[] mk_tokenSet_19() {
7617: long[] data = { 4611686018427387904L, 17179869698L, 0L, 0L };
7618: return data;
7619: }
7620:
7621: public static final BitSet _tokenSet_19 = new BitSet(
7622: mk_tokenSet_19());
7623:
7624: private static final long[] mk_tokenSet_20() {
7625: long[] data = { 274877906944L, 2151669768L, 0L, 0L };
7626: return data;
7627: }
7628:
7629: public static final BitSet _tokenSet_20 = new BitSet(
7630: mk_tokenSet_20());
7631:
7632: private static final long[] mk_tokenSet_21() {
7633: long[] data = { 0L, 2151670042L, 0L, 0L };
7634: return data;
7635: }
7636:
7637: public static final BitSet _tokenSet_21 = new BitSet(
7638: mk_tokenSet_21());
7639:
7640: private static final long[] mk_tokenSet_22() {
7641: long[] data = { 0L, 35186523758874L, 0L, 0L };
7642: return data;
7643: }
7644:
7645: public static final BitSet _tokenSet_22 = new BitSet(
7646: mk_tokenSet_22());
7647:
7648: private static final long[] mk_tokenSet_23() {
7649: long[] data = { 4611687942572736512L, 431932328239948169L,
7650: 34356330496L, 0L, 0L, 0L };
7651: return data;
7652: }
7653:
7654: public static final BitSet _tokenSet_23 = new BitSet(
7655: mk_tokenSet_23());
7656:
7657: private static final long[] mk_tokenSet_24() {
7658: long[] data = { 0L, 8796093022592L, 0L, 0L };
7659: return data;
7660: }
7661:
7662: public static final BitSet _tokenSet_24 = new BitSet(
7663: mk_tokenSet_24());
7664:
7665: private static final long[] mk_tokenSet_25() {
7666: long[] data = { 0L, 4299153448L, 0L, 0L };
7667: return data;
7668: }
7669:
7670: public static final BitSet _tokenSet_25 = new BitSet(
7671: mk_tokenSet_25());
7672:
7673: private static final long[] mk_tokenSet_26() {
7674: long[] data = { 4611687942572736512L, 431932396959424905L,
7675: 34356330496L, 0L, 0L, 0L };
7676: return data;
7677: }
7678:
7679: public static final BitSet _tokenSet_26 = new BitSet(
7680: mk_tokenSet_26());
7681:
7682: private static final long[] mk_tokenSet_27() {
7683: long[] data = { 4611687942572736512L, -1873838302180672069L,
7684: 34359738367L, 0L, 0L, 0L };
7685: return data;
7686: }
7687:
7688: public static final BitSet _tokenSet_27 = new BitSet(
7689: mk_tokenSet_27());
7690:
7691: private static final long[] mk_tokenSet_28() {
7692: long[] data = { 4611687942572736512L, 576331259035246985L,
7693: 34356330496L, 0L, 0L, 0L };
7694: return data;
7695: }
7696:
7697: public static final BitSet _tokenSet_28 = new BitSet(
7698: mk_tokenSet_28());
7699:
7700: private static final long[] mk_tokenSet_29() {
7701: long[] data = { 4611687942572736512L, -57183194579525L,
7702: 34359738367L, 0L, 0L, 0L };
7703: return data;
7704: }
7705:
7706: public static final BitSet _tokenSet_29 = new BitSet(
7707: mk_tokenSet_29());
7708:
7709: private static final long[] mk_tokenSet_30() {
7710: long[] data = { 1924145348608L, 4290764809L, 0L, 0L };
7711: return data;
7712: }
7713:
7714: public static final BitSet _tokenSet_30 = new BitSet(
7715: mk_tokenSet_30());
7716:
7717: private static final long[] mk_tokenSet_31() {
7718: long[] data = { 1924145348608L, 4290765083L, 0L, 0L };
7719: return data;
7720: }
7721:
7722: public static final BitSet _tokenSet_31 = new BitSet(
7723: mk_tokenSet_31());
7724:
7725: private static final long[] mk_tokenSet_32() {
7726: long[] data = { 0L, 8800392176008L, 34356330496L, 0L, 0L, 0L };
7727: return data;
7728: }
7729:
7730: public static final BitSet _tokenSet_32 = new BitSet(
7731: mk_tokenSet_32());
7732:
7733: private static final long[] mk_tokenSet_33() {
7734: long[] data = { 4611686018427387904L, -2305833092125819462L,
7735: 34359738367L, 0L, 0L, 0L };
7736: return data;
7737: }
7738:
7739: public static final BitSet _tokenSet_33 = new BitSet(
7740: mk_tokenSet_33());
7741:
7742: private static final long[] mk_tokenSet_34() {
7743: long[] data = { 1924145348608L, 141725532161L, 0L, 0L };
7744: return data;
7745: }
7746:
7747: public static final BitSet _tokenSet_34 = new BitSet(
7748: mk_tokenSet_34());
7749:
7750: private static final long[] mk_tokenSet_35() {
7751: long[] data = { 1924145348608L, 141725532169L, 0L, 0L };
7752: return data;
7753: }
7754:
7755: public static final BitSet _tokenSet_35 = new BitSet(
7756: mk_tokenSet_35());
7757:
7758: private static final long[] mk_tokenSet_36() {
7759: long[] data = { 4611687942572736512L, 8804678754697L,
7760: 34356330496L, 0L, 0L, 0L };
7761: return data;
7762: }
7763:
7764: public static final BitSet _tokenSet_36 = new BitSet(
7765: mk_tokenSet_36());
7766:
7767: private static final long[] mk_tokenSet_37() {
7768: long[] data = { 4611687942572736512L, -2305833087839240261L,
7769: 34359738367L, 0L, 0L, 0L };
7770: return data;
7771: }
7772:
7773: public static final BitSet _tokenSet_37 = new BitSet(
7774: mk_tokenSet_37());
7775:
7776: private static final long[] mk_tokenSet_38() {
7777: long[] data = { 0L, 79169136353672L, 34356330496L, 0L, 0L, 0L };
7778: return data;
7779: }
7780:
7781: public static final BitSet _tokenSet_38 = new BitSet(
7782: mk_tokenSet_38());
7783:
7784: private static final long[] mk_tokenSet_39() {
7785: long[] data = { 4611686018427387904L, -2305833092125818950L,
7786: 34359738367L, 0L, 0L, 0L };
7787: return data;
7788: }
7789:
7790: public static final BitSet _tokenSet_39 = new BitSet(
7791: mk_tokenSet_39());
7792:
7793: private static final long[] mk_tokenSet_40() {
7794: long[] data = { 0L, 1280L, 49152L, 0L, 0L, 0L };
7795: return data;
7796: }
7797:
7798: public static final BitSet _tokenSet_40 = new BitSet(
7799: mk_tokenSet_40());
7800:
7801: private static final long[] mk_tokenSet_41() {
7802: long[] data = { 0L, 6144L, 131072L, 0L, 0L, 0L };
7803: return data;
7804: }
7805:
7806: public static final BitSet _tokenSet_41 = new BitSet(
7807: mk_tokenSet_41());
7808:
7809: private static final long[] mk_tokenSet_42() {
7810: long[] data = { 0L, 4194304L, 3145728L, 0L, 0L, 0L };
7811: return data;
7812: }
7813:
7814: public static final BitSet _tokenSet_42 = new BitSet(
7815: mk_tokenSet_42());
7816:
7817: private static final long[] mk_tokenSet_43() {
7818: long[] data = { 0L, 8800392176008L, 34292629504L, 0L, 0L, 0L };
7819: return data;
7820: }
7821:
7822: public static final BitSet _tokenSet_43 = new BitSet(
7823: mk_tokenSet_43());
7824:
7825: private static final long[] mk_tokenSet_44() {
7826: long[] data = { 4611686018427387904L, -2305762646072229954L,
7827: 34359738367L, 0L, 0L, 0L };
7828: return data;
7829: }
7830:
7831: public static final BitSet _tokenSet_44 = new BitSet(
7832: mk_tokenSet_44());
7833:
7834: private static final long[] mk_tokenSet_45() {
7835: long[] data = { 0L, 392L, 0L, 0L };
7836: return data;
7837: }
7838:
7839: public static final BitSet _tokenSet_45 = new BitSet(
7840: mk_tokenSet_45());
7841:
7842: private static final long[] mk_tokenSet_46() {
7843: long[] data = { 4611686018427387904L, -2305771446464405706L,
7844: 16777215L, 0L, 0L, 0L };
7845: return data;
7846: }
7847:
7848: public static final BitSet _tokenSet_46 = new BitSet(
7849: mk_tokenSet_46());
7850:
7851: private static final long[] mk_tokenSet_47() {
7852: long[] data = { 6917530951786430464L, -1729439431514914881L,
7853: 34359738367L, 0L, 0L, 0L };
7854: return data;
7855: }
7856:
7857: public static final BitSet _tokenSet_47 = new BitSet(
7858: mk_tokenSet_47());
7859:
7860: private static final long[] mk_tokenSet_48() {
7861: long[] data = { 4611686018427387904L, -2305771442169438410L,
7862: 16777215L, 0L, 0L, 0L };
7863: return data;
7864: }
7865:
7866: public static final BitSet _tokenSet_48 = new BitSet(
7867: mk_tokenSet_48());
7868:
7869: private static final long[] mk_tokenSet_49() {
7870: long[] data = { 0L, 8800392176012L, 34356330496L, 0L, 0L, 0L };
7871: return data;
7872: }
7873:
7874: public static final BitSet _tokenSet_49 = new BitSet(
7875: mk_tokenSet_49());
7876:
7877: }
|