00001: // $ANTLR 2.7.2: "groovy.g" -> "GroovyRecognizer.java"$
00002:
00003: package org.codehaus.groovy.antlr.parser;
00004:
00005: import org.codehaus.groovy.antlr.*;
00006: import java.util.*;
00007: import java.io.InputStream;
00008: import java.io.Reader;
00009: import antlr.InputBuffer;
00010: import antlr.LexerSharedInputState;
00011:
00012: import antlr.TokenBuffer;
00013: import antlr.TokenStreamException;
00014: import antlr.TokenStreamIOException;
00015: import antlr.ANTLRException;
00016: import antlr.LLkParser;
00017: import antlr.Token;
00018: import antlr.TokenStream;
00019: import antlr.RecognitionException;
00020: import antlr.NoViableAltException;
00021: import antlr.MismatchedTokenException;
00022: import antlr.SemanticException;
00023: import antlr.ParserSharedInputState;
00024: import antlr.collections.impl.BitSet;
00025: import antlr.collections.AST;
00026: import java.util.Hashtable;
00027: import antlr.ASTFactory;
00028: import antlr.ASTPair;
00029: import antlr.collections.impl.ASTArray;
00030:
00031: /** JSR-241 Groovy Recognizer
00032: *
00033: * Run 'java Main [-showtree] directory-full-of-groovy-files'
00034: *
00035: * [The -showtree option pops up a Swing frame that shows
00036: * the AST constructed from the parser.]
00037: *
00038: * Contributing authors:
00039: * John Mitchell johnm@non.net
00040: * Terence Parr parrt@magelang.com
00041: * John Lilley jlilley@empathy.com
00042: * Scott Stanchfield thetick@magelang.com
00043: * Markus Mohnen mohnen@informatik.rwth-aachen.de
00044: * Peter Williams pete.williams@sun.com
00045: * Allan Jacobs Allan.Jacobs@eng.sun.com
00046: * Steve Messick messick@redhills.com
00047: * James Strachan jstrachan@protique.com
00048: * John Pybus john@pybus.org
00049: * John Rose rose00@mac.com
00050: * Jeremy Rayner groovy@ross-rayner.com
00051: *
00052: * Version 1.00 December 9, 1997 -- initial release
00053: * Version 1.01 December 10, 1997
00054: * fixed bug in octal def (0..7 not 0..8)
00055: * Version 1.10 August 1998 (parrt)
00056: * added tree construction
00057: * fixed definition of WS,comments for mac,pc,unix newlines
00058: * added unary plus
00059: * Version 1.11 (Nov 20, 1998)
00060: * Added "shutup" option to turn off last ambig warning.
00061: * Fixed inner class def to allow named class defs as statements
00062: * synchronized requires compound not simple statement
00063: * add [] after builtInType DOT class in primaryExpression
00064: * "const" is reserved but not valid..removed from modifiers
00065: * Version 1.12 (Feb 2, 1999)
00066: * Changed LITERAL_xxx to xxx in tree grammar.
00067: * Updated java.g to use tokens {...} now for 2.6.0 (new feature).
00068: *
00069: * Version 1.13 (Apr 23, 1999)
00070: * Didn't have (stat)? for else clause in tree parser.
00071: * Didn't gen ASTs for interface extends. Updated tree parser too.
00072: * Updated to 2.6.0.
00073: * Version 1.14 (Jun 20, 1999)
00074: * Allowed final/abstract on local classes.
00075: * Removed local interfaces from methods
00076: * Put instanceof precedence where it belongs...in relationalExpr
00077: * It also had expr not type as arg; fixed it.
00078: * Missing ! on SEMI in classBlock
00079: * fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
00080: * fixed: didn't like Object[].class in parser or tree parser
00081: * Version 1.15 (Jun 26, 1999)
00082: * Screwed up rule with instanceof in it. :( Fixed.
00083: * Tree parser didn't like (expr).something; fixed.
00084: * Allowed multiple inheritance in tree grammar. oops.
00085: * Version 1.16 (August 22, 1999)
00086: * Extending an interface built a wacky tree: had extra EXTENDS.
00087: * Tree grammar didn't allow multiple superinterfaces.
00088: * Tree grammar didn't allow empty var initializer: {}
00089: * Version 1.17 (October 12, 1999)
00090: * ESC lexer rule allowed 399 max not 377 max.
00091: * java.tree.g didn't handle the expression of synchronized
00092: * statements.
00093: * Version 1.18 (August 12, 2001)
00094: * Terence updated to Java 2 Version 1.3 by
00095: * observing/combining work of Allan Jacobs and Steve
00096: * Messick. Handles 1.3 src. Summary:
00097: * o primary didn't include boolean.class kind of thing
00098: * o constructor calls parsed explicitly now:
00099: * see explicitConstructorInvocation
00100: * o add strictfp modifier
00101: * o missing objBlock after new expression in tree grammar
00102: * o merged local class definition alternatives, moved after declaration
00103: * o fixed problem with ClassName.super.field
00104: * o reordered some alternatives to make things more efficient
00105: * o long and double constants were not differentiated from int/float
00106: * o whitespace rule was inefficient: matched only one char
00107: * o add an examples directory with some nasty 1.3 cases
00108: * o made Main.java use buffered IO and a Reader for Unicode support
00109: * o supports UNICODE?
00110: * Using Unicode charVocabulay makes code file big, but only
00111: * in the bitsets at the end. I need to make ANTLR generate
00112: * unicode bitsets more efficiently.
00113: * Version 1.19 (April 25, 2002)
00114: * Terence added in nice fixes by John Pybus concerning floating
00115: * constants and problems with super() calls. John did a nice
00116: * reorg of the primary/postfix expression stuff to read better
00117: * and makes f.g.super() parse properly (it was METHOD_CALL not
00118: * a SUPER_CTOR_CALL). Also:
00119: *
00120: * o "finally" clause was a root...made it a child of "try"
00121: * o Added stuff for asserts too for Java 1.4, but *commented out*
00122: * as it is not backward compatible.
00123: *
00124: * Version 1.20 (October 27, 2002)
00125: *
00126: * Terence ended up reorging John Pybus' stuff to
00127: * remove some nondeterminisms and some syntactic predicates.
00128: * Note that the grammar is stricter now; e.g., this(...) must
00129: * be the first statement.
00130: *
00131: * Trinary ?: operator wasn't working as array name:
00132: * (isBig ? bigDigits : digits)[i];
00133: *
00134: * Checked parser/tree parser on source for
00135: * Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
00136: * and the 110k-line jGuru server source.
00137: *
00138: * Version 1.21 (October 17, 2003)
00139: * Fixed lots of problems including:
00140: * Ray Waldin: add typeDefinition to interfaceBlock in java.tree.g
00141: * He found a problem/fix with floating point that start with 0
00142: * Ray also fixed problem that (int.class) was not recognized.
00143: * Thorsten van Ellen noticed that \n are allowed incorrectly in strings.
00144: * TJP fixed CHAR_LITERAL analogously.
00145: *
00146: * Version 1.21.2 (March, 2003)
00147: * Changes by Matt Quail to support generics (as per JDK1.5/JSR14)
00148: * Notes:
00149: * o We only allow the "extends" keyword and not the "implements"
00150: * keyword, since thats what JSR14 seems to imply.
00151: * o Thanks to Monty Zukowski for his help on the antlr-interest
00152: * mail list.
00153: * o Thanks to Alan Eliasen for testing the grammar over his
00154: * Fink source base
00155: *
00156: * Version 1.22 (July, 2004)
00157: * Changes by Michael Studman to support Java 1.5 language extensions
00158: * Notes:
00159: * o Added support for annotations types
00160: * o Finished off Matt Quail's generics enhancements to support bound type arguments
00161: * o Added support for new for statement syntax
00162: * o Added support for static import syntax
00163: * o Added support for enum types
00164: * o Tested against JDK 1.5 source base and source base of jdigraph project
00165: * o Thanks to Matt Quail for doing the hard part by doing most of the generics work
00166: *
00167: * Version 1.22.1 (July 28, 2004)
00168: * Bug/omission fixes for Java 1.5 language support
00169: * o Fixed tree structure bug with classOrInterface - thanks to Pieter Vangorpto for
00170: * spotting this
00171: * o Fixed bug where incorrect handling of SR and BSR tokens would cause type
00172: * parameters to be recognised as type arguments.
00173: * o Enabled type parameters on constructors, annotations on enum constants
00174: * and package definitions
00175: * o Fixed problems when parsing if ((char.class.equals(c))) {} - solution by Matt Quail at Cenqua
00176: *
00177: * Version 1.22.2 (July 28, 2004)
00178: * Slight refactoring of Java 1.5 language support
00179: * o Refactored for/"foreach" productions so that original literal "for" literal
00180: * is still used but the for sub-clauses vary by token type
00181: * o Fixed bug where type parameter was not included in generic constructor's branch of AST
00182: *
00183: * Version 1.22.3 (August 26, 2004)
00184: * Bug fixes as identified by Michael Stahl; clean up of tabs/spaces
00185: * and other refactorings
00186: * o Fixed typeParameters omission in identPrimary and newStatement
00187: * o Replaced GT reconcilliation code with simple semantic predicate
00188: * o Adapted enum/assert keyword checking support from Michael Stahl's java15 grammar
00189: * o Refactored typeDefinition production and field productions to reduce duplication
00190: *
00191: * Version 1.22.4 (October 21, 2004)
00192: * Small bux fixes
00193: * o Added typeArguments to explicitConstructorInvocation, e.g. new <String>MyParameterised()
00194: * o Added typeArguments to postfixExpression productions for anonymous inner class super
00195: * constructor invocation, e.g. new Outer().<String>super()
00196: * o Fixed bug in array declarations identified by Geoff Roy
00197: *
00198: * Version 1.22.4.g.1
00199: * o I have taken java.g for Java1.5 from Michael Studman (1.22.4)
00200: * and have applied the groovy.diff from java.g (1.22) by John Rose
00201: * back onto the new root (1.22.4) - Jeremy Rayner (Jan 2005)
00202: * o for a map of the task see...
00203: * http://groovy.javanicus.com/java-g.png
00204: *
00205: * This grammar is in the PUBLIC DOMAIN
00206: */
00207: public class GroovyRecognizer extends antlr.LLkParser implements
00208: GroovyTokenTypes {
00209:
00210: /** This factory is the correct way to wire together a Groovy parser and lexer. */
00211: public static GroovyRecognizer make(GroovyLexer lexer) {
00212: GroovyRecognizer parser = new GroovyRecognizer(lexer.plumb());
00213: // TODO: set up a common error-handling control block, to avoid excessive tangle between these guys
00214: parser.lexer = lexer;
00215: lexer.parser = parser;
00216: parser
00217: .setASTNodeClass("org.codehaus.groovy.antlr.GroovySourceAST");
00218: parser.warningList = new ArrayList();
00219: return parser;
00220: }
00221:
00222: // Create a scanner that reads from the input stream passed to us...
00223: public static GroovyRecognizer make(InputStream in) {
00224: return make(new GroovyLexer(in));
00225: }
00226:
00227: public static GroovyRecognizer make(Reader in) {
00228: return make(new GroovyLexer(in));
00229: }
00230:
00231: public static GroovyRecognizer make(InputBuffer in) {
00232: return make(new GroovyLexer(in));
00233: }
00234:
00235: public static GroovyRecognizer make(LexerSharedInputState in) {
00236: return make(new GroovyLexer(in));
00237: }
00238:
00239: private static GroovySourceAST dummyVariableToforceClassLoaderToFindASTClass = new GroovySourceAST();
00240:
00241: List warningList;
00242:
00243: public List getWarningList() {
00244: return warningList;
00245: }
00246:
00247: GroovyLexer lexer;
00248:
00249: public GroovyLexer getLexer() {
00250: return lexer;
00251: }
00252:
00253: public void setFilename(String f) {
00254: super .setFilename(f);
00255: lexer.setFilename(f);
00256: }
00257:
00258: private SourceBuffer sourceBuffer;
00259:
00260: public void setSourceBuffer(SourceBuffer sourceBuffer) {
00261: this .sourceBuffer = sourceBuffer;
00262: }
00263:
00264: /** Create an AST node with the token type and text passed in, but
00265: * with the same background information as another supplied Token (e.g. line numbers)
00266: * to be used in place of antlr tree construction syntax,
00267: * i.e. #[TOKEN,"text"] becomes create(TOKEN,"text",anotherToken)
00268: *
00269: * todo - change antlr.ASTFactory to do this instead...
00270: */
00271: public AST create(int type, String txt, Token first, Token last) {
00272: AST t = astFactory.create(type, txt);
00273: if (t != null && first != null) {
00274: // first copy details from first token
00275: t.initialize(first);
00276: // then ensure that type and txt are specific to this new node
00277: t.initialize(type, txt);
00278: }
00279:
00280: if ((t instanceof GroovySourceAST) && last != null) {
00281: GroovySourceAST node = (GroovySourceAST) t;
00282: node.setLast(last);
00283: // This is a good point to call node.setSnippet(),
00284: // but it bulks up the AST too much for production code.
00285: }
00286: return t;
00287: }
00288:
00289: // stuff to adjust ANTLR's tracing machinery
00290: public static boolean tracing = false; // only effective if antlr.Tool is run with -traceParser
00291:
00292: public void traceIn(String rname) throws TokenStreamException {
00293: if (!GroovyRecognizer.tracing)
00294: return;
00295: super .traceIn(rname);
00296: }
00297:
00298: public void traceOut(String rname) throws TokenStreamException {
00299: if (!GroovyRecognizer.tracing)
00300: return;
00301: if (returnAST != null)
00302: rname += returnAST.toStringList();
00303: super .traceOut(rname);
00304: }
00305:
00306: // Error handling. This is a funnel through which parser errors go, when the parser can suggest a solution.
00307: public void requireFailed(String problem, String solution)
00308: throws SemanticException {
00309: // TODO: Needs more work.
00310: Token lt = null;
00311: try {
00312: lt = LT(1);
00313: } catch (TokenStreamException ee) {
00314: }
00315: if (lt == null)
00316: lt = Token.badToken;
00317: throw new SemanticException(problem + ";\n solution: "
00318: + solution, getFilename(), lt.getLine(), lt.getColumn());
00319: }
00320:
00321: public void addWarning(String warning, String solution) {
00322: Token lt = null;
00323: try {
00324: lt = LT(1);
00325: } catch (TokenStreamException ee) {
00326: }
00327: if (lt == null)
00328: lt = Token.badToken;
00329:
00330: Map row = new HashMap();
00331: row.put("warning", warning);
00332: row.put("solution", solution);
00333: row.put("filename", getFilename());
00334: row.put("line", new Integer(lt.getLine()));
00335: row.put("column", new Integer(lt.getColumn()));
00336: // System.out.println(row);
00337: warningList.add(row);
00338: }
00339:
00340: // Convenience method for checking of expected error syndromes.
00341: private void require(boolean z, String problem, String solution)
00342: throws SemanticException {
00343: if (!z)
00344: requireFailed(problem, solution);
00345: }
00346:
00347: // Query a name token to see if it begins with a capital letter.
00348: // This is used to tell the difference (w/o symbol table access) between {String x} and {println x}.
00349: private boolean isUpperCase(Token x) {
00350: if (x == null || x.getType() != IDENT)
00351: return false; // cannot happen?
00352: String xtext = x.getText();
00353: return (xtext.length() > 0 && Character.isUpperCase(xtext
00354: .charAt(0)));
00355: }
00356:
00357: private AST currentClass = null; // current enclosing class (for constructor recognition)
00358:
00359: // Query a name token to see if it is identical with the current class name.
00360: // This is used to distinguish constructors from other methods.
00361: private boolean isConstructorIdent(Token x) {
00362: if (currentClass == null)
00363: return false;
00364: if (currentClass.getType() != IDENT)
00365: return false; // cannot happen?
00366: String cname = currentClass.getText();
00367:
00368: if (x == null || x.getType() != IDENT)
00369: return false; // cannot happen?
00370: return cname.equals(x.getText());
00371: }
00372:
00373: // Scratch variable for last 'sep' token.
00374: // Written by the 'sep' rule, read only by immediate callers of 'sep'.
00375: // (Not entirely clean, but better than a million xx=sep occurrences.)
00376: private int sepToken = EOF;
00377:
00378: // Scratch variable for last argument list; tells whether there was a label.
00379: // Written by 'argList' rule, read only by immediate callers of 'argList'.
00380: private boolean argListHasLabels = false;
00381:
00382: // Scratch variable, holds most recently completed pathExpression.
00383: // Read only by immediate callers of 'pathExpression' and 'expression'.
00384: private AST lastPathExpression = null;
00385:
00386: // Inherited attribute pushed into most expression rules.
00387: // If not zero, it means that the left context of the expression
00388: // being parsed is a statement boundary or an initializer sign '='.
00389: // Only such expressions are allowed to reach across newlines
00390: // to pull in an LCURLY and appended block.
00391: private final int LC_STMT = 1, LC_INIT = 2;
00392:
00393: /**
00394: * Counts the number of LT seen in the typeArguments production.
00395: * It is used in semantic predicates to ensure we have seen
00396: * enough closing '>' characters; which actually may have been
00397: * either GT, SR or BSR tokens.
00398: */
00399: private int ltCounter = 0;
00400:
00401: /* This symbol is used to work around a known ANTLR limitation.
00402: * In a loop with syntactic predicate, ANTLR needs help knowing
00403: * that the loop exit is a second alternative.
00404: * Example usage: ( (LCURLY)=> block | {ANTLR_LOOP_EXIT}? )*
00405: * Probably should be an ANTLR RFE.
00406: */
00407: ////// Original comment in Java grammar:
00408: // Unfortunately a syntactic predicate can only select one of
00409: // multiple alternatives on the same level, not break out of
00410: // an enclosing loop, which is why this ugly hack (a fake
00411: // empty alternative with always-false semantic predicate)
00412: // is necessary.
00413: private static final boolean ANTLR_LOOP_EXIT = false;
00414:
00415: protected GroovyRecognizer(TokenBuffer tokenBuf, int k) {
00416: super (tokenBuf, k);
00417: tokenNames = _tokenNames;
00418: buildTokenTypeASTClassMap();
00419: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
00420: }
00421:
00422: public GroovyRecognizer(TokenBuffer tokenBuf) {
00423: this (tokenBuf, 3);
00424: }
00425:
00426: protected GroovyRecognizer(TokenStream lexer, int k) {
00427: super (lexer, k);
00428: tokenNames = _tokenNames;
00429: buildTokenTypeASTClassMap();
00430: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
00431: }
00432:
00433: public GroovyRecognizer(TokenStream lexer) {
00434: this (lexer, 3);
00435: }
00436:
00437: public GroovyRecognizer(ParserSharedInputState state) {
00438: super (state, 3);
00439: tokenNames = _tokenNames;
00440: buildTokenTypeASTClassMap();
00441: astFactory = new ASTFactory(getTokenTypeToASTClassMap());
00442: }
00443:
00444: public final void compilationUnit() throws RecognitionException,
00445: TokenStreamException {
00446:
00447: returnAST = null;
00448: ASTPair currentAST = new ASTPair();
00449: AST compilationUnit_AST = null;
00450:
00451: {
00452: switch (LA(1)) {
00453: case SH_COMMENT: {
00454: match(SH_COMMENT);
00455: break;
00456: }
00457: case EOF:
00458: case FINAL:
00459: case ABSTRACT:
00460: case STRICTFP:
00461: case LITERAL_package:
00462: case LITERAL_import:
00463: case LITERAL_static:
00464: case LITERAL_def:
00465: case AT:
00466: case IDENT:
00467: case LBRACK:
00468: case LPAREN:
00469: case LITERAL_class:
00470: case LITERAL_interface:
00471: case LITERAL_enum:
00472: case LITERAL_super :
00473: case LITERAL_void:
00474: case LITERAL_boolean:
00475: case LITERAL_byte:
00476: case LITERAL_char:
00477: case LITERAL_short:
00478: case LITERAL_int:
00479: case LITERAL_float:
00480: case LITERAL_long:
00481: case LITERAL_double:
00482: case LITERAL_any:
00483: case STAR:
00484: case LITERAL_private:
00485: case LITERAL_public:
00486: case LITERAL_protected:
00487: case LITERAL_transient:
00488: case LITERAL_native:
00489: case LITERAL_threadsafe:
00490: case LITERAL_synchronized:
00491: case LITERAL_volatile:
00492: case LCURLY:
00493: case SEMI:
00494: case NLS:
00495: case LITERAL_this :
00496: case STRING_LITERAL:
00497: case LITERAL_if:
00498: case LITERAL_while:
00499: case LITERAL_with:
00500: case LITERAL_switch:
00501: case LITERAL_for:
00502: case LITERAL_return:
00503: case LITERAL_break:
00504: case LITERAL_continue:
00505: case LITERAL_throw:
00506: case LITERAL_assert:
00507: case PLUS:
00508: case MINUS:
00509: case LITERAL_try:
00510: case INC:
00511: case DEC:
00512: case BNOT:
00513: case LNOT:
00514: case DOLLAR:
00515: case STRING_CTOR_START:
00516: case LITERAL_new:
00517: case LITERAL_true:
00518: case LITERAL_false:
00519: case LITERAL_null:
00520: case NUM_INT:
00521: case NUM_FLOAT:
00522: case NUM_LONG:
00523: case NUM_DOUBLE:
00524: case NUM_BIG_INT:
00525: case NUM_BIG_DECIMAL: {
00526: break;
00527: }
00528: default: {
00529: throw new NoViableAltException(LT(1), getFilename());
00530: }
00531: }
00532: }
00533: nls();
00534: {
00535: boolean synPredMatched5 = false;
00536: if (((LA(1) == LITERAL_package || LA(1) == AT)
00537: && (LA(2) == IDENT) && (_tokenSet_0.member(LA(3))))) {
00538: int _m5 = mark();
00539: synPredMatched5 = true;
00540: inputState.guessing++;
00541: try {
00542: {
00543: annotationsOpt();
00544: match(LITERAL_package);
00545: }
00546: } catch (RecognitionException pe) {
00547: synPredMatched5 = false;
00548: }
00549: rewind(_m5);
00550: inputState.guessing--;
00551: }
00552: if (synPredMatched5) {
00553: packageDefinition();
00554: astFactory.addASTChild(currentAST, returnAST);
00555: } else if ((_tokenSet_1.member(LA(1)))
00556: && (_tokenSet_2.member(LA(2)))
00557: && (_tokenSet_3.member(LA(3)))) {
00558: {
00559: switch (LA(1)) {
00560: case FINAL:
00561: case ABSTRACT:
00562: case STRICTFP:
00563: case LITERAL_import:
00564: case LITERAL_static:
00565: case LITERAL_def:
00566: case AT:
00567: case IDENT:
00568: case LBRACK:
00569: case LPAREN:
00570: case LITERAL_class:
00571: case LITERAL_interface:
00572: case LITERAL_enum:
00573: case LITERAL_super :
00574: case LITERAL_void:
00575: case LITERAL_boolean:
00576: case LITERAL_byte:
00577: case LITERAL_char:
00578: case LITERAL_short:
00579: case LITERAL_int:
00580: case LITERAL_float:
00581: case LITERAL_long:
00582: case LITERAL_double:
00583: case LITERAL_any:
00584: case STAR:
00585: case LITERAL_private:
00586: case LITERAL_public:
00587: case LITERAL_protected:
00588: case LITERAL_transient:
00589: case LITERAL_native:
00590: case LITERAL_threadsafe:
00591: case LITERAL_synchronized:
00592: case LITERAL_volatile:
00593: case LCURLY:
00594: case LITERAL_this :
00595: case STRING_LITERAL:
00596: case LITERAL_if:
00597: case LITERAL_while:
00598: case LITERAL_with:
00599: case LITERAL_switch:
00600: case LITERAL_for:
00601: case LITERAL_return:
00602: case LITERAL_break:
00603: case LITERAL_continue:
00604: case LITERAL_throw:
00605: case LITERAL_assert:
00606: case PLUS:
00607: case MINUS:
00608: case LITERAL_try:
00609: case INC:
00610: case DEC:
00611: case BNOT:
00612: case LNOT:
00613: case DOLLAR:
00614: case STRING_CTOR_START:
00615: case LITERAL_new:
00616: case LITERAL_true:
00617: case LITERAL_false:
00618: case LITERAL_null:
00619: case NUM_INT:
00620: case NUM_FLOAT:
00621: case NUM_LONG:
00622: case NUM_DOUBLE:
00623: case NUM_BIG_INT:
00624: case NUM_BIG_DECIMAL: {
00625: statement(EOF);
00626: astFactory.addASTChild(currentAST, returnAST);
00627: break;
00628: }
00629: case EOF:
00630: case SEMI:
00631: case NLS: {
00632: break;
00633: }
00634: default: {
00635: throw new NoViableAltException(LT(1),
00636: getFilename());
00637: }
00638: }
00639: }
00640: } else {
00641: throw new NoViableAltException(LT(1), getFilename());
00642: }
00643:
00644: }
00645: {
00646: _loop9: do {
00647: if ((LA(1) == SEMI || LA(1) == NLS)) {
00648: sep();
00649: {
00650: switch (LA(1)) {
00651: case FINAL:
00652: case ABSTRACT:
00653: case STRICTFP:
00654: case LITERAL_import:
00655: case LITERAL_static:
00656: case LITERAL_def:
00657: case AT:
00658: case IDENT:
00659: case LBRACK:
00660: case LPAREN:
00661: case LITERAL_class:
00662: case LITERAL_interface:
00663: case LITERAL_enum:
00664: case LITERAL_super :
00665: case LITERAL_void:
00666: case LITERAL_boolean:
00667: case LITERAL_byte:
00668: case LITERAL_char:
00669: case LITERAL_short:
00670: case LITERAL_int:
00671: case LITERAL_float:
00672: case LITERAL_long:
00673: case LITERAL_double:
00674: case LITERAL_any:
00675: case STAR:
00676: case LITERAL_private:
00677: case LITERAL_public:
00678: case LITERAL_protected:
00679: case LITERAL_transient:
00680: case LITERAL_native:
00681: case LITERAL_threadsafe:
00682: case LITERAL_synchronized:
00683: case LITERAL_volatile:
00684: case LCURLY:
00685: case LITERAL_this :
00686: case STRING_LITERAL:
00687: case LITERAL_if:
00688: case LITERAL_while:
00689: case LITERAL_with:
00690: case LITERAL_switch:
00691: case LITERAL_for:
00692: case LITERAL_return:
00693: case LITERAL_break:
00694: case LITERAL_continue:
00695: case LITERAL_throw:
00696: case LITERAL_assert:
00697: case PLUS:
00698: case MINUS:
00699: case LITERAL_try:
00700: case INC:
00701: case DEC:
00702: case BNOT:
00703: case LNOT:
00704: case DOLLAR:
00705: case STRING_CTOR_START:
00706: case LITERAL_new:
00707: case LITERAL_true:
00708: case LITERAL_false:
00709: case LITERAL_null:
00710: case NUM_INT:
00711: case NUM_FLOAT:
00712: case NUM_LONG:
00713: case NUM_DOUBLE:
00714: case NUM_BIG_INT:
00715: case NUM_BIG_DECIMAL: {
00716: statement(sepToken);
00717: astFactory.addASTChild(currentAST,
00718: returnAST);
00719: break;
00720: }
00721: case EOF:
00722: case SEMI:
00723: case NLS: {
00724: break;
00725: }
00726: default: {
00727: throw new NoViableAltException(LT(1),
00728: getFilename());
00729: }
00730: }
00731: }
00732: } else {
00733: break _loop9;
00734: }
00735:
00736: } while (true);
00737: }
00738: match(Token.EOF_TYPE);
00739: compilationUnit_AST = (AST) currentAST.root;
00740: returnAST = compilationUnit_AST;
00741: }
00742:
00743: /** Zero or more insignificant newlines, all gobbled up and thrown away. */
00744: public final void nls() throws RecognitionException,
00745: TokenStreamException {
00746:
00747: returnAST = null;
00748: ASTPair currentAST = new ASTPair();
00749: AST nls_AST = null;
00750:
00751: {
00752: if ((LA(1) == NLS) && (_tokenSet_4.member(LA(2)))
00753: && (_tokenSet_5.member(LA(3)))) {
00754: match(NLS);
00755: } else if ((_tokenSet_4.member(LA(1)))
00756: && (_tokenSet_5.member(LA(2)))
00757: && (_tokenSet_5.member(LA(3)))) {
00758: } else {
00759: throw new NoViableAltException(LT(1), getFilename());
00760: }
00761:
00762: }
00763: returnAST = nls_AST;
00764: }
00765:
00766: public final void annotationsOpt() throws RecognitionException,
00767: TokenStreamException {
00768:
00769: returnAST = null;
00770: ASTPair currentAST = new ASTPair();
00771: AST annotationsOpt_AST = null;
00772: Token first = LT(1);
00773:
00774: {
00775: _loop79: do {
00776: if ((LA(1) == AT)) {
00777: annotation();
00778: astFactory.addASTChild(currentAST, returnAST);
00779: nls();
00780: } else {
00781: break _loop79;
00782: }
00783:
00784: } while (true);
00785: }
00786: if (inputState.guessing == 0) {
00787: annotationsOpt_AST = (AST) currentAST.root;
00788: annotationsOpt_AST = (AST) astFactory
00789: .make((new ASTArray(2)).add(
00790: create(ANNOTATIONS, "ANNOTATIONS", first,
00791: LT(1))).add(annotationsOpt_AST));
00792: currentAST.root = annotationsOpt_AST;
00793: currentAST.child = annotationsOpt_AST != null
00794: && annotationsOpt_AST.getFirstChild() != null ? annotationsOpt_AST
00795: .getFirstChild()
00796: : annotationsOpt_AST;
00797: currentAST.advanceChildToEnd();
00798: }
00799: annotationsOpt_AST = (AST) currentAST.root;
00800: returnAST = annotationsOpt_AST;
00801: }
00802:
00803: public final void packageDefinition() throws RecognitionException,
00804: TokenStreamException {
00805:
00806: returnAST = null;
00807: ASTPair currentAST = new ASTPair();
00808: AST packageDefinition_AST = null;
00809: Token p = null;
00810: AST p_AST = null;
00811:
00812: annotationsOpt();
00813: astFactory.addASTChild(currentAST, returnAST);
00814: p = LT(1);
00815: p_AST = astFactory.create(p);
00816: astFactory.makeASTRoot(currentAST, p_AST);
00817: match(LITERAL_package);
00818: if (inputState.guessing == 0) {
00819: p_AST.setType(PACKAGE_DEF);
00820: }
00821: identifier();
00822: astFactory.addASTChild(currentAST, returnAST);
00823: packageDefinition_AST = (AST) currentAST.root;
00824: returnAST = packageDefinition_AST;
00825: }
00826:
00827: /** A statement is an element of a block.
00828: * Typical statements are declarations (which are scoped to the block)
00829: * and expressions.
00830: */
00831: public final void statement(int prevToken)
00832: throws RecognitionException, TokenStreamException {
00833:
00834: returnAST = null;
00835: ASTPair currentAST = new ASTPair();
00836: AST statement_AST = null;
00837: AST pfx_AST = null;
00838: AST m_AST = null;
00839: Token sp = null;
00840: AST sp_AST = null;
00841:
00842: switch (LA(1)) {
00843: case LITERAL_if: {
00844: AST tmp4_AST = null;
00845: tmp4_AST = astFactory.create(LT(1));
00846: astFactory.makeASTRoot(currentAST, tmp4_AST);
00847: match(LITERAL_if);
00848: match(LPAREN);
00849: assignmentLessExpression();
00850: astFactory.addASTChild(currentAST, returnAST);
00851: match(RPAREN);
00852: nlsWarn();
00853: compatibleBodyStatement();
00854: astFactory.addASTChild(currentAST, returnAST);
00855: {
00856: boolean synPredMatched251 = false;
00857: if (((_tokenSet_6.member(LA(1)))
00858: && (_tokenSet_7.member(LA(2))) && (_tokenSet_8
00859: .member(LA(3))))) {
00860: int _m251 = mark();
00861: synPredMatched251 = true;
00862: inputState.guessing++;
00863: try {
00864: {
00865: {
00866: switch (LA(1)) {
00867: case SEMI:
00868: case NLS: {
00869: sep();
00870: break;
00871: }
00872: case LITERAL_else: {
00873: break;
00874: }
00875: default: {
00876: throw new NoViableAltException(
00877: LT(1), getFilename());
00878: }
00879: }
00880: }
00881: match(LITERAL_else);
00882: }
00883: } catch (RecognitionException pe) {
00884: synPredMatched251 = false;
00885: }
00886: rewind(_m251);
00887: inputState.guessing--;
00888: }
00889: if (synPredMatched251) {
00890: {
00891: switch (LA(1)) {
00892: case SEMI:
00893: case NLS: {
00894: sep();
00895: break;
00896: }
00897: case LITERAL_else: {
00898: break;
00899: }
00900: default: {
00901: throw new NoViableAltException(LT(1),
00902: getFilename());
00903: }
00904: }
00905: }
00906: match(LITERAL_else);
00907: nlsWarn();
00908: compatibleBodyStatement();
00909: astFactory.addASTChild(currentAST, returnAST);
00910: } else if ((_tokenSet_9.member(LA(1)))
00911: && (_tokenSet_10.member(LA(2)))
00912: && (_tokenSet_11.member(LA(3)))) {
00913: } else {
00914: throw new NoViableAltException(LT(1), getFilename());
00915: }
00916:
00917: }
00918: statement_AST = (AST) currentAST.root;
00919: break;
00920: }
00921: case LITERAL_for: {
00922: forStatement();
00923: astFactory.addASTChild(currentAST, returnAST);
00924: statement_AST = (AST) currentAST.root;
00925: break;
00926: }
00927: case LITERAL_while: {
00928: AST tmp8_AST = null;
00929: tmp8_AST = astFactory.create(LT(1));
00930: astFactory.makeASTRoot(currentAST, tmp8_AST);
00931: match(LITERAL_while);
00932: match(LPAREN);
00933: strictContextExpression();
00934: astFactory.addASTChild(currentAST, returnAST);
00935: match(RPAREN);
00936: nlsWarn();
00937: compatibleBodyStatement();
00938: astFactory.addASTChild(currentAST, returnAST);
00939: statement_AST = (AST) currentAST.root;
00940: break;
00941: }
00942: case LITERAL_with: {
00943: AST tmp11_AST = null;
00944: tmp11_AST = astFactory.create(LT(1));
00945: astFactory.makeASTRoot(currentAST, tmp11_AST);
00946: match(LITERAL_with);
00947: match(LPAREN);
00948: strictContextExpression();
00949: astFactory.addASTChild(currentAST, returnAST);
00950: match(RPAREN);
00951: nlsWarn();
00952: compoundStatement();
00953: astFactory.addASTChild(currentAST, returnAST);
00954: statement_AST = (AST) currentAST.root;
00955: break;
00956: }
00957: case STAR: {
00958: sp = LT(1);
00959: sp_AST = astFactory.create(sp);
00960: astFactory.makeASTRoot(currentAST, sp_AST);
00961: match(STAR);
00962: nls();
00963: if (inputState.guessing == 0) {
00964: sp_AST.setType(SPREAD_ARG);
00965: }
00966: expressionStatement(EOF);
00967: astFactory.addASTChild(currentAST, returnAST);
00968: statement_AST = (AST) currentAST.root;
00969: break;
00970: }
00971: case LITERAL_import: {
00972: importStatement();
00973: astFactory.addASTChild(currentAST, returnAST);
00974: statement_AST = (AST) currentAST.root;
00975: break;
00976: }
00977: case LITERAL_switch: {
00978: AST tmp14_AST = null;
00979: tmp14_AST = astFactory.create(LT(1));
00980: astFactory.makeASTRoot(currentAST, tmp14_AST);
00981: match(LITERAL_switch);
00982: match(LPAREN);
00983: strictContextExpression();
00984: astFactory.addASTChild(currentAST, returnAST);
00985: match(RPAREN);
00986: nlsWarn();
00987: match(LCURLY);
00988: nls();
00989: {
00990: _loop254: do {
00991: if ((LA(1) == LITERAL_default || LA(1) == LITERAL_case)) {
00992: casesGroup();
00993: astFactory.addASTChild(currentAST, returnAST);
00994: } else {
00995: break _loop254;
00996: }
00997:
00998: } while (true);
00999: }
01000: match(RCURLY);
01001: statement_AST = (AST) currentAST.root;
01002: break;
01003: }
01004: case LITERAL_try: {
01005: tryBlock();
01006: astFactory.addASTChild(currentAST, returnAST);
01007: statement_AST = (AST) currentAST.root;
01008: break;
01009: }
01010: case LITERAL_return:
01011: case LITERAL_break:
01012: case LITERAL_continue:
01013: case LITERAL_throw:
01014: case LITERAL_assert: {
01015: branchStatement();
01016: astFactory.addASTChild(currentAST, returnAST);
01017: statement_AST = (AST) currentAST.root;
01018: break;
01019: }
01020: default:
01021: boolean synPredMatched242 = false;
01022: if (((_tokenSet_12.member(LA(1)))
01023: && (_tokenSet_13.member(LA(2))) && (_tokenSet_14
01024: .member(LA(3))))) {
01025: int _m242 = mark();
01026: synPredMatched242 = true;
01027: inputState.guessing++;
01028: try {
01029: {
01030: declarationStart();
01031: }
01032: } catch (RecognitionException pe) {
01033: synPredMatched242 = false;
01034: }
01035: rewind(_m242);
01036: inputState.guessing--;
01037: }
01038: if (synPredMatched242) {
01039: declaration();
01040: astFactory.addASTChild(currentAST, returnAST);
01041: statement_AST = (AST) currentAST.root;
01042: } else {
01043: boolean synPredMatched244 = false;
01044: if (((LA(1) == IDENT) && (LA(2) == COLON) && (_tokenSet_15
01045: .member(LA(3))))) {
01046: int _m244 = mark();
01047: synPredMatched244 = true;
01048: inputState.guessing++;
01049: try {
01050: {
01051: match(IDENT);
01052: match(COLON);
01053: }
01054: } catch (RecognitionException pe) {
01055: synPredMatched244 = false;
01056: }
01057: rewind(_m244);
01058: inputState.guessing--;
01059: }
01060: if (synPredMatched244) {
01061: statementLabelPrefix();
01062: pfx_AST = (AST) returnAST;
01063: if (inputState.guessing == 0) {
01064: statement_AST = (AST) currentAST.root;
01065: statement_AST = pfx_AST;
01066: currentAST.root = statement_AST;
01067: currentAST.child = statement_AST != null
01068: && statement_AST.getFirstChild() != null ? statement_AST
01069: .getFirstChild()
01070: : statement_AST;
01071: currentAST.advanceChildToEnd();
01072: }
01073: {
01074: boolean synPredMatched247 = false;
01075: if (((LA(1) == LCURLY)
01076: && (_tokenSet_16.member(LA(2))) && (_tokenSet_8
01077: .member(LA(3))))) {
01078: int _m247 = mark();
01079: synPredMatched247 = true;
01080: inputState.guessing++;
01081: try {
01082: {
01083: match(LCURLY);
01084: }
01085: } catch (RecognitionException pe) {
01086: synPredMatched247 = false;
01087: }
01088: rewind(_m247);
01089: inputState.guessing--;
01090: }
01091: if (synPredMatched247) {
01092: openOrClosableBlock();
01093: astFactory.addASTChild(currentAST,
01094: returnAST);
01095: } else if ((_tokenSet_17.member(LA(1)))
01096: && (_tokenSet_8.member(LA(2)))
01097: && (_tokenSet_18.member(LA(3)))) {
01098: statement(COLON);
01099: astFactory.addASTChild(currentAST,
01100: returnAST);
01101: } else {
01102: throw new NoViableAltException(LT(1),
01103: getFilename());
01104: }
01105:
01106: }
01107: statement_AST = (AST) currentAST.root;
01108: } else if ((_tokenSet_19.member(LA(1)))
01109: && (_tokenSet_8.member(LA(2)))
01110: && (_tokenSet_20.member(LA(3)))) {
01111: expressionStatement(prevToken);
01112: astFactory.addASTChild(currentAST, returnAST);
01113: statement_AST = (AST) currentAST.root;
01114: } else if ((_tokenSet_21.member(LA(1)))
01115: && (_tokenSet_22.member(LA(2)))
01116: && (_tokenSet_23.member(LA(3)))) {
01117: modifiersOpt();
01118: m_AST = (AST) returnAST;
01119: typeDefinitionInternal(m_AST);
01120: astFactory.addASTChild(currentAST, returnAST);
01121: statement_AST = (AST) currentAST.root;
01122: } else if ((LA(1) == LITERAL_synchronized)
01123: && (LA(2) == LPAREN)) {
01124: AST tmp19_AST = null;
01125: tmp19_AST = astFactory.create(LT(1));
01126: astFactory.makeASTRoot(currentAST, tmp19_AST);
01127: match(LITERAL_synchronized);
01128: match(LPAREN);
01129: strictContextExpression();
01130: astFactory.addASTChild(currentAST, returnAST);
01131: match(RPAREN);
01132: nlsWarn();
01133: compoundStatement();
01134: astFactory.addASTChild(currentAST, returnAST);
01135: statement_AST = (AST) currentAST.root;
01136: } else {
01137: throw new NoViableAltException(LT(1), getFilename());
01138: }
01139: }
01140: }
01141: returnAST = statement_AST;
01142: }
01143:
01144: /** A statement separator is either a semicolon or a significant newline.
01145: * Any number of additional (insignificant) newlines may accompany it.
01146: */
01147: public final void sep() throws RecognitionException,
01148: TokenStreamException {
01149:
01150: returnAST = null;
01151: ASTPair currentAST = new ASTPair();
01152: AST sep_AST = null;
01153:
01154: switch (LA(1)) {
01155: case SEMI: {
01156: match(SEMI);
01157: {
01158: _loop475: do {
01159: if ((LA(1) == NLS) && (_tokenSet_24.member(LA(2)))
01160: && (_tokenSet_20.member(LA(3)))) {
01161: match(NLS);
01162: } else {
01163: break _loop475;
01164: }
01165:
01166: } while (true);
01167: }
01168: if (inputState.guessing == 0) {
01169: sepToken = SEMI;
01170: }
01171: break;
01172: }
01173: case NLS: {
01174: match(NLS);
01175: if (inputState.guessing == 0) {
01176: sepToken = NLS;
01177: }
01178: {
01179: _loop479: do {
01180: if ((LA(1) == SEMI) && (_tokenSet_24.member(LA(2)))
01181: && (_tokenSet_20.member(LA(3)))) {
01182: match(SEMI);
01183: {
01184: _loop478: do {
01185: if ((LA(1) == NLS)
01186: && (_tokenSet_24.member(LA(2)))
01187: && (_tokenSet_20.member(LA(3)))) {
01188: match(NLS);
01189: } else {
01190: break _loop478;
01191: }
01192:
01193: } while (true);
01194: }
01195: if (inputState.guessing == 0) {
01196: sepToken = SEMI;
01197: }
01198: } else {
01199: break _loop479;
01200: }
01201:
01202: } while (true);
01203: }
01204: break;
01205: }
01206: default: {
01207: throw new NoViableAltException(LT(1), getFilename());
01208: }
01209: }
01210: returnAST = sep_AST;
01211: }
01212:
01213: /** A Groovy script or simple expression. Can be anything legal inside {...}. */
01214: public final void snippetUnit() throws RecognitionException,
01215: TokenStreamException {
01216:
01217: returnAST = null;
01218: ASTPair currentAST = new ASTPair();
01219: AST snippetUnit_AST = null;
01220:
01221: nls();
01222: blockBody(EOF);
01223: astFactory.addASTChild(currentAST, returnAST);
01224: snippetUnit_AST = (AST) currentAST.root;
01225: returnAST = snippetUnit_AST;
01226: }
01227:
01228: /** A block body is a parade of zero or more statements or expressions. */
01229: public final void blockBody(int prevToken)
01230: throws RecognitionException, TokenStreamException {
01231:
01232: returnAST = null;
01233: ASTPair currentAST = new ASTPair();
01234: AST blockBody_AST = null;
01235:
01236: {
01237: switch (LA(1)) {
01238: case FINAL:
01239: case ABSTRACT:
01240: case STRICTFP:
01241: case LITERAL_import:
01242: case LITERAL_static:
01243: case LITERAL_def:
01244: case AT:
01245: case IDENT:
01246: case LBRACK:
01247: case LPAREN:
01248: case LITERAL_class:
01249: case LITERAL_interface:
01250: case LITERAL_enum:
01251: case LITERAL_super :
01252: case LITERAL_void:
01253: case LITERAL_boolean:
01254: case LITERAL_byte:
01255: case LITERAL_char:
01256: case LITERAL_short:
01257: case LITERAL_int:
01258: case LITERAL_float:
01259: case LITERAL_long:
01260: case LITERAL_double:
01261: case LITERAL_any:
01262: case STAR:
01263: case LITERAL_private:
01264: case LITERAL_public:
01265: case LITERAL_protected:
01266: case LITERAL_transient:
01267: case LITERAL_native:
01268: case LITERAL_threadsafe:
01269: case LITERAL_synchronized:
01270: case LITERAL_volatile:
01271: case LCURLY:
01272: case LITERAL_this :
01273: case STRING_LITERAL:
01274: case LITERAL_if:
01275: case LITERAL_while:
01276: case LITERAL_with:
01277: case LITERAL_switch:
01278: case LITERAL_for:
01279: case LITERAL_return:
01280: case LITERAL_break:
01281: case LITERAL_continue:
01282: case LITERAL_throw:
01283: case LITERAL_assert:
01284: case PLUS:
01285: case MINUS:
01286: case LITERAL_try:
01287: case INC:
01288: case DEC:
01289: case BNOT:
01290: case LNOT:
01291: case DOLLAR:
01292: case STRING_CTOR_START:
01293: case LITERAL_new:
01294: case LITERAL_true:
01295: case LITERAL_false:
01296: case LITERAL_null:
01297: case NUM_INT:
01298: case NUM_FLOAT:
01299: case NUM_LONG:
01300: case NUM_DOUBLE:
01301: case NUM_BIG_INT:
01302: case NUM_BIG_DECIMAL: {
01303: statement(prevToken);
01304: astFactory.addASTChild(currentAST, returnAST);
01305: break;
01306: }
01307: case EOF:
01308: case RCURLY:
01309: case SEMI:
01310: case NLS: {
01311: break;
01312: }
01313: default: {
01314: throw new NoViableAltException(LT(1), getFilename());
01315: }
01316: }
01317: }
01318: {
01319: _loop236: do {
01320: if ((LA(1) == SEMI || LA(1) == NLS)) {
01321: sep();
01322: {
01323: switch (LA(1)) {
01324: case FINAL:
01325: case ABSTRACT:
01326: case STRICTFP:
01327: case LITERAL_import:
01328: case LITERAL_static:
01329: case LITERAL_def:
01330: case AT:
01331: case IDENT:
01332: case LBRACK:
01333: case LPAREN:
01334: case LITERAL_class:
01335: case LITERAL_interface:
01336: case LITERAL_enum:
01337: case LITERAL_super :
01338: case LITERAL_void:
01339: case LITERAL_boolean:
01340: case LITERAL_byte:
01341: case LITERAL_char:
01342: case LITERAL_short:
01343: case LITERAL_int:
01344: case LITERAL_float:
01345: case LITERAL_long:
01346: case LITERAL_double:
01347: case LITERAL_any:
01348: case STAR:
01349: case LITERAL_private:
01350: case LITERAL_public:
01351: case LITERAL_protected:
01352: case LITERAL_transient:
01353: case LITERAL_native:
01354: case LITERAL_threadsafe:
01355: case LITERAL_synchronized:
01356: case LITERAL_volatile:
01357: case LCURLY:
01358: case LITERAL_this :
01359: case STRING_LITERAL:
01360: case LITERAL_if:
01361: case LITERAL_while:
01362: case LITERAL_with:
01363: case LITERAL_switch:
01364: case LITERAL_for:
01365: case LITERAL_return:
01366: case LITERAL_break:
01367: case LITERAL_continue:
01368: case LITERAL_throw:
01369: case LITERAL_assert:
01370: case PLUS:
01371: case MINUS:
01372: case LITERAL_try:
01373: case INC:
01374: case DEC:
01375: case BNOT:
01376: case LNOT:
01377: case DOLLAR:
01378: case STRING_CTOR_START:
01379: case LITERAL_new:
01380: case LITERAL_true:
01381: case LITERAL_false:
01382: case LITERAL_null:
01383: case NUM_INT:
01384: case NUM_FLOAT:
01385: case NUM_LONG:
01386: case NUM_DOUBLE:
01387: case NUM_BIG_INT:
01388: case NUM_BIG_DECIMAL: {
01389: statement(sepToken);
01390: astFactory.addASTChild(currentAST,
01391: returnAST);
01392: break;
01393: }
01394: case EOF:
01395: case RCURLY:
01396: case SEMI:
01397: case NLS: {
01398: break;
01399: }
01400: default: {
01401: throw new NoViableAltException(LT(1),
01402: getFilename());
01403: }
01404: }
01405: }
01406: } else {
01407: break _loop236;
01408: }
01409:
01410: } while (true);
01411: }
01412: blockBody_AST = (AST) currentAST.root;
01413: returnAST = blockBody_AST;
01414: }
01415:
01416: public final void identifier() throws RecognitionException,
01417: TokenStreamException {
01418:
01419: returnAST = null;
01420: ASTPair currentAST = new ASTPair();
01421: AST identifier_AST = null;
01422:
01423: AST tmp27_AST = null;
01424: tmp27_AST = astFactory.create(LT(1));
01425: astFactory.addASTChild(currentAST, tmp27_AST);
01426: match(IDENT);
01427: {
01428: _loop62: do {
01429: if ((LA(1) == DOT)) {
01430: AST tmp28_AST = null;
01431: tmp28_AST = astFactory.create(LT(1));
01432: astFactory.makeASTRoot(currentAST, tmp28_AST);
01433: match(DOT);
01434: nls();
01435: AST tmp29_AST = null;
01436: tmp29_AST = astFactory.create(LT(1));
01437: astFactory.addASTChild(currentAST, tmp29_AST);
01438: match(IDENT);
01439: } else {
01440: break _loop62;
01441: }
01442:
01443: } while (true);
01444: }
01445: identifier_AST = (AST) currentAST.root;
01446: returnAST = identifier_AST;
01447: }
01448:
01449: public final void importStatement() throws RecognitionException,
01450: TokenStreamException {
01451:
01452: returnAST = null;
01453: ASTPair currentAST = new ASTPair();
01454: AST importStatement_AST = null;
01455: Token i = null;
01456: AST i_AST = null;
01457: boolean isStatic = false;
01458:
01459: i = LT(1);
01460: i_AST = astFactory.create(i);
01461: astFactory.makeASTRoot(currentAST, i_AST);
01462: match(LITERAL_import);
01463: if (inputState.guessing == 0) {
01464: i_AST.setType(IMPORT);
01465: }
01466: {
01467: switch (LA(1)) {
01468: case LITERAL_static: {
01469: match(LITERAL_static);
01470: if (inputState.guessing == 0) {
01471: i_AST.setType(STATIC_IMPORT);
01472: }
01473: break;
01474: }
01475: case IDENT: {
01476: break;
01477: }
01478: default: {
01479: throw new NoViableAltException(LT(1), getFilename());
01480: }
01481: }
01482: }
01483: identifierStar();
01484: astFactory.addASTChild(currentAST, returnAST);
01485: importStatement_AST = (AST) currentAST.root;
01486: returnAST = importStatement_AST;
01487: }
01488:
01489: public final void identifierStar() throws RecognitionException,
01490: TokenStreamException {
01491:
01492: returnAST = null;
01493: ASTPair currentAST = new ASTPair();
01494: AST identifierStar_AST = null;
01495:
01496: AST tmp31_AST = null;
01497: tmp31_AST = astFactory.create(LT(1));
01498: astFactory.addASTChild(currentAST, tmp31_AST);
01499: match(IDENT);
01500: {
01501: _loop65: do {
01502: if ((LA(1) == DOT) && (LA(2) == IDENT || LA(2) == NLS)
01503: && (_tokenSet_25.member(LA(3)))) {
01504: AST tmp32_AST = null;
01505: tmp32_AST = astFactory.create(LT(1));
01506: astFactory.makeASTRoot(currentAST, tmp32_AST);
01507: match(DOT);
01508: nls();
01509: AST tmp33_AST = null;
01510: tmp33_AST = astFactory.create(LT(1));
01511: astFactory.addASTChild(currentAST, tmp33_AST);
01512: match(IDENT);
01513: } else {
01514: break _loop65;
01515: }
01516:
01517: } while (true);
01518: }
01519: {
01520: switch (LA(1)) {
01521: case DOT: {
01522: AST tmp34_AST = null;
01523: tmp34_AST = astFactory.create(LT(1));
01524: astFactory.makeASTRoot(currentAST, tmp34_AST);
01525: match(DOT);
01526: nls();
01527: AST tmp35_AST = null;
01528: tmp35_AST = astFactory.create(LT(1));
01529: astFactory.addASTChild(currentAST, tmp35_AST);
01530: match(STAR);
01531: break;
01532: }
01533: case LITERAL_as: {
01534: AST tmp36_AST = null;
01535: tmp36_AST = astFactory.create(LT(1));
01536: astFactory.makeASTRoot(currentAST, tmp36_AST);
01537: match(LITERAL_as);
01538: nls();
01539: AST tmp37_AST = null;
01540: tmp37_AST = astFactory.create(LT(1));
01541: astFactory.addASTChild(currentAST, tmp37_AST);
01542: match(IDENT);
01543: break;
01544: }
01545: case EOF:
01546: case RCURLY:
01547: case SEMI:
01548: case NLS:
01549: case LITERAL_default:
01550: case LITERAL_else:
01551: case LITERAL_case: {
01552: break;
01553: }
01554: default: {
01555: throw new NoViableAltException(LT(1), getFilename());
01556: }
01557: }
01558: }
01559: identifierStar_AST = (AST) currentAST.root;
01560: returnAST = identifierStar_AST;
01561: }
01562:
01563: protected final void typeDefinitionInternal(AST mods)
01564: throws RecognitionException, TokenStreamException {
01565:
01566: returnAST = null;
01567: ASTPair currentAST = new ASTPair();
01568: AST typeDefinitionInternal_AST = null;
01569: AST cd_AST = null;
01570: AST id_AST = null;
01571: AST ed_AST = null;
01572: AST ad_AST = null;
01573:
01574: switch (LA(1)) {
01575: case LITERAL_class: {
01576: classDefinition(mods);
01577: cd_AST = (AST) returnAST;
01578: astFactory.addASTChild(currentAST, returnAST);
01579: if (inputState.guessing == 0) {
01580: typeDefinitionInternal_AST = (AST) currentAST.root;
01581: typeDefinitionInternal_AST = cd_AST;
01582: currentAST.root = typeDefinitionInternal_AST;
01583: currentAST.child = typeDefinitionInternal_AST != null
01584: && typeDefinitionInternal_AST.getFirstChild() != null ? typeDefinitionInternal_AST
01585: .getFirstChild()
01586: : typeDefinitionInternal_AST;
01587: currentAST.advanceChildToEnd();
01588: }
01589: typeDefinitionInternal_AST = (AST) currentAST.root;
01590: break;
01591: }
01592: case LITERAL_interface: {
01593: interfaceDefinition(mods);
01594: id_AST = (AST) returnAST;
01595: astFactory.addASTChild(currentAST, returnAST);
01596: if (inputState.guessing == 0) {
01597: typeDefinitionInternal_AST = (AST) currentAST.root;
01598: typeDefinitionInternal_AST = id_AST;
01599: currentAST.root = typeDefinitionInternal_AST;
01600: currentAST.child = typeDefinitionInternal_AST != null
01601: && typeDefinitionInternal_AST.getFirstChild() != null ? typeDefinitionInternal_AST
01602: .getFirstChild()
01603: : typeDefinitionInternal_AST;
01604: currentAST.advanceChildToEnd();
01605: }
01606: typeDefinitionInternal_AST = (AST) currentAST.root;
01607: break;
01608: }
01609: case LITERAL_enum: {
01610: enumDefinition(mods);
01611: ed_AST = (AST) returnAST;
01612: astFactory.addASTChild(currentAST, returnAST);
01613: if (inputState.guessing == 0) {
01614: typeDefinitionInternal_AST = (AST) currentAST.root;
01615: typeDefinitionInternal_AST = ed_AST;
01616: currentAST.root = typeDefinitionInternal_AST;
01617: currentAST.child = typeDefinitionInternal_AST != null
01618: && typeDefinitionInternal_AST.getFirstChild() != null ? typeDefinitionInternal_AST
01619: .getFirstChild()
01620: : typeDefinitionInternal_AST;
01621: currentAST.advanceChildToEnd();
01622: }
01623: typeDefinitionInternal_AST = (AST) currentAST.root;
01624: break;
01625: }
01626: case AT: {
01627: annotationDefinition(mods);
01628: ad_AST = (AST) returnAST;
01629: astFactory.addASTChild(currentAST, returnAST);
01630: if (inputState.guessing == 0) {
01631: typeDefinitionInternal_AST = (AST) currentAST.root;
01632: typeDefinitionInternal_AST = ad_AST;
01633: currentAST.root = typeDefinitionInternal_AST;
01634: currentAST.child = typeDefinitionInternal_AST != null
01635: && typeDefinitionInternal_AST.getFirstChild() != null ? typeDefinitionInternal_AST
01636: .getFirstChild()
01637: : typeDefinitionInternal_AST;
01638: currentAST.advanceChildToEnd();
01639: }
01640: typeDefinitionInternal_AST = (AST) currentAST.root;
01641: break;
01642: }
01643: default: {
01644: throw new NoViableAltException(LT(1), getFilename());
01645: }
01646: }
01647: returnAST = typeDefinitionInternal_AST;
01648: }
01649:
01650: public final void classDefinition(AST modifiers)
01651: throws RecognitionException, TokenStreamException {
01652:
01653: returnAST = null;
01654: ASTPair currentAST = new ASTPair();
01655: AST classDefinition_AST = null;
01656: AST tp_AST = null;
01657: AST sc_AST = null;
01658: AST ic_AST = null;
01659: AST cb_AST = null;
01660: Token first = LT(1);
01661: AST prevCurrentClass = currentClass;
01662:
01663: match(LITERAL_class);
01664: AST tmp39_AST = null;
01665: tmp39_AST = astFactory.create(LT(1));
01666: match(IDENT);
01667: nls();
01668: if (inputState.guessing == 0) {
01669: currentClass = tmp39_AST;
01670: }
01671: {
01672: switch (LA(1)) {
01673: case LT: {
01674: typeParameters();
01675: tp_AST = (AST) returnAST;
01676: break;
01677: }
01678: case LITERAL_extends:
01679: case LCURLY:
01680: case LITERAL_implements : {
01681: break;
01682: }
01683: default: {
01684: throw new NoViableAltException(LT(1), getFilename());
01685: }
01686: }
01687: }
01688: super ClassClause();
01689: sc_AST = (AST) returnAST;
01690: implements Clause();
01691: ic_AST = (AST) returnAST;
01692: classBlock();
01693: cb_AST = (AST) returnAST;
01694: if (inputState.guessing == 0) {
01695: classDefinition_AST = (AST) currentAST.root;
01696: classDefinition_AST = (AST) astFactory
01697: .make((new ASTArray(7))
01698: .add(
01699: create(CLASS_DEF, "CLASS_DEF",
01700: first, LT(1))).add(
01701: modifiers).add(tmp39_AST).add(
01702: tp_AST).add(sc_AST).add(ic_AST)
01703: .add(cb_AST));
01704: currentAST.root = classDefinition_AST;
01705: currentAST.child = classDefinition_AST != null
01706: && classDefinition_AST.getFirstChild() != null ? classDefinition_AST
01707: .getFirstChild()
01708: : classDefinition_AST;
01709: currentAST.advanceChildToEnd();
01710: }
01711: if (inputState.guessing == 0) {
01712: currentClass = prevCurrentClass;
01713: }
01714: returnAST = classDefinition_AST;
01715: }
01716:
01717: public final void interfaceDefinition(AST modifiers)
01718: throws RecognitionException, TokenStreamException {
01719:
01720: returnAST = null;
01721: ASTPair currentAST = new ASTPair();
01722: AST interfaceDefinition_AST = null;
01723: AST tp_AST = null;
01724: AST ie_AST = null;
01725: AST ib_AST = null;
01726: Token first = LT(1);
01727:
01728: match(LITERAL_interface);
01729: AST tmp41_AST = null;
01730: tmp41_AST = astFactory.create(LT(1));
01731: match(IDENT);
01732: nls();
01733: {
01734: switch (LA(1)) {
01735: case LT: {
01736: typeParameters();
01737: tp_AST = (AST) returnAST;
01738: break;
01739: }
01740: case LITERAL_extends:
01741: case LCURLY: {
01742: break;
01743: }
01744: default: {
01745: throw new NoViableAltException(LT(1), getFilename());
01746: }
01747: }
01748: }
01749: interfaceExtends();
01750: ie_AST = (AST) returnAST;
01751: interfaceBlock();
01752: ib_AST = (AST) returnAST;
01753: if (inputState.guessing == 0) {
01754: interfaceDefinition_AST = (AST) currentAST.root;
01755: interfaceDefinition_AST = (AST) astFactory
01756: .make((new ASTArray(6)).add(
01757: create(INTERFACE_DEF, "INTERFACE_DEF",
01758: first, LT(1))).add(modifiers).add(
01759: tmp41_AST).add(tp_AST).add(ie_AST).add(
01760: ib_AST));
01761: currentAST.root = interfaceDefinition_AST;
01762: currentAST.child = interfaceDefinition_AST != null
01763: && interfaceDefinition_AST.getFirstChild() != null ? interfaceDefinition_AST
01764: .getFirstChild()
01765: : interfaceDefinition_AST;
01766: currentAST.advanceChildToEnd();
01767: }
01768: returnAST = interfaceDefinition_AST;
01769: }
01770:
01771: public final void enumDefinition(AST modifiers)
01772: throws RecognitionException, TokenStreamException {
01773:
01774: returnAST = null;
01775: ASTPair currentAST = new ASTPair();
01776: AST enumDefinition_AST = null;
01777: AST ic_AST = null;
01778: AST eb_AST = null;
01779: Token first = LT(1);
01780:
01781: match(LITERAL_enum);
01782: AST tmp43_AST = null;
01783: tmp43_AST = astFactory.create(LT(1));
01784: match(IDENT);
01785: implements Clause();
01786: ic_AST = (AST) returnAST;
01787: enumBlock();
01788: eb_AST = (AST) returnAST;
01789: if (inputState.guessing == 0) {
01790: enumDefinition_AST = (AST) currentAST.root;
01791: enumDefinition_AST = (AST) astFactory
01792: .make((new ASTArray(5)).add(
01793: create(ENUM_DEF, "ENUM_DEF", first, LT(1)))
01794: .add(modifiers).add(tmp43_AST).add(ic_AST)
01795: .add(eb_AST));
01796: currentAST.root = enumDefinition_AST;
01797: currentAST.child = enumDefinition_AST != null
01798: && enumDefinition_AST.getFirstChild() != null ? enumDefinition_AST
01799: .getFirstChild()
01800: : enumDefinition_AST;
01801: currentAST.advanceChildToEnd();
01802: }
01803: returnAST = enumDefinition_AST;
01804: }
01805:
01806: public final void annotationDefinition(AST modifiers)
01807: throws RecognitionException, TokenStreamException {
01808:
01809: returnAST = null;
01810: ASTPair currentAST = new ASTPair();
01811: AST annotationDefinition_AST = null;
01812: AST ab_AST = null;
01813: Token first = LT(1);
01814:
01815: AST tmp44_AST = null;
01816: tmp44_AST = astFactory.create(LT(1));
01817: match(AT);
01818: match(LITERAL_interface);
01819: AST tmp46_AST = null;
01820: tmp46_AST = astFactory.create(LT(1));
01821: match(IDENT);
01822: annotationBlock();
01823: ab_AST = (AST) returnAST;
01824: if (inputState.guessing == 0) {
01825: annotationDefinition_AST = (AST) currentAST.root;
01826: annotationDefinition_AST = (AST) astFactory
01827: .make((new ASTArray(4)).add(
01828: create(ANNOTATION_DEF, "ANNOTATION_DEF",
01829: first, LT(1))).add(modifiers).add(
01830: tmp46_AST).add(ab_AST));
01831: currentAST.root = annotationDefinition_AST;
01832: currentAST.child = annotationDefinition_AST != null
01833: && annotationDefinition_AST.getFirstChild() != null ? annotationDefinition_AST
01834: .getFirstChild()
01835: : annotationDefinition_AST;
01836: currentAST.advanceChildToEnd();
01837: }
01838: returnAST = annotationDefinition_AST;
01839: }
01840:
01841: /** A declaration is the creation of a reference or primitive-type variable,
01842: * or (if arguments are present) of a method.
01843: * Generically, this is called a 'variable' definition, even in the case of a class field or method.
01844: * It may start with the modifiers and/or a declaration keyword "def".
01845: * It may also start with the modifiers and a capitalized type name.
01846: * <p>
01847: * AST effect: Create a separate Type/Var tree for each var in the var list.
01848: * Must be guarded, as in (declarationStart) => declaration.
01849: */
01850: public final void declaration() throws RecognitionException,
01851: TokenStreamException {
01852:
01853: returnAST = null;
01854: ASTPair currentAST = new ASTPair();
01855: AST declaration_AST = null;
01856: AST m_AST = null;
01857: AST t_AST = null;
01858: AST v_AST = null;
01859: AST t2_AST = null;
01860: AST v2_AST = null;
01861:
01862: switch (LA(1)) {
01863: case FINAL:
01864: case ABSTRACT:
01865: case STRICTFP:
01866: case LITERAL_static:
01867: case LITERAL_def:
01868: case AT:
01869: case LITERAL_private:
01870: case LITERAL_public:
01871: case LITERAL_protected:
01872: case LITERAL_transient:
01873: case LITERAL_native:
01874: case LITERAL_threadsafe:
01875: case LITERAL_synchronized:
01876: case LITERAL_volatile: {
01877: modifiers();
01878: m_AST = (AST) returnAST;
01879: {
01880: if ((_tokenSet_26.member(LA(1)))
01881: && (_tokenSet_27.member(LA(2)))) {
01882: typeSpec(false);
01883: t_AST = (AST) returnAST;
01884: } else if ((LA(1) == IDENT || LA(1) == STRING_LITERAL)
01885: && (_tokenSet_28.member(LA(2)))) {
01886: } else {
01887: throw new NoViableAltException(LT(1), getFilename());
01888: }
01889:
01890: }
01891: variableDefinitions(m_AST, t_AST);
01892: v_AST = (AST) returnAST;
01893: if (inputState.guessing == 0) {
01894: declaration_AST = (AST) currentAST.root;
01895: declaration_AST = v_AST;
01896: currentAST.root = declaration_AST;
01897: currentAST.child = declaration_AST != null
01898: && declaration_AST.getFirstChild() != null ? declaration_AST
01899: .getFirstChild()
01900: : declaration_AST;
01901: currentAST.advanceChildToEnd();
01902: }
01903: break;
01904: }
01905: case IDENT:
01906: case LITERAL_void:
01907: case LITERAL_boolean:
01908: case LITERAL_byte:
01909: case LITERAL_char:
01910: case LITERAL_short:
01911: case LITERAL_int:
01912: case LITERAL_float:
01913: case LITERAL_long:
01914: case LITERAL_double:
01915: case LITERAL_any: {
01916: typeSpec(false);
01917: t2_AST = (AST) returnAST;
01918: variableDefinitions(null, t2_AST);
01919: v2_AST = (AST) returnAST;
01920: if (inputState.guessing == 0) {
01921: declaration_AST = (AST) currentAST.root;
01922: declaration_AST = v2_AST;
01923: currentAST.root = declaration_AST;
01924: currentAST.child = declaration_AST != null
01925: && declaration_AST.getFirstChild() != null ? declaration_AST
01926: .getFirstChild()
01927: : declaration_AST;
01928: currentAST.advanceChildToEnd();
01929: }
01930: break;
01931: }
01932: default: {
01933: throw new NoViableAltException(LT(1), getFilename());
01934: }
01935: }
01936: returnAST = declaration_AST;
01937: }
01938:
01939: /** A list of one or more modifier, annotation, or "def". */
01940: public final void modifiers() throws RecognitionException,
01941: TokenStreamException {
01942:
01943: returnAST = null;
01944: ASTPair currentAST = new ASTPair();
01945: AST modifiers_AST = null;
01946: Token first = LT(1);
01947:
01948: modifiersInternal();
01949: astFactory.addASTChild(currentAST, returnAST);
01950: if (inputState.guessing == 0) {
01951: modifiers_AST = (AST) currentAST.root;
01952: modifiers_AST = (AST) astFactory.make((new ASTArray(2))
01953: .add(create(MODIFIERS, "MODIFIERS", first, LT(1)))
01954: .add(modifiers_AST));
01955: currentAST.root = modifiers_AST;
01956: currentAST.child = modifiers_AST != null
01957: && modifiers_AST.getFirstChild() != null ? modifiers_AST
01958: .getFirstChild()
01959: : modifiers_AST;
01960: currentAST.advanceChildToEnd();
01961: }
01962: modifiers_AST = (AST) currentAST.root;
01963: returnAST = modifiers_AST;
01964: }
01965:
01966: public final void typeSpec(boolean addImagNode)
01967: throws RecognitionException, TokenStreamException {
01968:
01969: returnAST = null;
01970: ASTPair currentAST = new ASTPair();
01971: AST typeSpec_AST = null;
01972:
01973: switch (LA(1)) {
01974: case IDENT: {
01975: classTypeSpec(addImagNode);
01976: astFactory.addASTChild(currentAST, returnAST);
01977: typeSpec_AST = (AST) currentAST.root;
01978: break;
01979: }
01980: case LITERAL_void:
01981: case LITERAL_boolean:
01982: case LITERAL_byte:
01983: case LITERAL_char:
01984: case LITERAL_short:
01985: case LITERAL_int:
01986: case LITERAL_float:
01987: case LITERAL_long:
01988: case LITERAL_double:
01989: case LITERAL_any: {
01990: builtInTypeSpec(addImagNode);
01991: astFactory.addASTChild(currentAST, returnAST);
01992: typeSpec_AST = (AST) currentAST.root;
01993: break;
01994: }
01995: default: {
01996: throw new NoViableAltException(LT(1), getFilename());
01997: }
01998: }
01999: returnAST = typeSpec_AST;
02000: }
02001:
02002: /** The tail of a declaration.
02003: * Either v1, v2, ... (with possible initializers) or else m(args){body}.
02004: * The two arguments are the modifier list (if any) and the declaration head (if any).
02005: * The declaration head is the variable type, or (for a method) the return type.
02006: * If it is missing, then the variable type is taken from its initializer (if there is one).
02007: * Otherwise, the variable type defaults to 'any'.
02008: * DECIDE: Method return types default to the type of the method body, as an expression.
02009: */
02010: public final void variableDefinitions(AST mods, AST t)
02011: throws RecognitionException, TokenStreamException {
02012:
02013: returnAST = null;
02014: ASTPair currentAST = new ASTPair();
02015: AST variableDefinitions_AST = null;
02016: Token id = null;
02017: AST id_AST = null;
02018: Token qid = null;
02019: AST qid_AST = null;
02020: AST param_AST = null;
02021: AST tc_AST = null;
02022: AST mb_AST = null;
02023: Token first = LT(1);
02024:
02025: if ((LA(1) == IDENT) && (_tokenSet_29.member(LA(2)))) {
02026: variableDeclarator(getASTFactory().dupTree(mods),
02027: getASTFactory().dupTree(t));
02028: astFactory.addASTChild(currentAST, returnAST);
02029: {
02030: _loop190: do {
02031: if ((LA(1) == COMMA)) {
02032: match(COMMA);
02033: nls();
02034: variableDeclarator(getASTFactory()
02035: .dupTree(mods), getASTFactory()
02036: .dupTree(t));
02037: astFactory.addASTChild(currentAST, returnAST);
02038: } else {
02039: break _loop190;
02040: }
02041:
02042: } while (true);
02043: }
02044: variableDefinitions_AST = (AST) currentAST.root;
02045: } else if ((LA(1) == IDENT || LA(1) == STRING_LITERAL)
02046: && (LA(2) == LPAREN)) {
02047: {
02048: switch (LA(1)) {
02049: case IDENT: {
02050: id = LT(1);
02051: id_AST = astFactory.create(id);
02052: astFactory.addASTChild(currentAST, id_AST);
02053: match(IDENT);
02054: break;
02055: }
02056: case STRING_LITERAL: {
02057: qid = LT(1);
02058: qid_AST = astFactory.create(qid);
02059: astFactory.addASTChild(currentAST, qid_AST);
02060: match(STRING_LITERAL);
02061: if (inputState.guessing == 0) {
02062: qid_AST.setType(IDENT);
02063: }
02064: break;
02065: }
02066: default: {
02067: throw new NoViableAltException(LT(1), getFilename());
02068: }
02069: }
02070: }
02071: match(LPAREN);
02072: parameterDeclarationList();
02073: param_AST = (AST) returnAST;
02074: match(RPAREN);
02075: {
02076: boolean synPredMatched194 = false;
02077: if (((LA(1) == NLS || LA(1) == LITERAL_throws)
02078: && (_tokenSet_30.member(LA(2))) && (_tokenSet_31
02079: .member(LA(3))))) {
02080: int _m194 = mark();
02081: synPredMatched194 = true;
02082: inputState.guessing++;
02083: try {
02084: {
02085: nls();
02086: match(LITERAL_throws);
02087: }
02088: } catch (RecognitionException pe) {
02089: synPredMatched194 = false;
02090: }
02091: rewind(_m194);
02092: inputState.guessing--;
02093: }
02094: if (synPredMatched194) {
02095: throwsClause();
02096: tc_AST = (AST) returnAST;
02097: } else if ((_tokenSet_32.member(LA(1)))
02098: && (_tokenSet_10.member(LA(2)))
02099: && (_tokenSet_11.member(LA(3)))) {
02100: } else {
02101: throw new NoViableAltException(LT(1), getFilename());
02102: }
02103:
02104: }
02105: {
02106: boolean synPredMatched197 = false;
02107: if (((LA(1) == LCURLY || LA(1) == NLS)
02108: && (_tokenSet_33.member(LA(2))) && (_tokenSet_8
02109: .member(LA(3))))) {
02110: int _m197 = mark();
02111: synPredMatched197 = true;
02112: inputState.guessing++;
02113: try {
02114: {
02115: nls();
02116: match(LCURLY);
02117: }
02118: } catch (RecognitionException pe) {
02119: synPredMatched197 = false;
02120: }
02121: rewind(_m197);
02122: inputState.guessing--;
02123: }
02124: if (synPredMatched197) {
02125: {
02126: nlsWarn();
02127: openBlock();
02128: mb_AST = (AST) returnAST;
02129: }
02130: } else if ((_tokenSet_9.member(LA(1)))
02131: && (_tokenSet_10.member(LA(2)))
02132: && (_tokenSet_11.member(LA(3)))) {
02133: } else {
02134: throw new NoViableAltException(LT(1), getFilename());
02135: }
02136:
02137: }
02138: if (inputState.guessing == 0) {
02139: variableDefinitions_AST = (AST) currentAST.root;
02140: if (qid_AST != null)
02141: id_AST = qid_AST;
02142: variableDefinitions_AST = (AST) astFactory
02143: .make((new ASTArray(7)).add(
02144: create(METHOD_DEF, "METHOD_DEF", first,
02145: LT(1))).add(mods).add(
02146: (AST) astFactory.make((new ASTArray(2))
02147: .add(
02148: create(TYPE, "TYPE",
02149: first, LT(1)))
02150: .add(t))).add(id_AST).add(
02151: param_AST).add(tc_AST).add(mb_AST));
02152:
02153: currentAST.root = variableDefinitions_AST;
02154: currentAST.child = variableDefinitions_AST != null
02155: && variableDefinitions_AST.getFirstChild() != null ? variableDefinitions_AST
02156: .getFirstChild()
02157: : variableDefinitions_AST;
02158: currentAST.advanceChildToEnd();
02159: }
02160: variableDefinitions_AST = (AST) currentAST.root;
02161: } else {
02162: throw new NoViableAltException(LT(1), getFilename());
02163: }
02164:
02165: returnAST = variableDefinitions_AST;
02166: }
02167:
02168: /** A declaration with one declarator and no initialization, like a parameterDeclaration.
02169: * Used to parse loops like <code>for (int x in y)</code> (up to the <code>in</code> keyword).
02170: */
02171: public final void singleDeclarationNoInit()
02172: throws RecognitionException, TokenStreamException {
02173:
02174: returnAST = null;
02175: ASTPair currentAST = new ASTPair();
02176: AST singleDeclarationNoInit_AST = null;
02177: AST m_AST = null;
02178: AST t_AST = null;
02179: AST v_AST = null;
02180: AST t2_AST = null;
02181: AST v2_AST = null;
02182:
02183: switch (LA(1)) {
02184: case FINAL:
02185: case ABSTRACT:
02186: case STRICTFP:
02187: case LITERAL_static:
02188: case LITERAL_def:
02189: case AT:
02190: case LITERAL_private:
02191: case LITERAL_public:
02192: case LITERAL_protected:
02193: case LITERAL_transient:
02194: case LITERAL_native:
02195: case LITERAL_threadsafe:
02196: case LITERAL_synchronized:
02197: case LITERAL_volatile: {
02198: modifiers();
02199: m_AST = (AST) returnAST;
02200: {
02201: if ((_tokenSet_26.member(LA(1)))
02202: && (_tokenSet_34.member(LA(2)))) {
02203: typeSpec(false);
02204: t_AST = (AST) returnAST;
02205: } else if ((LA(1) == IDENT)
02206: && (_tokenSet_35.member(LA(2)))) {
02207: } else {
02208: throw new NoViableAltException(LT(1), getFilename());
02209: }
02210:
02211: }
02212: singleVariable(m_AST, t_AST);
02213: v_AST = (AST) returnAST;
02214: if (inputState.guessing == 0) {
02215: singleDeclarationNoInit_AST = (AST) currentAST.root;
02216: singleDeclarationNoInit_AST = v_AST;
02217: currentAST.root = singleDeclarationNoInit_AST;
02218: currentAST.child = singleDeclarationNoInit_AST != null
02219: && singleDeclarationNoInit_AST.getFirstChild() != null ? singleDeclarationNoInit_AST
02220: .getFirstChild()
02221: : singleDeclarationNoInit_AST;
02222: currentAST.advanceChildToEnd();
02223: }
02224: break;
02225: }
02226: case IDENT:
02227: case LITERAL_void:
02228: case LITERAL_boolean:
02229: case LITERAL_byte:
02230: case LITERAL_char:
02231: case LITERAL_short:
02232: case LITERAL_int:
02233: case LITERAL_float:
02234: case LITERAL_long:
02235: case LITERAL_double:
02236: case LITERAL_any: {
02237: typeSpec(false);
02238: t2_AST = (AST) returnAST;
02239: singleVariable(null, t2_AST);
02240: v2_AST = (AST) returnAST;
02241: if (inputState.guessing == 0) {
02242: singleDeclarationNoInit_AST = (AST) currentAST.root;
02243: singleDeclarationNoInit_AST = v2_AST;
02244: currentAST.root = singleDeclarationNoInit_AST;
02245: currentAST.child = singleDeclarationNoInit_AST != null
02246: && singleDeclarationNoInit_AST.getFirstChild() != null ? singleDeclarationNoInit_AST
02247: .getFirstChild()
02248: : singleDeclarationNoInit_AST;
02249: currentAST.advanceChildToEnd();
02250: }
02251: break;
02252: }
02253: default: {
02254: throw new NoViableAltException(LT(1), getFilename());
02255: }
02256: }
02257: returnAST = singleDeclarationNoInit_AST;
02258: }
02259:
02260: /** Used in cases where a declaration cannot have commas, or ends with the "in" operator instead of '='. */
02261: public final void singleVariable(AST mods, AST t)
02262: throws RecognitionException, TokenStreamException {
02263:
02264: returnAST = null;
02265: ASTPair currentAST = new ASTPair();
02266: AST singleVariable_AST = null;
02267: AST id_AST = null;
02268: Token first = LT(1);
02269:
02270: variableName();
02271: id_AST = (AST) returnAST;
02272: if (inputState.guessing == 0) {
02273: singleVariable_AST = (AST) currentAST.root;
02274: singleVariable_AST = (AST) astFactory
02275: .make((new ASTArray(4)).add(
02276: create(VARIABLE_DEF, "VARIABLE_DEF", first,
02277: LT(1))).add(mods).add(
02278: (AST) astFactory.make((new ASTArray(2))
02279: .add(
02280: create(TYPE, "TYPE", first,
02281: LT(1))).add(t)))
02282: .add(id_AST));
02283: currentAST.root = singleVariable_AST;
02284: currentAST.child = singleVariable_AST != null
02285: && singleVariable_AST.getFirstChild() != null ? singleVariable_AST
02286: .getFirstChild()
02287: : singleVariable_AST;
02288: currentAST.advanceChildToEnd();
02289: }
02290: returnAST = singleVariable_AST;
02291: }
02292:
02293: /** A declaration with one declarator and optional initialization, like a parameterDeclaration.
02294: * Used to parse declarations used for both binding and effect, in places like argument
02295: * lists and <code>while</code> statements.
02296: */
02297: public final void singleDeclaration() throws RecognitionException,
02298: TokenStreamException {
02299:
02300: returnAST = null;
02301: ASTPair currentAST = new ASTPair();
02302: AST singleDeclaration_AST = null;
02303: AST sd_AST = null;
02304:
02305: singleDeclarationNoInit();
02306: sd_AST = (AST) returnAST;
02307: if (inputState.guessing == 0) {
02308: singleDeclaration_AST = (AST) currentAST.root;
02309: singleDeclaration_AST = sd_AST;
02310: currentAST.root = singleDeclaration_AST;
02311: currentAST.child = singleDeclaration_AST != null
02312: && singleDeclaration_AST.getFirstChild() != null ? singleDeclaration_AST
02313: .getFirstChild()
02314: : singleDeclaration_AST;
02315: currentAST.advanceChildToEnd();
02316: }
02317: {
02318: switch (LA(1)) {
02319: case ASSIGN: {
02320: varInitializer();
02321: astFactory.addASTChild(currentAST, returnAST);
02322: break;
02323: }
02324: case RBRACK:
02325: case COMMA:
02326: case RPAREN:
02327: case SEMI: {
02328: break;
02329: }
02330: default: {
02331: throw new NoViableAltException(LT(1), getFilename());
02332: }
02333: }
02334: }
02335: singleDeclaration_AST = (AST) currentAST.root;
02336: returnAST = singleDeclaration_AST;
02337: }
02338:
02339: /** An assignment operator '=' followed by an expression. (Never empty.) */
02340: public final void varInitializer() throws RecognitionException,
02341: TokenStreamException {
02342:
02343: returnAST = null;
02344: ASTPair currentAST = new ASTPair();
02345: AST varInitializer_AST = null;
02346:
02347: AST tmp50_AST = null;
02348: tmp50_AST = astFactory.create(LT(1));
02349: astFactory.makeASTRoot(currentAST, tmp50_AST);
02350: match(ASSIGN);
02351: nls();
02352: expression(LC_INIT);
02353: astFactory.addASTChild(currentAST, returnAST);
02354: varInitializer_AST = (AST) currentAST.root;
02355: returnAST = varInitializer_AST;
02356: }
02357:
02358: /** Used only as a lookahead predicate, before diving in and parsing a declaration.
02359: * A declaration can be unambiguously introduced with "def", an annotation or a modifier token like "final".
02360: * It may also be introduced by a simple identifier whose first character is an uppercase letter,
02361: * as in {String x}. A declaration can also be introduced with a built in type like 'int' or 'void'.
02362: * Brackets (array and generic) are allowed, as in {List[] x} or {int[][] y}.
02363: * Anything else is parsed as a statement of some sort (expression or command).
02364: * <p>
02365: * (In the absence of explicit method-call parens, we assume a capitalized name is a type name.
02366: * Yes, this is a little hacky. Alternatives are to complicate the declaration or command
02367: * syntaxes, or to have the parser query the symbol table. Parse-time queries are evil.
02368: * And we want both {String x} and {println x}. So we need a syntactic razor-edge to slip
02369: * between 'println' and 'String'.)
02370: *
02371: * *TODO* The declarationStart production needs to be strengthened to recognize
02372: * things like {List<String> foo}.
02373: * Right now it only knows how to skip square brackets after the type, not
02374: * angle brackets.
02375: * This probably turns out to be tricky because of >> vs. > >. If so,
02376: * just put a TODO comment in.
02377: */
02378: public final void declarationStart() throws RecognitionException,
02379: TokenStreamException {
02380:
02381: returnAST = null;
02382: ASTPair currentAST = new ASTPair();
02383: AST declarationStart_AST = null;
02384:
02385: switch (LA(1)) {
02386: case LITERAL_def: {
02387: match(LITERAL_def);
02388: break;
02389: }
02390: case FINAL:
02391: case ABSTRACT:
02392: case STRICTFP:
02393: case LITERAL_static:
02394: case LITERAL_private:
02395: case LITERAL_public:
02396: case LITERAL_protected:
02397: case LITERAL_transient:
02398: case LITERAL_native:
02399: case LITERAL_threadsafe:
02400: case LITERAL_synchronized:
02401: case LITERAL_volatile: {
02402: modifier();
02403: break;
02404: }
02405: case AT: {
02406: AST tmp52_AST = null;
02407: tmp52_AST = astFactory.create(LT(1));
02408: match(AT);
02409: AST tmp53_AST = null;
02410: tmp53_AST = astFactory.create(LT(1));
02411: match(IDENT);
02412: break;
02413: }
02414: case IDENT:
02415: case LITERAL_void:
02416: case LITERAL_boolean:
02417: case LITERAL_byte:
02418: case LITERAL_char:
02419: case LITERAL_short:
02420: case LITERAL_int:
02421: case LITERAL_float:
02422: case LITERAL_long:
02423: case LITERAL_double:
02424: case LITERAL_any: {
02425: {
02426: if ((LA(1) == IDENT)
02427: && (LA(2) == IDENT || LA(2) == LBRACK)) {
02428: upperCaseIdent();
02429: } else if (((LA(1) >= LITERAL_void && LA(1) <= LITERAL_any))) {
02430: builtInType();
02431: } else if ((LA(1) == IDENT) && (LA(2) == DOT)) {
02432: qualifiedTypeName();
02433: } else {
02434: throw new NoViableAltException(LT(1), getFilename());
02435: }
02436:
02437: }
02438: {
02439: _loop24: do {
02440: if ((LA(1) == LBRACK)) {
02441: AST tmp54_AST = null;
02442: tmp54_AST = astFactory.create(LT(1));
02443: match(LBRACK);
02444: balancedTokens();
02445: AST tmp55_AST = null;
02446: tmp55_AST = astFactory.create(LT(1));
02447: match(RBRACK);
02448: } else {
02449: break _loop24;
02450: }
02451:
02452: } while (true);
02453: }
02454: AST tmp56_AST = null;
02455: tmp56_AST = astFactory.create(LT(1));
02456: match(IDENT);
02457: break;
02458: }
02459: default: {
02460: throw new NoViableAltException(LT(1), getFilename());
02461: }
02462: }
02463: returnAST = declarationStart_AST;
02464: }
02465:
02466: public final void modifier() throws RecognitionException,
02467: TokenStreamException {
02468:
02469: returnAST = null;
02470: ASTPair currentAST = new ASTPair();
02471: AST modifier_AST = null;
02472:
02473: switch (LA(1)) {
02474: case LITERAL_private: {
02475: AST tmp57_AST = null;
02476: tmp57_AST = astFactory.create(LT(1));
02477: astFactory.addASTChild(currentAST, tmp57_AST);
02478: match(LITERAL_private);
02479: modifier_AST = (AST) currentAST.root;
02480: break;
02481: }
02482: case LITERAL_public: {
02483: AST tmp58_AST = null;
02484: tmp58_AST = astFactory.create(LT(1));
02485: astFactory.addASTChild(currentAST, tmp58_AST);
02486: match(LITERAL_public);
02487: modifier_AST = (AST) currentAST.root;
02488: break;
02489: }
02490: case LITERAL_protected: {
02491: AST tmp59_AST = null;
02492: tmp59_AST = astFactory.create(LT(1));
02493: astFactory.addASTChild(currentAST, tmp59_AST);
02494: match(LITERAL_protected);
02495: modifier_AST = (AST) currentAST.root;
02496: break;
02497: }
02498: case LITERAL_static: {
02499: AST tmp60_AST = null;
02500: tmp60_AST = astFactory.create(LT(1));
02501: astFactory.addASTChild(currentAST, tmp60_AST);
02502: match(LITERAL_static);
02503: modifier_AST = (AST) currentAST.root;
02504: break;
02505: }
02506: case LITERAL_transient: {
02507: AST tmp61_AST = null;
02508: tmp61_AST = astFactory.create(LT(1));
02509: astFactory.addASTChild(currentAST, tmp61_AST);
02510: match(LITERAL_transient);
02511: modifier_AST = (AST) currentAST.root;
02512: break;
02513: }
02514: case FINAL: {
02515: AST tmp62_AST = null;
02516: tmp62_AST = astFactory.create(LT(1));
02517: astFactory.addASTChild(currentAST, tmp62_AST);
02518: match(FINAL);
02519: modifier_AST = (AST) currentAST.root;
02520: break;
02521: }
02522: case ABSTRACT: {
02523: AST tmp63_AST = null;
02524: tmp63_AST = astFactory.create(LT(1));
02525: astFactory.addASTChild(currentAST, tmp63_AST);
02526: match(ABSTRACT);
02527: modifier_AST = (AST) currentAST.root;
02528: break;
02529: }
02530: case LITERAL_native: {
02531: AST tmp64_AST = null;
02532: tmp64_AST = astFactory.create(LT(1));
02533: astFactory.addASTChild(currentAST, tmp64_AST);
02534: match(LITERAL_native);
02535: modifier_AST = (AST) currentAST.root;
02536: break;
02537: }
02538: case LITERAL_threadsafe: {
02539: AST tmp65_AST = null;
02540: tmp65_AST = astFactory.create(LT(1));
02541: astFactory.addASTChild(currentAST, tmp65_AST);
02542: match(LITERAL_threadsafe);
02543: modifier_AST = (AST) currentAST.root;
02544: break;
02545: }
02546: case LITERAL_synchronized: {
02547: AST tmp66_AST = null;
02548: tmp66_AST = astFactory.create(LT(1));
02549: astFactory.addASTChild(currentAST, tmp66_AST);
02550: match(LITERAL_synchronized);
02551: modifier_AST = (AST) currentAST.root;
02552: break;
02553: }
02554: case LITERAL_volatile: {
02555: AST tmp67_AST = null;
02556: tmp67_AST = astFactory.create(LT(1));
02557: astFactory.addASTChild(currentAST, tmp67_AST);
02558: match(LITERAL_volatile);
02559: modifier_AST = (AST) currentAST.root;
02560: break;
02561: }
02562: case STRICTFP: {
02563: AST tmp68_AST = null;
02564: tmp68_AST = astFactory.create(LT(1));
02565: astFactory.addASTChild(currentAST, tmp68_AST);
02566: match(STRICTFP);
02567: modifier_AST = (AST) currentAST.root;
02568: break;
02569: }
02570: default: {
02571: throw new NoViableAltException(LT(1), getFilename());
02572: }
02573: }
02574: returnAST = modifier_AST;
02575: }
02576:
02577: /** An IDENT token whose spelling is required to start with an uppercase letter.
02578: * In the case of a simple statement {UpperID name} the identifier is taken to be a type name, not a command name.
02579: */
02580: public final void upperCaseIdent() throws RecognitionException,
02581: TokenStreamException {
02582:
02583: returnAST = null;
02584: ASTPair currentAST = new ASTPair();
02585: AST upperCaseIdent_AST = null;
02586:
02587: if (!(isUpperCase(LT(1))))
02588: throw new SemanticException("isUpperCase(LT(1))");
02589: AST tmp69_AST = null;
02590: tmp69_AST = astFactory.create(LT(1));
02591: astFactory.addASTChild(currentAST, tmp69_AST);
02592: match(IDENT);
02593: upperCaseIdent_AST = (AST) currentAST.root;
02594: returnAST = upperCaseIdent_AST;
02595: }
02596:
02597: public final void builtInType() throws RecognitionException,
02598: TokenStreamException {
02599:
02600: returnAST = null;
02601: ASTPair currentAST = new ASTPair();
02602: AST builtInType_AST = null;
02603:
02604: switch (LA(1)) {
02605: case LITERAL_void: {
02606: AST tmp70_AST = null;
02607: tmp70_AST = astFactory.create(LT(1));
02608: astFactory.addASTChild(currentAST, tmp70_AST);
02609: match(LITERAL_void);
02610: builtInType_AST = (AST) currentAST.root;
02611: break;
02612: }
02613: case LITERAL_boolean: {
02614: AST tmp71_AST = null;
02615: tmp71_AST = astFactory.create(LT(1));
02616: astFactory.addASTChild(currentAST, tmp71_AST);
02617: match(LITERAL_boolean);
02618: builtInType_AST = (AST) currentAST.root;
02619: break;
02620: }
02621: case LITERAL_byte: {
02622: AST tmp72_AST = null;
02623: tmp72_AST = astFactory.create(LT(1));
02624: astFactory.addASTChild(currentAST, tmp72_AST);
02625: match(LITERAL_byte);
02626: builtInType_AST = (AST) currentAST.root;
02627: break;
02628: }
02629: case LITERAL_char: {
02630: AST tmp73_AST = null;
02631: tmp73_AST = astFactory.create(LT(1));
02632: astFactory.addASTChild(currentAST, tmp73_AST);
02633: match(LITERAL_char);
02634: builtInType_AST = (AST) currentAST.root;
02635: break;
02636: }
02637: case LITERAL_short: {
02638: AST tmp74_AST = null;
02639: tmp74_AST = astFactory.create(LT(1));
02640: astFactory.addASTChild(currentAST, tmp74_AST);
02641: match(LITERAL_short);
02642: builtInType_AST = (AST) currentAST.root;
02643: break;
02644: }
02645: case LITERAL_int: {
02646: AST tmp75_AST = null;
02647: tmp75_AST = astFactory.create(LT(1));
02648: astFactory.addASTChild(currentAST, tmp75_AST);
02649: match(LITERAL_int);
02650: builtInType_AST = (AST) currentAST.root;
02651: break;
02652: }
02653: case LITERAL_float: {
02654: AST tmp76_AST = null;
02655: tmp76_AST = astFactory.create(LT(1));
02656: astFactory.addASTChild(currentAST, tmp76_AST);
02657: match(LITERAL_float);
02658: builtInType_AST = (AST) currentAST.root;
02659: break;
02660: }
02661: case LITERAL_long: {
02662: AST tmp77_AST = null;
02663: tmp77_AST = astFactory.create(LT(1));
02664: astFactory.addASTChild(currentAST, tmp77_AST);
02665: match(LITERAL_long);
02666: builtInType_AST = (AST) currentAST.root;
02667: break;
02668: }
02669: case LITERAL_double: {
02670: AST tmp78_AST = null;
02671: tmp78_AST = astFactory.create(LT(1));
02672: astFactory.addASTChild(currentAST, tmp78_AST);
02673: match(LITERAL_double);
02674: builtInType_AST = (AST) currentAST.root;
02675: break;
02676: }
02677: case LITERAL_any: {
02678: AST tmp79_AST = null;
02679: tmp79_AST = astFactory.create(LT(1));
02680: astFactory.addASTChild(currentAST, tmp79_AST);
02681: match(LITERAL_any);
02682: builtInType_AST = (AST) currentAST.root;
02683: break;
02684: }
02685: default: {
02686: throw new NoViableAltException(LT(1), getFilename());
02687: }
02688: }
02689: returnAST = builtInType_AST;
02690: }
02691:
02692: /** Not yet used - but we could use something like this to look for fully qualified type names
02693: */
02694: public final void qualifiedTypeName() throws RecognitionException,
02695: TokenStreamException {
02696:
02697: returnAST = null;
02698: ASTPair currentAST = new ASTPair();
02699: AST qualifiedTypeName_AST = null;
02700:
02701: AST tmp80_AST = null;
02702: tmp80_AST = astFactory.create(LT(1));
02703: match(IDENT);
02704: {
02705: _loop27: do {
02706: if ((LA(1) == DOT) && (LA(2) == IDENT)
02707: && (LA(3) == DOT)) {
02708: AST tmp81_AST = null;
02709: tmp81_AST = astFactory.create(LT(1));
02710: match(DOT);
02711: AST tmp82_AST = null;
02712: tmp82_AST = astFactory.create(LT(1));
02713: match(IDENT);
02714: } else {
02715: break _loop27;
02716: }
02717:
02718: } while (true);
02719: }
02720: AST tmp83_AST = null;
02721: tmp83_AST = astFactory.create(LT(1));
02722: match(DOT);
02723: upperCaseIdent();
02724: returnAST = qualifiedTypeName_AST;
02725: }
02726:
02727: public final void balancedTokens() throws RecognitionException,
02728: TokenStreamException {
02729:
02730: returnAST = null;
02731: ASTPair currentAST = new ASTPair();
02732: AST balancedTokens_AST = null;
02733:
02734: {
02735: _loop472: do {
02736: if ((_tokenSet_36.member(LA(1)))) {
02737: balancedBrackets();
02738: } else if ((_tokenSet_37.member(LA(1)))) {
02739: {
02740: match(_tokenSet_37);
02741: }
02742: } else {
02743: break _loop472;
02744: }
02745:
02746: } while (true);
02747: }
02748: returnAST = balancedTokens_AST;
02749: }
02750:
02751: /** Used to look ahead for a constructor
02752: */
02753: public final void constructorStart() throws RecognitionException,
02754: TokenStreamException {
02755:
02756: returnAST = null;
02757: ASTPair currentAST = new ASTPair();
02758: AST constructorStart_AST = null;
02759: Token id = null;
02760: AST id_AST = null;
02761:
02762: modifiersOpt();
02763: id = LT(1);
02764: id_AST = astFactory.create(id);
02765: match(IDENT);
02766: if (!(isConstructorIdent(id)))
02767: throw new SemanticException("isConstructorIdent(id)");
02768: nls();
02769: match(LPAREN);
02770: returnAST = constructorStart_AST;
02771: }
02772:
02773: /** A list of zero or more modifiers, annotations, or "def". */
02774: public final void modifiersOpt() throws RecognitionException,
02775: TokenStreamException {
02776:
02777: returnAST = null;
02778: ASTPair currentAST = new ASTPair();
02779: AST modifiersOpt_AST = null;
02780: Token first = LT(1);
02781:
02782: {
02783: if ((_tokenSet_38.member(LA(1)))
02784: && (_tokenSet_39.member(LA(2)))
02785: && (_tokenSet_40.member(LA(3)))) {
02786: modifiersInternal();
02787: astFactory.addASTChild(currentAST, returnAST);
02788: } else if ((_tokenSet_41.member(LA(1)))
02789: && (_tokenSet_42.member(LA(2)))
02790: && (_tokenSet_43.member(LA(3)))) {
02791: } else {
02792: throw new NoViableAltException(LT(1), getFilename());
02793: }
02794:
02795: }
02796: if (inputState.guessing == 0) {
02797: modifiersOpt_AST = (AST) currentAST.root;
02798: modifiersOpt_AST = (AST) astFactory.make((new ASTArray(2))
02799: .add(create(MODIFIERS, "MODIFIERS", first, LT(1)))
02800: .add(modifiersOpt_AST));
02801: currentAST.root = modifiersOpt_AST;
02802: currentAST.child = modifiersOpt_AST != null
02803: && modifiersOpt_AST.getFirstChild() != null ? modifiersOpt_AST
02804: .getFirstChild()
02805: : modifiersOpt_AST;
02806: currentAST.advanceChildToEnd();
02807: }
02808: modifiersOpt_AST = (AST) currentAST.root;
02809: returnAST = modifiersOpt_AST;
02810: }
02811:
02812: /** Used only as a lookahead predicate for nested type declarations. */
02813: public final void typeDeclarationStart()
02814: throws RecognitionException, TokenStreamException {
02815:
02816: returnAST = null;
02817: ASTPair currentAST = new ASTPair();
02818: AST typeDeclarationStart_AST = null;
02819:
02820: modifiersOpt();
02821: {
02822: switch (LA(1)) {
02823: case LITERAL_class: {
02824: match(LITERAL_class);
02825: break;
02826: }
02827: case LITERAL_interface: {
02828: match(LITERAL_interface);
02829: break;
02830: }
02831: case LITERAL_enum: {
02832: match(LITERAL_enum);
02833: break;
02834: }
02835: case AT: {
02836: AST tmp89_AST = null;
02837: tmp89_AST = astFactory.create(LT(1));
02838: match(AT);
02839: match(LITERAL_interface);
02840: break;
02841: }
02842: default: {
02843: throw new NoViableAltException(LT(1), getFilename());
02844: }
02845: }
02846: }
02847: returnAST = typeDeclarationStart_AST;
02848: }
02849:
02850: public final void classTypeSpec(boolean addImagNode)
02851: throws RecognitionException, TokenStreamException {
02852:
02853: returnAST = null;
02854: ASTPair currentAST = new ASTPair();
02855: AST classTypeSpec_AST = null;
02856: AST ct_AST = null;
02857: Token first = LT(1);
02858:
02859: classOrInterfaceType(false);
02860: ct_AST = (AST) returnAST;
02861: declaratorBrackets(ct_AST);
02862: astFactory.addASTChild(currentAST, returnAST);
02863: if (inputState.guessing == 0) {
02864: classTypeSpec_AST = (AST) currentAST.root;
02865:
02866: if (addImagNode) {
02867: classTypeSpec_AST = (AST) astFactory
02868: .make((new ASTArray(2)).add(
02869: create(TYPE, "TYPE", first, LT(1)))
02870: .add(classTypeSpec_AST));
02871: }
02872:
02873: currentAST.root = classTypeSpec_AST;
02874: currentAST.child = classTypeSpec_AST != null
02875: && classTypeSpec_AST.getFirstChild() != null ? classTypeSpec_AST
02876: .getFirstChild()
02877: : classTypeSpec_AST;
02878: currentAST.advanceChildToEnd();
02879: }
02880: classTypeSpec_AST = (AST) currentAST.root;
02881: returnAST = classTypeSpec_AST;
02882: }
02883:
02884: public final void builtInTypeSpec(boolean addImagNode)
02885: throws RecognitionException, TokenStreamException {
02886:
02887: returnAST = null;
02888: ASTPair currentAST = new ASTPair();
02889: AST builtInTypeSpec_AST = null;
02890: AST bt_AST = null;
02891: Token first = LT(1);
02892:
02893: builtInType();
02894: bt_AST = (AST) returnAST;
02895: declaratorBrackets(bt_AST);
02896: astFactory.addASTChild(currentAST, returnAST);
02897: if (inputState.guessing == 0) {
02898: builtInTypeSpec_AST = (AST) currentAST.root;
02899:
02900: if (addImagNode) {
02901: builtInTypeSpec_AST = (AST) astFactory
02902: .make((new ASTArray(2)).add(
02903: create(TYPE, "TYPE", first, LT(1)))
02904: .add(builtInTypeSpec_AST));
02905: }
02906:
02907: currentAST.root = builtInTypeSpec_AST;
02908: currentAST.child = builtInTypeSpec_AST != null
02909: && builtInTypeSpec_AST.getFirstChild() != null ? builtInTypeSpec_AST
02910: .getFirstChild()
02911: : builtInTypeSpec_AST;
02912: currentAST.advanceChildToEnd();
02913: }
02914: builtInTypeSpec_AST = (AST) currentAST.root;
02915: returnAST = builtInTypeSpec_AST;
02916: }
02917:
02918: public final void classOrInterfaceType(boolean addImagNode)
02919: throws RecognitionException, TokenStreamException {
02920:
02921: returnAST = null;
02922: ASTPair currentAST = new ASTPair();
02923: AST classOrInterfaceType_AST = null;
02924: Token first = LT(1);
02925:
02926: AST tmp91_AST = null;
02927: tmp91_AST = astFactory.create(LT(1));
02928: astFactory.makeASTRoot(currentAST, tmp91_AST);
02929: match(IDENT);
02930: {
02931: switch (LA(1)) {
02932: case LT: {
02933: typeArguments();
02934: astFactory.addASTChild(currentAST, returnAST);
02935: break;
02936: }
02937: case EOF:
02938: case UNUSED_DO:
02939: case LITERAL_def:
02940: case AT:
02941: case IDENT:
02942: case LBRACK:
02943: case RBRACK:
02944: case DOT:
02945: case LPAREN:
02946: case LITERAL_class:
02947: case QUESTION:
02948: case LITERAL_extends:
02949: case LITERAL_super :
02950: case COMMA:
02951: case GT:
02952: case SR:
02953: case BSR:
02954: case LITERAL_void:
02955: case LITERAL_boolean:
02956: case LITERAL_byte:
02957: case LITERAL_char:
02958: case LITERAL_short:
02959: case LITERAL_int:
02960: case LITERAL_float:
02961: case LITERAL_long:
02962: case LITERAL_double:
02963: case LITERAL_any:
02964: case LITERAL_as:
02965: case RPAREN:
02966: case ASSIGN:
02967: case BAND:
02968: case LCURLY:
02969: case RCURLY:
02970: case SEMI:
02971: case NLS:
02972: case LITERAL_default:
02973: case LITERAL_implements :
02974: case LITERAL_this :
02975: case STRING_LITERAL:
02976: case TRIPLE_DOT:
02977: case CLOSABLE_BLOCK_OP:
02978: case COLON:
02979: case LITERAL_if:
02980: case LITERAL_else:
02981: case LITERAL_while:
02982: case LITERAL_switch:
02983: case LITERAL_for:
02984: case LITERAL_in:
02985: case PLUS:
02986: case MINUS:
02987: case LITERAL_case:
02988: case LITERAL_try:
02989: case LITERAL_finally:
02990: case LITERAL_catch:
02991: case PLUS_ASSIGN:
02992: case MINUS_ASSIGN:
02993: case STAR_ASSIGN:
02994: case DIV_ASSIGN:
02995: case MOD_ASSIGN:
02996: case SR_ASSIGN:
02997: case BSR_ASSIGN:
02998: case SL_ASSIGN:
02999: case BAND_ASSIGN:
03000: case BXOR_ASSIGN:
03001: case BOR_ASSIGN:
03002: case STAR_STAR_ASSIGN:
03003: case LOR:
03004: case LAND:
03005: case BOR:
03006: case BXOR:
03007: case REGEX_FIND:
03008: case REGEX_MATCH:
03009: case NOT_EQUAL:
03010: case EQUAL:
03011: case COMPARE_TO:
03012: case INC:
03013: case DEC:
03014: case BNOT:
03015: case LNOT:
03016: case DOLLAR:
03017: case STRING_CTOR_START:
03018: case LITERAL_new:
03019: case LITERAL_true:
03020: case LITERAL_false:
03021: case LITERAL_null:
03022: case NUM_INT:
03023: case NUM_FLOAT:
03024: case NUM_LONG:
03025: case NUM_DOUBLE:
03026: case NUM_BIG_INT:
03027: case NUM_BIG_DECIMAL: {
03028: break;
03029: }
03030: default: {
03031: throw new NoViableAltException(LT(1), getFilename());
03032: }
03033: }
03034: }
03035: {
03036: _loop38: do {
03037: if ((LA(1) == DOT) && (LA(2) == IDENT)
03038: && (_tokenSet_44.member(LA(3)))) {
03039: AST tmp92_AST = null;
03040: tmp92_AST = astFactory.create(LT(1));
03041: astFactory.makeASTRoot(currentAST, tmp92_AST);
03042: match(DOT);
03043: AST tmp93_AST = null;
03044: tmp93_AST = astFactory.create(LT(1));
03045: astFactory.addASTChild(currentAST, tmp93_AST);
03046: match(IDENT);
03047: {
03048: switch (LA(1)) {
03049: case LT: {
03050: typeArguments();
03051: astFactory.addASTChild(currentAST,
03052: returnAST);
03053: break;
03054: }
03055: case EOF:
03056: case UNUSED_DO:
03057: case LITERAL_def:
03058: case AT:
03059: case IDENT:
03060: case LBRACK:
03061: case RBRACK:
03062: case DOT:
03063: case LPAREN:
03064: case LITERAL_class:
03065: case QUESTION:
03066: case LITERAL_extends:
03067: case LITERAL_super :
03068: case COMMA:
03069: case GT:
03070: case SR:
03071: case BSR:
03072: case LITERAL_void:
03073: case LITERAL_boolean:
03074: case LITERAL_byte:
03075: case LITERAL_char:
03076: case LITERAL_short:
03077: case LITERAL_int:
03078: case LITERAL_float:
03079: case LITERAL_long:
03080: case LITERAL_double:
03081: case LITERAL_any:
03082: case LITERAL_as:
03083: case RPAREN:
03084: case ASSIGN:
03085: case BAND:
03086: case LCURLY:
03087: case RCURLY:
03088: case SEMI:
03089: case NLS:
03090: case LITERAL_default:
03091: case LITERAL_implements :
03092: case LITERAL_this :
03093: case STRING_LITERAL:
03094: case TRIPLE_DOT:
03095: case CLOSABLE_BLOCK_OP:
03096: case COLON:
03097: case LITERAL_if:
03098: case LITERAL_else:
03099: case LITERAL_while:
03100: case LITERAL_switch:
03101: case LITERAL_for:
03102: case LITERAL_in:
03103: case PLUS:
03104: case MINUS:
03105: case LITERAL_case:
03106: case LITERAL_try:
03107: case LITERAL_finally:
03108: case LITERAL_catch:
03109: case PLUS_ASSIGN:
03110: case MINUS_ASSIGN:
03111: case STAR_ASSIGN:
03112: case DIV_ASSIGN:
03113: case MOD_ASSIGN:
03114: case SR_ASSIGN:
03115: case BSR_ASSIGN:
03116: case SL_ASSIGN:
03117: case BAND_ASSIGN:
03118: case BXOR_ASSIGN:
03119: case BOR_ASSIGN:
03120: case STAR_STAR_ASSIGN:
03121: case LOR:
03122: case LAND:
03123: case BOR:
03124: case BXOR:
03125: case REGEX_FIND:
03126: case REGEX_MATCH:
03127: case NOT_EQUAL:
03128: case EQUAL:
03129: case COMPARE_TO:
03130: case INC:
03131: case DEC:
03132: case BNOT:
03133: case LNOT:
03134: case DOLLAR:
03135: case STRING_CTOR_START:
03136: case LITERAL_new:
03137: case LITERAL_true:
03138: case LITERAL_false:
03139: case LITERAL_null:
03140: case NUM_INT:
03141: case NUM_FLOAT:
03142: case NUM_LONG:
03143: case NUM_DOUBLE:
03144: case NUM_BIG_INT:
03145: case NUM_BIG_DECIMAL: {
03146: break;
03147: }
03148: default: {
03149: throw new NoViableAltException(LT(1),
03150: getFilename());
03151: }
03152: }
03153: }
03154: } else {
03155: break _loop38;
03156: }
03157:
03158: } while (true);
03159: }
03160: if (inputState.guessing == 0) {
03161: classOrInterfaceType_AST = (AST) currentAST.root;
03162:
03163: if (addImagNode) {
03164: classOrInterfaceType_AST = (AST) astFactory
03165: .make((new ASTArray(2)).add(
03166: create(TYPE, "TYPE", first, LT(1)))
03167: .add(classOrInterfaceType_AST));
03168: }
03169:
03170: currentAST.root = classOrInterfaceType_AST;
03171: currentAST.child = classOrInterfaceType_AST != null
03172: && classOrInterfaceType_AST.getFirstChild() != null ? classOrInterfaceType_AST
03173: .getFirstChild()
03174: : classOrInterfaceType_AST;
03175: currentAST.advanceChildToEnd();
03176: }
03177: classOrInterfaceType_AST = (AST) currentAST.root;
03178: returnAST = classOrInterfaceType_AST;
03179: }
03180:
03181: /** After some type names, where zero or more empty bracket pairs are allowed.
03182: * We use ARRAY_DECLARATOR to represent this.
03183: * TODO: Is there some more Groovy way to view this in terms of the indexed property syntax?
03184: */
03185: public final void declaratorBrackets(AST typ)
03186: throws RecognitionException, TokenStreamException {
03187:
03188: returnAST = null;
03189: ASTPair currentAST = new ASTPair();
03190: AST declaratorBrackets_AST = null;
03191: Token lb = null;
03192: AST lb_AST = null;
03193:
03194: if (inputState.guessing == 0) {
03195: declaratorBrackets_AST = (AST) currentAST.root;
03196: declaratorBrackets_AST = typ;
03197: currentAST.root = declaratorBrackets_AST;
03198: currentAST.child = declaratorBrackets_AST != null
03199: && declaratorBrackets_AST.getFirstChild() != null ? declaratorBrackets_AST
03200: .getFirstChild()
03201: : declaratorBrackets_AST;
03202: currentAST.advanceChildToEnd();
03203: }
03204: {
03205: _loop209: do {
03206: if ((LA(1) == LBRACK) && (LA(2) == RBRACK)
03207: && (_tokenSet_45.member(LA(3)))) {
03208: lb = LT(1);
03209: lb_AST = astFactory.create(lb);
03210: astFactory.makeASTRoot(currentAST, lb_AST);
03211: match(LBRACK);
03212: if (inputState.guessing == 0) {
03213: lb_AST.setType(ARRAY_DECLARATOR);
03214: }
03215: match(RBRACK);
03216: } else {
03217: break _loop209;
03218: }
03219:
03220: } while (true);
03221: }
03222: declaratorBrackets_AST = (AST) currentAST.root;
03223: returnAST = declaratorBrackets_AST;
03224: }
03225:
03226: public final void typeArguments() throws RecognitionException,
03227: TokenStreamException {
03228:
03229: returnAST = null;
03230: ASTPair currentAST = new ASTPair();
03231: AST typeArguments_AST = null;
03232: Token first = LT(1);
03233: int currentLtLevel = 0;
03234:
03235: if (inputState.guessing == 0) {
03236: currentLtLevel = ltCounter;
03237: }
03238: match(LT);
03239: if (inputState.guessing == 0) {
03240: ltCounter++;
03241: }
03242: nls();
03243: typeArgument();
03244: astFactory.addASTChild(currentAST, returnAST);
03245: {
03246: _loop48: do {
03247: if (((LA(1) == COMMA) && (_tokenSet_46.member(LA(2))) && (_tokenSet_44
03248: .member(LA(3))))
03249: && (inputState.guessing != 0 || ltCounter == currentLtLevel + 1)) {
03250: match(COMMA);
03251: nls();
03252: typeArgument();
03253: astFactory.addASTChild(currentAST, returnAST);
03254: } else {
03255: break _loop48;
03256: }
03257:
03258: } while (true);
03259: }
03260: nls();
03261: {
03262: if (((LA(1) >= GT && LA(1) <= BSR))
03263: && (_tokenSet_45.member(LA(2)))
03264: && (_tokenSet_5.member(LA(3)))) {
03265: typeArgumentsOrParametersEnd();
03266: astFactory.addASTChild(currentAST, returnAST);
03267: } else if ((_tokenSet_45.member(LA(1)))
03268: && (_tokenSet_5.member(LA(2)))
03269: && (_tokenSet_5.member(LA(3)))) {
03270: } else {
03271: throw new NoViableAltException(LT(1), getFilename());
03272: }
03273:
03274: }
03275: if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
03276: throw new SemanticException(
03277: "(currentLtLevel != 0) || ltCounter == currentLtLevel");
03278: if (inputState.guessing == 0) {
03279: typeArguments_AST = (AST) currentAST.root;
03280: typeArguments_AST = (AST) astFactory.make((new ASTArray(2))
03281: .add(
03282: create(TYPE_ARGUMENTS, "TYPE_ARGUMENTS",
03283: first, LT(1))).add(
03284: typeArguments_AST));
03285: currentAST.root = typeArguments_AST;
03286: currentAST.child = typeArguments_AST != null
03287: && typeArguments_AST.getFirstChild() != null ? typeArguments_AST
03288: .getFirstChild()
03289: : typeArguments_AST;
03290: currentAST.advanceChildToEnd();
03291: }
03292: typeArguments_AST = (AST) currentAST.root;
03293: returnAST = typeArguments_AST;
03294: }
03295:
03296: public final void typeArgumentSpec() throws RecognitionException,
03297: TokenStreamException {
03298:
03299: returnAST = null;
03300: ASTPair currentAST = new ASTPair();
03301: AST typeArgumentSpec_AST = null;
03302:
03303: switch (LA(1)) {
03304: case IDENT: {
03305: classTypeSpec(true);
03306: astFactory.addASTChild(currentAST, returnAST);
03307: typeArgumentSpec_AST = (AST) currentAST.root;
03308: break;
03309: }
03310: case LITERAL_void:
03311: case LITERAL_boolean:
03312: case LITERAL_byte:
03313: case LITERAL_char:
03314: case LITERAL_short:
03315: case LITERAL_int:
03316: case LITERAL_float:
03317: case LITERAL_long:
03318: case LITERAL_double:
03319: case LITERAL_any: {
03320: builtInTypeArraySpec(true);
03321: astFactory.addASTChild(currentAST, returnAST);
03322: typeArgumentSpec_AST = (AST) currentAST.root;
03323: break;
03324: }
03325: default: {
03326: throw new NoViableAltException(LT(1), getFilename());
03327: }
03328: }
03329: returnAST = typeArgumentSpec_AST;
03330: }
03331:
03332: public final void builtInTypeArraySpec(boolean addImagNode)
03333: throws RecognitionException, TokenStreamException {
03334:
03335: returnAST = null;
03336: ASTPair currentAST = new ASTPair();
03337: AST builtInTypeArraySpec_AST = null;
03338: AST bt_AST = null;
03339: Token first = LT(1);
03340:
03341: builtInType();
03342: bt_AST = (AST) returnAST;
03343: {
03344: boolean synPredMatched56 = false;
03345: if (((_tokenSet_45.member(LA(1)))
03346: && (_tokenSet_5.member(LA(2))) && (_tokenSet_5
03347: .member(LA(3))))) {
03348: int _m56 = mark();
03349: synPredMatched56 = true;
03350: inputState.guessing++;
03351: try {
03352: {
03353: match(LBRACK);
03354: }
03355: } catch (RecognitionException pe) {
03356: synPredMatched56 = false;
03357: }
03358: rewind(_m56);
03359: inputState.guessing--;
03360: }
03361: if (synPredMatched56) {
03362: declaratorBrackets(bt_AST);
03363: astFactory.addASTChild(currentAST, returnAST);
03364: } else if ((_tokenSet_45.member(LA(1)))
03365: && (_tokenSet_5.member(LA(2)))
03366: && (_tokenSet_5.member(LA(3)))) {
03367: if (inputState.guessing == 0) {
03368: require(
03369: false,
03370: "primitive type parameters not allowed here",
03371: "use the corresponding wrapper type, such as Integer for int");
03372: }
03373: } else {
03374: throw new NoViableAltException(LT(1), getFilename());
03375: }
03376:
03377: }
03378: if (inputState.guessing == 0) {
03379: builtInTypeArraySpec_AST = (AST) currentAST.root;
03380:
03381: if (addImagNode) {
03382: builtInTypeArraySpec_AST = (AST) astFactory
03383: .make((new ASTArray(2)).add(
03384: create(TYPE, "TYPE", first, LT(1)))
03385: .add(builtInTypeArraySpec_AST));
03386: }
03387:
03388: currentAST.root = builtInTypeArraySpec_AST;
03389: currentAST.child = builtInTypeArraySpec_AST != null
03390: && builtInTypeArraySpec_AST.getFirstChild() != null ? builtInTypeArraySpec_AST
03391: .getFirstChild()
03392: : builtInTypeArraySpec_AST;
03393: currentAST.advanceChildToEnd();
03394: }
03395: builtInTypeArraySpec_AST = (AST) currentAST.root;
03396: returnAST = builtInTypeArraySpec_AST;
03397: }
03398:
03399: public final void typeArgument() throws RecognitionException,
03400: TokenStreamException {
03401:
03402: returnAST = null;
03403: ASTPair currentAST = new ASTPair();
03404: AST typeArgument_AST = null;
03405: Token first = LT(1);
03406:
03407: {
03408: switch (LA(1)) {
03409: case IDENT:
03410: case LITERAL_void:
03411: case LITERAL_boolean:
03412: case LITERAL_byte:
03413: case LITERAL_char:
03414: case LITERAL_short:
03415: case LITERAL_int:
03416: case LITERAL_float:
03417: case LITERAL_long:
03418: case LITERAL_double:
03419: case LITERAL_any: {
03420: typeArgumentSpec();
03421: astFactory.addASTChild(currentAST, returnAST);
03422: break;
03423: }
03424: case QUESTION: {
03425: wildcardType();
03426: astFactory.addASTChild(currentAST, returnAST);
03427: break;
03428: }
03429: default: {
03430: throw new NoViableAltException(LT(1), getFilename());
03431: }
03432: }
03433: }
03434: if (inputState.guessing == 0) {
03435: typeArgument_AST = (AST) currentAST.root;
03436: typeArgument_AST = (AST) astFactory.make((new ASTArray(2))
03437: .add(
03438: create(TYPE_ARGUMENT, "TYPE_ARGUMENT",
03439: first, LT(1)))
03440: .add(typeArgument_AST));
03441: currentAST.root = typeArgument_AST;
03442: currentAST.child = typeArgument_AST != null
03443: && typeArgument_AST.getFirstChild() != null ? typeArgument_AST
03444: .getFirstChild()
03445: : typeArgument_AST;
03446: currentAST.advanceChildToEnd();
03447: }
03448: typeArgument_AST = (AST) currentAST.root;
03449: returnAST = typeArgument_AST;
03450: }
03451:
03452: public final void wildcardType() throws RecognitionException,
03453: TokenStreamException {
03454:
03455: returnAST = null;
03456: ASTPair currentAST = new ASTPair();
03457: AST wildcardType_AST = null;
03458: Token q = null;
03459: AST q_AST = null;
03460:
03461: q = LT(1);
03462: q_AST = astFactory.create(q);
03463: astFactory.makeASTRoot(currentAST, q_AST);
03464: match(QUESTION);
03465: if (inputState.guessing == 0) {
03466: q_AST.setType(WILDCARD_TYPE);
03467: }
03468: {
03469: boolean synPredMatched45 = false;
03470: if (((LA(1) == LITERAL_extends || LA(1) == LITERAL_super )
03471: && (LA(2) == IDENT || LA(2) == NLS) && (_tokenSet_44
03472: .member(LA(3))))) {
03473: int _m45 = mark();
03474: synPredMatched45 = true;
03475: inputState.guessing++;
03476: try {
03477: {
03478: switch (LA(1)) {
03479: case LITERAL_extends: {
03480: match(LITERAL_extends);
03481: break;
03482: }
03483: case LITERAL_super : {
03484: match(LITERAL_super );
03485: break;
03486: }
03487: default: {
03488: throw new NoViableAltException(LT(1),
03489: getFilename());
03490: }
03491: }
03492: }
03493: } catch (RecognitionException pe) {
03494: synPredMatched45 = false;
03495: }
03496: rewind(_m45);
03497: inputState.guessing--;
03498: }
03499: if (synPredMatched45) {
03500: typeArgumentBounds();
03501: astFactory.addASTChild(currentAST, returnAST);
03502: } else if ((_tokenSet_45.member(LA(1)))
03503: && (_tokenSet_5.member(LA(2)))
03504: && (_tokenSet_5.member(LA(3)))) {
03505: } else {
03506: throw new NoViableAltException(LT(1), getFilename());
03507: }
03508:
03509: }
03510: wildcardType_AST = (AST) currentAST.root;
03511: returnAST = wildcardType_AST;
03512: }
03513:
03514: public final void typeArgumentBounds() throws RecognitionException,
03515: TokenStreamException {
03516:
03517: returnAST = null;
03518: ASTPair currentAST = new ASTPair();
03519: AST typeArgumentBounds_AST = null;
03520: Token first = LT(1);
03521: boolean isUpperBounds = false;
03522:
03523: {
03524: switch (LA(1)) {
03525: case LITERAL_extends: {
03526: match(LITERAL_extends);
03527: if (inputState.guessing == 0) {
03528: isUpperBounds = true;
03529: }
03530: break;
03531: }
03532: case LITERAL_super : {
03533: match(LITERAL_super );
03534: break;
03535: }
03536: default: {
03537: throw new NoViableAltException(LT(1), getFilename());
03538: }
03539: }
03540: }
03541: nls();
03542: classOrInterfaceType(false);
03543: astFactory.addASTChild(currentAST, returnAST);
03544: nls();
03545: if (inputState.guessing == 0) {
03546: typeArgumentBounds_AST = (AST) currentAST.root;
03547:
03548: if (isUpperBounds) {
03549: typeArgumentBounds_AST = (AST) astFactory
03550: .make((new ASTArray(2)).add(
03551: create(TYPE_UPPER_BOUNDS,
03552: "TYPE_UPPER_BOUNDS", first,
03553: LT(1))).add(
03554: typeArgumentBounds_AST));
03555: } else {
03556: typeArgumentBounds_AST = (AST) astFactory
03557: .make((new ASTArray(2)).add(
03558: create(TYPE_LOWER_BOUNDS,
03559: "TYPE_LOWER_BOUNDS", first,
03560: LT(1))).add(
03561: typeArgumentBounds_AST));
03562: }
03563:
03564: currentAST.root = typeArgumentBounds_AST;
03565: currentAST.child = typeArgumentBounds_AST != null
03566: && typeArgumentBounds_AST.getFirstChild() != null ? typeArgumentBounds_AST
03567: .getFirstChild()
03568: : typeArgumentBounds_AST;
03569: currentAST.advanceChildToEnd();
03570: }
03571: typeArgumentBounds_AST = (AST) currentAST.root;
03572: returnAST = typeArgumentBounds_AST;
03573: }
03574:
03575: protected final void typeArgumentsOrParametersEnd()
03576: throws RecognitionException, TokenStreamException {
03577:
03578: returnAST = null;
03579: ASTPair currentAST = new ASTPair();
03580: AST typeArgumentsOrParametersEnd_AST = null;
03581:
03582: switch (LA(1)) {
03583: case GT: {
03584: match(GT);
03585: if (inputState.guessing == 0) {
03586: ltCounter -= 1;
03587: }
03588: nls();
03589: typeArgumentsOrParametersEnd_AST = (AST) currentAST.root;
03590: break;
03591: }
03592: case SR: {
03593: match(SR);
03594: if (inputState.guessing == 0) {
03595: ltCounter -= 2;
03596: }
03597: nls();
03598: typeArgumentsOrParametersEnd_AST = (AST) currentAST.root;
03599: break;
03600: }
03601: case BSR: {
03602: match(BSR);
03603: if (inputState.guessing == 0) {
03604: ltCounter -= 3;
03605: }
03606: nls();
03607: typeArgumentsOrParametersEnd_AST = (AST) currentAST.root;
03608: break;
03609: }
03610: default: {
03611: throw new NoViableAltException(LT(1), getFilename());
03612: }
03613: }
03614: returnAST = typeArgumentsOrParametersEnd_AST;
03615: }
03616:
03617: public final void type() throws RecognitionException,
03618: TokenStreamException {
03619:
03620: returnAST = null;
03621: ASTPair currentAST = new ASTPair();
03622: AST type_AST = null;
03623:
03624: switch (LA(1)) {
03625: case IDENT: {
03626: classOrInterfaceType(false);
03627: astFactory.addASTChild(currentAST, returnAST);
03628: type_AST = (AST) currentAST.root;
03629: break;
03630: }
03631: case LITERAL_void:
03632: case LITERAL_boolean:
03633: case LITERAL_byte:
03634: case LITERAL_char:
03635: case LITERAL_short:
03636: case LITERAL_int:
03637: case LITERAL_float:
03638: case LITERAL_long:
03639: case LITERAL_double:
03640: case LITERAL_any: {
03641: builtInType();
03642: astFactory.addASTChild(currentAST, returnAST);
03643: type_AST = (AST) currentAST.root;
03644: break;
03645: }
03646: default: {
03647: throw new NoViableAltException(LT(1), getFilename());
03648: }
03649: }
03650: returnAST = type_AST;
03651: }
03652:
03653: public final void modifiersInternal() throws RecognitionException,
03654: TokenStreamException {
03655:
03656: returnAST = null;
03657: ASTPair currentAST = new ASTPair();
03658: AST modifiersInternal_AST = null;
03659: int seenDef = 0;
03660:
03661: {
03662: int _cnt69 = 0;
03663: _loop69: do {
03664: if (((LA(1) == LITERAL_def)) && (seenDef++ == 0)) {
03665: match(LITERAL_def);
03666: nls();
03667: } else if ((_tokenSet_47.member(LA(1)))) {
03668: modifier();
03669: astFactory.addASTChild(currentAST, returnAST);
03670: nls();
03671: } else if (((LA(1) == AT) && (LA(2) == IDENT) && (_tokenSet_48
03672: .member(LA(3))))
03673: && (LA(1) == AT && !LT(2).getText().equals(
03674: "interface"))) {
03675: annotation();
03676: astFactory.addASTChild(currentAST, returnAST);
03677: nls();
03678: } else {
03679: if (_cnt69 >= 1) {
03680: break _loop69;
03681: } else {
03682: throw new NoViableAltException(LT(1),
03683: getFilename());
03684: }
03685: }
03686:
03687: _cnt69++;
03688: } while (true);
03689: }
03690: modifiersInternal_AST = (AST) currentAST.root;
03691: returnAST = modifiersInternal_AST;
03692: }
03693:
03694: public final void annotation() throws RecognitionException,
03695: TokenStreamException {
03696:
03697: returnAST = null;
03698: ASTPair currentAST = new ASTPair();
03699: AST annotation_AST = null;
03700: AST i_AST = null;
03701: AST args_AST = null;
03702: Token first = LT(1);
03703:
03704: match(AT);
03705: identifier();
03706: i_AST = (AST) returnAST;
03707: {
03708: switch (LA(1)) {
03709: case LPAREN: {
03710: match(LPAREN);
03711: {
03712: switch (LA(1)) {
03713: case AT:
03714: case IDENT:
03715: case LBRACK:
03716: case LPAREN:
03717: case LITERAL_super :
03718: case LITERAL_void:
03719: case LITERAL_boolean:
03720: case LITERAL_byte:
03721: case LITERAL_char:
03722: case LITERAL_short:
03723: case LITERAL_int:
03724: case LITERAL_float:
03725: case LITERAL_long:
03726: case LITERAL_double:
03727: case LITERAL_any:
03728: case LCURLY:
03729: case LITERAL_this :
03730: case STRING_LITERAL:
03731: case PLUS:
03732: case MINUS:
03733: case INC:
03734: case DEC:
03735: case BNOT:
03736: case LNOT:
03737: case DOLLAR:
03738: case STRING_CTOR_START:
03739: case LITERAL_new:
03740: case LITERAL_true:
03741: case LITERAL_false:
03742: case LITERAL_null:
03743: case NUM_INT:
03744: case NUM_FLOAT:
03745: case NUM_LONG:
03746: case NUM_DOUBLE:
03747: case NUM_BIG_INT:
03748: case NUM_BIG_DECIMAL: {
03749: annotationArguments();
03750: args_AST = (AST) returnAST;
03751: break;
03752: }
03753: case RPAREN: {
03754: break;
03755: }
03756: default: {
03757: throw new NoViableAltException(LT(1),
03758: getFilename());
03759: }
03760: }
03761: }
03762: match(RPAREN);
03763: break;
03764: }
03765: case EOF:
03766: case FINAL:
03767: case ABSTRACT:
03768: case STRICTFP:
03769: case LITERAL_package:
03770: case LITERAL_static:
03771: case LITERAL_def:
03772: case AT:
03773: case IDENT:
03774: case RBRACK:
03775: case LITERAL_class:
03776: case LITERAL_interface:
03777: case LITERAL_enum:
03778: case LT:
03779: case COMMA:
03780: case LITERAL_void:
03781: case LITERAL_boolean:
03782: case LITERAL_byte:
03783: case LITERAL_char:
03784: case LITERAL_short:
03785: case LITERAL_int:
03786: case LITERAL_float:
03787: case LITERAL_long:
03788: case LITERAL_double:
03789: case LITERAL_any:
03790: case LITERAL_private:
03791: case LITERAL_public:
03792: case LITERAL_protected:
03793: case LITERAL_transient:
03794: case LITERAL_native:
03795: case LITERAL_threadsafe:
03796: case LITERAL_synchronized:
03797: case LITERAL_volatile:
03798: case RPAREN:
03799: case RCURLY:
03800: case SEMI:
03801: case NLS:
03802: case STRING_LITERAL:
03803: case TRIPLE_DOT: {
03804: break;
03805: }
03806: default: {
03807: throw new NoViableAltException(LT(1), getFilename());
03808: }
03809: }
03810: }
03811: if (inputState.guessing == 0) {
03812: annotation_AST = (AST) currentAST.root;
03813: annotation_AST = (AST) astFactory
03814: .make((new ASTArray(3)).add(
03815: create(ANNOTATION, "ANNOTATION", first,
03816: LT(1))).add(i_AST).add(args_AST));
03817: currentAST.root = annotation_AST;
03818: currentAST.child = annotation_AST != null
03819: && annotation_AST.getFirstChild() != null ? annotation_AST
03820: .getFirstChild()
03821: : annotation_AST;
03822: currentAST.advanceChildToEnd();
03823: }
03824: returnAST = annotation_AST;
03825: }
03826:
03827: public final void annotationArguments()
03828: throws RecognitionException, TokenStreamException {
03829:
03830: returnAST = null;
03831: ASTPair currentAST = new ASTPair();
03832: AST annotationArguments_AST = null;
03833:
03834: if ((_tokenSet_49.member(LA(1)))
03835: && (_tokenSet_50.member(LA(2)))) {
03836: annotationMemberValueInitializer();
03837: astFactory.addASTChild(currentAST, returnAST);
03838: annotationArguments_AST = (AST) currentAST.root;
03839: } else if ((LA(1) == IDENT) && (LA(2) == ASSIGN)) {
03840: anntotationMemberValuePairs();
03841: astFactory.addASTChild(currentAST, returnAST);
03842: annotationArguments_AST = (AST) currentAST.root;
03843: } else {
03844: throw new NoViableAltException(LT(1), getFilename());
03845: }
03846:
03847: returnAST = annotationArguments_AST;
03848: }
03849:
03850: public final void annotationMemberValueInitializer()
03851: throws RecognitionException, TokenStreamException {
03852:
03853: returnAST = null;
03854: ASTPair currentAST = new ASTPair();
03855: AST annotationMemberValueInitializer_AST = null;
03856:
03857: switch (LA(1)) {
03858: case IDENT:
03859: case LBRACK:
03860: case LPAREN:
03861: case LITERAL_super :
03862: case LITERAL_void:
03863: case LITERAL_boolean:
03864: case LITERAL_byte:
03865: case LITERAL_char:
03866: case LITERAL_short:
03867: case LITERAL_int:
03868: case LITERAL_float:
03869: case LITERAL_long:
03870: case LITERAL_double:
03871: case LITERAL_any:
03872: case LCURLY:
03873: case LITERAL_this :
03874: case STRING_LITERAL:
03875: case PLUS:
03876: case MINUS:
03877: case INC:
03878: case DEC:
03879: case BNOT:
03880: case LNOT:
03881: case DOLLAR:
03882: case STRING_CTOR_START:
03883: case LITERAL_new:
03884: case LITERAL_true:
03885: case LITERAL_false:
03886: case LITERAL_null:
03887: case NUM_INT:
03888: case NUM_FLOAT:
03889: case NUM_LONG:
03890: case NUM_DOUBLE:
03891: case NUM_BIG_INT:
03892: case NUM_BIG_DECIMAL: {
03893: conditionalExpression(0);
03894: astFactory.addASTChild(currentAST, returnAST);
03895: annotationMemberValueInitializer_AST = (AST) currentAST.root;
03896: break;
03897: }
03898: case AT: {
03899: annotation();
03900: astFactory.addASTChild(currentAST, returnAST);
03901: annotationMemberValueInitializer_AST = (AST) currentAST.root;
03902: break;
03903: }
03904: default: {
03905: throw new NoViableAltException(LT(1), getFilename());
03906: }
03907: }
03908: returnAST = annotationMemberValueInitializer_AST;
03909: }
03910:
03911: public final void anntotationMemberValuePairs()
03912: throws RecognitionException, TokenStreamException {
03913:
03914: returnAST = null;
03915: ASTPair currentAST = new ASTPair();
03916: AST anntotationMemberValuePairs_AST = null;
03917:
03918: annotationMemberValuePair();
03919: astFactory.addASTChild(currentAST, returnAST);
03920: {
03921: _loop83: do {
03922: if ((LA(1) == COMMA)) {
03923: match(COMMA);
03924: nls();
03925: annotationMemberValuePair();
03926: astFactory.addASTChild(currentAST, returnAST);
03927: } else {
03928: break _loop83;
03929: }
03930:
03931: } while (true);
03932: }
03933: anntotationMemberValuePairs_AST = (AST) currentAST.root;
03934: returnAST = anntotationMemberValuePairs_AST;
03935: }
03936:
03937: public final void annotationMemberValuePair()
03938: throws RecognitionException, TokenStreamException {
03939:
03940: returnAST = null;
03941: ASTPair currentAST = new ASTPair();
03942: AST annotationMemberValuePair_AST = null;
03943: Token i = null;
03944: AST i_AST = null;
03945: AST v_AST = null;
03946: Token first = LT(1);
03947:
03948: i = LT(1);
03949: i_AST = astFactory.create(i);
03950: match(IDENT);
03951: match(ASSIGN);
03952: nls();
03953: annotationMemberValueInitializer();
03954: v_AST = (AST) returnAST;
03955: if (inputState.guessing == 0) {
03956: annotationMemberValuePair_AST = (AST) currentAST.root;
03957: annotationMemberValuePair_AST = (AST) astFactory
03958: .make((new ASTArray(3)).add(
03959: create(ANNOTATION_MEMBER_VALUE_PAIR,
03960: "ANNOTATION_MEMBER_VALUE_PAIR",
03961: first, LT(1))).add(i_AST)
03962: .add(v_AST));
03963: currentAST.root = annotationMemberValuePair_AST;
03964: currentAST.child = annotationMemberValuePair_AST != null
03965: && annotationMemberValuePair_AST.getFirstChild() != null ? annotationMemberValuePair_AST
03966: .getFirstChild()
03967: : annotationMemberValuePair_AST;
03968: currentAST.advanceChildToEnd();
03969: }
03970: returnAST = annotationMemberValuePair_AST;
03971: }
03972:
03973: public final void conditionalExpression(int lc_stmt)
03974: throws RecognitionException, TokenStreamException {
03975:
03976: returnAST = null;
03977: ASTPair currentAST = new ASTPair();
03978: AST conditionalExpression_AST = null;
03979:
03980: logicalOrExpression(lc_stmt);
03981: astFactory.addASTChild(currentAST, returnAST);
03982: {
03983: switch (LA(1)) {
03984: case QUESTION: {
03985: AST tmp108_AST = null;
03986: tmp108_AST = astFactory.create(LT(1));
03987: astFactory.makeASTRoot(currentAST, tmp108_AST);
03988: match(QUESTION);
03989: nls();
03990: assignmentExpression(0);
03991: astFactory.addASTChild(currentAST, returnAST);
03992: match(COLON);
03993: nls();
03994: conditionalExpression(0);
03995: astFactory.addASTChild(currentAST, returnAST);
03996: break;
03997: }
03998: case EOF:
03999: case IDENT:
04000: case LBRACK:
04001: case RBRACK:
04002: case LPAREN:
04003: case LITERAL_super :
04004: case COMMA:
04005: case LITERAL_void:
04006: case LITERAL_boolean:
04007: case LITERAL_byte:
04008: case LITERAL_char:
04009: case LITERAL_short:
04010: case LITERAL_int:
04011: case LITERAL_float:
04012: case LITERAL_long:
04013: case LITERAL_double:
04014: case LITERAL_any:
04015: case RPAREN:
04016: case ASSIGN:
04017: case LCURLY:
04018: case RCURLY:
04019: case SEMI:
04020: case NLS:
04021: case LITERAL_default:
04022: case LITERAL_this :
04023: case STRING_LITERAL:
04024: case CLOSABLE_BLOCK_OP:
04025: case COLON:
04026: case LITERAL_else:
04027: case PLUS:
04028: case MINUS:
04029: case LITERAL_case:
04030: case PLUS_ASSIGN:
04031: case MINUS_ASSIGN:
04032: case STAR_ASSIGN:
04033: case DIV_ASSIGN:
04034: case MOD_ASSIGN:
04035: case SR_ASSIGN:
04036: case BSR_ASSIGN:
04037: case SL_ASSIGN:
04038: case BAND_ASSIGN:
04039: case BXOR_ASSIGN:
04040: case BOR_ASSIGN:
04041: case STAR_STAR_ASSIGN:
04042: case INC:
04043: case DEC:
04044: case BNOT:
04045: case LNOT:
04046: case DOLLAR:
04047: case STRING_CTOR_START:
04048: case LITERAL_new:
04049: case LITERAL_true:
04050: case LITERAL_false:
04051: case LITERAL_null:
04052: case NUM_INT:
04053: case NUM_FLOAT:
04054: case NUM_LONG:
04055: case NUM_DOUBLE:
04056: case NUM_BIG_INT:
04057: case NUM_BIG_DECIMAL: {
04058: break;
04059: }
04060: default: {
04061: throw new NoViableAltException(LT(1), getFilename());
04062: }
04063: }
04064: }
04065: conditionalExpression_AST = (AST) currentAST.root;
04066: returnAST = conditionalExpression_AST;
04067: }
04068:
04069: public final void annotationMemberArrayValueInitializer()
04070: throws RecognitionException, TokenStreamException {
04071:
04072: returnAST = null;
04073: ASTPair currentAST = new ASTPair();
04074: AST annotationMemberArrayValueInitializer_AST = null;
04075:
04076: switch (LA(1)) {
04077: case IDENT:
04078: case LBRACK:
04079: case LPAREN:
04080: case LITERAL_super :
04081: case LITERAL_void:
04082: case LITERAL_boolean:
04083: case LITERAL_byte:
04084: case LITERAL_char:
04085: case LITERAL_short:
04086: case LITERAL_int:
04087: case LITERAL_float:
04088: case LITERAL_long:
04089: case LITERAL_double:
04090: case LITERAL_any:
04091: case LCURLY:
04092: case LITERAL_this :
04093: case STRING_LITERAL:
04094: case PLUS:
04095: case MINUS:
04096: case INC:
04097: case DEC:
04098: case BNOT:
04099: case LNOT:
04100: case DOLLAR:
04101: case STRING_CTOR_START:
04102: case LITERAL_new:
04103: case LITERAL_true:
04104: case LITERAL_false:
04105: case LITERAL_null:
04106: case NUM_INT:
04107: case NUM_FLOAT:
04108: case NUM_LONG:
04109: case NUM_DOUBLE:
04110: case NUM_BIG_INT:
04111: case NUM_BIG_DECIMAL: {
04112: conditionalExpression(0);
04113: astFactory.addASTChild(currentAST, returnAST);
04114: annotationMemberArrayValueInitializer_AST = (AST) currentAST.root;
04115: break;
04116: }
04117: case AT: {
04118: annotation();
04119: astFactory.addASTChild(currentAST, returnAST);
04120: nls();
04121: annotationMemberArrayValueInitializer_AST = (AST) currentAST.root;
04122: break;
04123: }
04124: default: {
04125: throw new NoViableAltException(LT(1), getFilename());
04126: }
04127: }
04128: returnAST = annotationMemberArrayValueInitializer_AST;
04129: }
04130:
04131: public final void super ClassClause() throws RecognitionException,
04132: TokenStreamException {
04133:
04134: returnAST = null;
04135: ASTPair currentAST = new ASTPair();
04136: AST super ClassClause_AST = null;
04137: AST c_AST = null;
04138: Token first = LT(1);
04139:
04140: {
04141: switch (LA(1)) {
04142: case LITERAL_extends: {
04143: match(LITERAL_extends);
04144: nls();
04145: classOrInterfaceType(false);
04146: c_AST = (AST) returnAST;
04147: nls();
04148: break;
04149: }
04150: case LCURLY:
04151: case LITERAL_implements : {
04152: break;
04153: }
04154: default: {
04155: throw new NoViableAltException(LT(1), getFilename());
04156: }
04157: }
04158: }
04159: if (inputState.guessing == 0) {
04160: super ClassClause_AST = (AST) currentAST.root;
04161: super ClassClause_AST = (AST) astFactory.make((new ASTArray(
04162: 2)).add(
04163: create(EXTENDS_CLAUSE, "EXTENDS_CLAUSE", first,
04164: LT(1))).add(c_AST));
04165: currentAST.root = super ClassClause_AST;
04166: currentAST.child = super ClassClause_AST != null
04167: && super ClassClause_AST.getFirstChild() != null ? super ClassClause_AST
04168: .getFirstChild()
04169: : super ClassClause_AST;
04170: currentAST.advanceChildToEnd();
04171: }
04172: returnAST = super ClassClause_AST;
04173: }
04174:
04175: public final void typeParameters() throws RecognitionException,
04176: TokenStreamException {
04177:
04178: returnAST = null;
04179: ASTPair currentAST = new ASTPair();
04180: AST typeParameters_AST = null;
04181: Token first = LT(1);
04182: int currentLtLevel = 0;
04183:
04184: if (inputState.guessing == 0) {
04185: currentLtLevel = ltCounter;
04186: }
04187: match(LT);
04188: if (inputState.guessing == 0) {
04189: ltCounter++;
04190: }
04191: nls();
04192: typeParameter();
04193: astFactory.addASTChild(currentAST, returnAST);
04194: {
04195: _loop97: do {
04196: if ((LA(1) == COMMA)) {
04197: match(COMMA);
04198: nls();
04199: typeParameter();
04200: astFactory.addASTChild(currentAST, returnAST);
04201: } else {
04202: break _loop97;
04203: }
04204:
04205: } while (true);
04206: }
04207: nls();
04208: {
04209: switch (LA(1)) {
04210: case GT:
04211: case SR:
04212: case BSR: {
04213: typeArgumentsOrParametersEnd();
04214: astFactory.addASTChild(currentAST, returnAST);
04215: break;
04216: }
04217: case IDENT:
04218: case LITERAL_extends:
04219: case LITERAL_void:
04220: case LITERAL_boolean:
04221: case LITERAL_byte:
04222: case LITERAL_char:
04223: case LITERAL_short:
04224: case LITERAL_int:
04225: case LITERAL_float:
04226: case LITERAL_long:
04227: case LITERAL_double:
04228: case LITERAL_any:
04229: case LCURLY:
04230: case LITERAL_implements : {
04231: break;
04232: }
04233: default: {
04234: throw new NoViableAltException(LT(1), getFilename());
04235: }
04236: }
04237: }
04238: if (!((currentLtLevel != 0) || ltCounter == currentLtLevel))
04239: throw new SemanticException(
04240: "(currentLtLevel != 0) || ltCounter == currentLtLevel");
04241: if (inputState.guessing == 0) {
04242: typeParameters_AST = (AST) currentAST.root;
04243: typeParameters_AST = (AST) astFactory
04244: .make((new ASTArray(2)).add(
04245: create(TYPE_PARAMETERS, "TYPE_PARAMETERS",
04246: first, LT(1))).add(
04247: typeParameters_AST));
04248: currentAST.root = typeParameters_AST;
04249: currentAST.child = typeParameters_AST != null
04250: && typeParameters_AST.getFirstChild() != null ? typeParameters_AST
04251: .getFirstChild()
04252: : typeParameters_AST;
04253: currentAST.advanceChildToEnd();
04254: }
04255: typeParameters_AST = (AST) currentAST.root;
04256: returnAST = typeParameters_AST;
04257: }
04258:
04259: public final void implements Clause() throws RecognitionException,
04260: TokenStreamException {
04261:
04262: returnAST = null;
04263: ASTPair currentAST = new ASTPair();
04264: AST implements Clause_AST = null;
04265: Token i = null;
04266: AST i_AST = null;
04267: Token first = LT(1);
04268:
04269: {
04270: switch (LA(1)) {
04271: case LITERAL_implements : {
04272: i = LT(1);
04273: i_AST = astFactory.create(i);
04274: match(LITERAL_implements );
04275: nls();
04276: classOrInterfaceType(false);
04277: astFactory.addASTChild(currentAST, returnAST);
04278: {
04279: _loop165: do {
04280: if ((LA(1) == COMMA)) {
04281: match(COMMA);
04282: nls();
04283: classOrInterfaceType(false);
04284: astFactory.addASTChild(currentAST,
04285: returnAST);
04286: } else {
04287: break _loop165;
04288: }
04289:
04290: } while (true);
04291: }
04292: nls();
04293: break;
04294: }
04295: case LCURLY: {
04296: break;
04297: }
04298: default: {
04299: throw new NoViableAltException(LT(1), getFilename());
04300: }
04301: }
04302: }
04303: if (inputState.guessing == 0) {
04304: implements Clause_AST = (AST) currentAST.root;
04305: implements Clause_AST = (AST) astFactory.make((new ASTArray(
04306: 2)).add(
04307: create(IMPLEMENTS_CLAUSE, "IMPLEMENTS_CLAUSE",
04308: first, LT(1))).add(implements Clause_AST));
04309: currentAST.root = implements Clause_AST;
04310: currentAST.child = implements Clause_AST != null
04311: && implements Clause_AST.getFirstChild() != null ? implements Clause_AST
04312: .getFirstChild()
04313: : implements Clause_AST;
04314: currentAST.advanceChildToEnd();
04315: }
04316: implements Clause_AST = (AST) currentAST.root;
04317: returnAST = implements Clause_AST;
04318: }
04319:
04320: public final void classBlock() throws RecognitionException,
04321: TokenStreamException {
04322:
04323: returnAST = null;
04324: ASTPair currentAST = new ASTPair();
04325: AST classBlock_AST = null;
04326: Token first = LT(1);
04327:
04328: match(LCURLY);
04329: {
04330: switch (LA(1)) {
04331: case FINAL:
04332: case ABSTRACT:
04333: case STRICTFP:
04334: case LITERAL_static:
04335: case LITERAL_def:
04336: case AT:
04337: case IDENT:
04338: case LITERAL_class:
04339: case LITERAL_interface:
04340: case LITERAL_enum:
04341: case LITERAL_void:
04342: case LITERAL_boolean:
04343: case LITERAL_byte:
04344: case LITERAL_char:
04345: case LITERAL_short:
04346: case LITERAL_int:
04347: case LITERAL_float:
04348: case LITERAL_long:
04349: case LITERAL_double:
04350: case LITERAL_any:
04351: case LITERAL_private:
04352: case LITERAL_public:
04353: case LITERAL_protected:
04354: case LITERAL_transient:
04355: case LITERAL_native:
04356: case LITERAL_threadsafe:
04357: case LITERAL_synchronized:
04358: case LITERAL_volatile:
04359: case LCURLY: {
04360: classField();
04361: astFactory.addASTChild(currentAST, returnAST);
04362: break;
04363: }
04364: case RCURLY:
04365: case SEMI:
04366: case NLS: {
04367: break;
04368: }
04369: default: {
04370: throw new NoViableAltException(LT(1), getFilename());
04371: }
04372: }
04373: }
04374: {
04375: _loop109: do {
04376: if ((LA(1) == SEMI || LA(1) == NLS)) {
04377: sep();
04378: {
04379: switch (LA(1)) {
04380: case FINAL:
04381: case ABSTRACT:
04382: case STRICTFP:
04383: case LITERAL_static:
04384: case LITERAL_def:
04385: case AT:
04386: case IDENT:
04387: case LITERAL_class:
04388: case LITERAL_interface:
04389: case LITERAL_enum:
04390: case LITERAL_void:
04391: case LITERAL_boolean:
04392: case LITERAL_byte:
04393: case LITERAL_char:
04394: case LITERAL_short:
04395: case LITERAL_int:
04396: case LITERAL_float:
04397: case LITERAL_long:
04398: case LITERAL_double:
04399: case LITERAL_any:
04400: case LITERAL_private:
04401: case LITERAL_public:
04402: case LITERAL_protected:
04403: case LITERAL_transient:
04404: case LITERAL_native:
04405: case LITERAL_threadsafe:
04406: case LITERAL_synchronized:
04407: case LITERAL_volatile:
04408: case LCURLY: {
04409: classField();
04410: astFactory.addASTChild(currentAST,
04411: returnAST);
04412: break;
04413: }
04414: case RCURLY:
04415: case SEMI:
04416: case NLS: {
04417: break;
04418: }
04419: default: {
04420: throw new NoViableAltException(LT(1),
04421: getFilename());
04422: }
04423: }
04424: }
04425: } else {
04426: break _loop109;
04427: }
04428:
04429: } while (true);
04430: }
04431: match(RCURLY);
04432: if (inputState.guessing == 0) {
04433: classBlock_AST = (AST) currentAST.root;
04434: classBlock_AST = (AST) astFactory.make((new ASTArray(2))
04435: .add(create(OBJBLOCK, "OBJBLOCK", first, LT(1)))
04436: .add(classBlock_AST));
04437: currentAST.root = classBlock_AST;
04438: currentAST.child = classBlock_AST != null
04439: && classBlock_AST.getFirstChild() != null ? classBlock_AST
04440: .getFirstChild()
04441: : classBlock_AST;
04442: currentAST.advanceChildToEnd();
04443: }
04444: classBlock_AST = (AST) currentAST.root;
04445: returnAST = classBlock_AST;
04446: }
04447:
04448: public final void interfaceExtends() throws RecognitionException,
04449: TokenStreamException {
04450:
04451: returnAST = null;
04452: ASTPair currentAST = new ASTPair();
04453: AST interfaceExtends_AST = null;
04454: Token e = null;
04455: AST e_AST = null;
04456: Token first = LT(1);
04457:
04458: {
04459: switch (LA(1)) {
04460: case LITERAL_extends: {
04461: e = LT(1);
04462: e_AST = astFactory.create(e);
04463: match(LITERAL_extends);
04464: nls();
04465: classOrInterfaceType(false);
04466: astFactory.addASTChild(currentAST, returnAST);
04467: {
04468: _loop161: do {
04469: if ((LA(1) == COMMA)) {
04470: match(COMMA);
04471: nls();
04472: classOrInterfaceType(false);
04473: astFactory.addASTChild(currentAST,
04474: returnAST);
04475: } else {
04476: break _loop161;
04477: }
04478:
04479: } while (true);
04480: }
04481: nls();
04482: break;
04483: }
04484: case LCURLY: {
04485: break;
04486: }
04487: default: {
04488: throw new NoViableAltException(LT(1), getFilename());
04489: }
04490: }
04491: }
04492: if (inputState.guessing == 0) {
04493: interfaceExtends_AST = (AST) currentAST.root;
04494: interfaceExtends_AST = (AST) astFactory.make((new ASTArray(
04495: 2)).add(
04496: create(EXTENDS_CLAUSE, "EXTENDS_CLAUSE", first,
04497: LT(1))).add(interfaceExtends_AST));
04498: currentAST.root = interfaceExtends_AST;
04499: currentAST.child = interfaceExtends_AST != null
04500: && interfaceExtends_AST.getFirstChild() != null ? interfaceExtends_AST
04501: .getFirstChild()
04502: : interfaceExtends_AST;
04503: currentAST.advanceChildToEnd();
04504: }
04505: interfaceExtends_AST = (AST) currentAST.root;
04506: returnAST = interfaceExtends_AST;
04507: }
04508:
04509: public final void interfaceBlock() throws RecognitionException,
04510: TokenStreamException {
04511:
04512: returnAST = null;
04513: ASTPair currentAST = new ASTPair();
04514: AST interfaceBlock_AST = null;
04515: Token first = LT(1);
04516:
04517: match(LCURLY);
04518: {
04519: switch (LA(1)) {
04520: case FINAL:
04521: case ABSTRACT:
04522: case STRICTFP:
04523: case LITERAL_static:
04524: case LITERAL_def:
04525: case AT:
04526: case IDENT:
04527: case LITERAL_class:
04528: case LITERAL_interface:
04529: case LITERAL_enum:
04530: case LITERAL_void:
04531: case LITERAL_boolean:
04532: case LITERAL_byte:
04533: case LITERAL_char:
04534: case LITERAL_short:
04535: case LITERAL_int:
04536: case LITERAL_float:
04537: case LITERAL_long:
04538: case LITERAL_double:
04539: case LITERAL_any:
04540: case LITERAL_private:
04541: case LITERAL_public:
04542: case LITERAL_protected:
04543: case LITERAL_transient:
04544: case LITERAL_native:
04545: case LITERAL_threadsafe:
04546: case LITERAL_synchronized:
04547: case LITERAL_volatile: {
04548: interfaceField();
04549: astFactory.addASTChild(currentAST, returnAST);
04550: break;
04551: }
04552: case RCURLY:
04553: case SEMI:
04554: case NLS: {
04555: break;
04556: }
04557: default: {
04558: throw new NoViableAltException(LT(1), getFilename());
04559: }
04560: }
04561: }
04562: {
04563: _loop114: do {
04564: if ((LA(1) == SEMI || LA(1) == NLS)) {
04565: sep();
04566: {
04567: switch (LA(1)) {
04568: case FINAL:
04569: case ABSTRACT:
04570: case STRICTFP:
04571: case LITERAL_static:
04572: case LITERAL_def:
04573: case AT:
04574: case IDENT:
04575: case LITERAL_class:
04576: case LITERAL_interface:
04577: case LITERAL_enum:
04578: case LITERAL_void:
04579: case LITERAL_boolean:
04580: case LITERAL_byte:
04581: case LITERAL_char:
04582: case LITERAL_short:
04583: case LITERAL_int:
04584: case LITERAL_float:
04585: case LITERAL_long:
04586: case LITERAL_double:
04587: case LITERAL_any:
04588: case LITERAL_private:
04589: case LITERAL_public:
04590: case LITERAL_protected:
04591: case LITERAL_transient:
04592: case LITERAL_native:
04593: case LITERAL_threadsafe:
04594: case LITERAL_synchronized:
04595: case LITERAL_volatile: {
04596: interfaceField();
04597: astFactory.addASTChild(currentAST,
04598: returnAST);
04599: break;
04600: }
04601: case RCURLY:
04602: case SEMI:
04603: case NLS: {
04604: break;
04605: }
04606: default: {
04607: throw new NoViableAltException(LT(1),
04608: getFilename());
04609: }
04610: }
04611: }
04612: } else {
04613: break _loop114;
04614: }
04615:
04616: } while (true);
04617: }
04618: match(RCURLY);
04619: if (inputState.guessing == 0) {
04620: interfaceBlock_AST = (AST) currentAST.root;
04621: interfaceBlock_AST = (AST) astFactory
04622: .make((new ASTArray(2)).add(
04623: create(OBJBLOCK, "OBJBLOCK", first, LT(1)))
04624: .add(interfaceBlock_AST));
04625: currentAST.root = interfaceBlock_AST;
04626: currentAST.child = interfaceBlock_AST != null
04627: && interfaceBlock_AST.getFirstChild() != null ? interfaceBlock_AST
04628: .getFirstChild()
04629: : interfaceBlock_AST;
04630: currentAST.advanceChildToEnd();
04631: }
04632: interfaceBlock_AST = (AST) currentAST.root;
04633: returnAST = interfaceBlock_AST;
04634: }
04635:
04636: public final void enumBlock() throws RecognitionException,
04637: TokenStreamException {
04638:
04639: returnAST = null;
04640: ASTPair currentAST = new ASTPair();
04641: AST enumBlock_AST = null;
04642: Token first = LT(1);
04643:
04644: match(LCURLY);
04645: {
04646: boolean synPredMatched123 = false;
04647: if (((LA(1) == AT || LA(1) == IDENT)
04648: && (_tokenSet_51.member(LA(2))) && (_tokenSet_52
04649: .member(LA(3))))) {
04650: int _m123 = mark();
04651: synPredMatched123 = true;
04652: inputState.guessing++;
04653: try {
04654: {
04655: enumConstantsStart();
04656: }
04657: } catch (RecognitionException pe) {
04658: synPredMatched123 = false;
04659: }
04660: rewind(_m123);
04661: inputState.guessing--;
04662: }
04663: if (synPredMatched123) {
04664: enumConstants();
04665: astFactory.addASTChild(currentAST, returnAST);
04666: } else if ((_tokenSet_53.member(LA(1)))
04667: && (_tokenSet_54.member(LA(2)))
04668: && (_tokenSet_18.member(LA(3)))) {
04669: {
04670: switch (LA(1)) {
04671: case FINAL:
04672: case ABSTRACT:
04673: case STRICTFP:
04674: case LITERAL_static:
04675: case LITERAL_def:
04676: case AT:
04677: case IDENT:
04678: case LITERAL_class:
04679: case LITERAL_interface:
04680: case LITERAL_enum:
04681: case LITERAL_void:
04682: case LITERAL_boolean:
04683: case LITERAL_byte:
04684: case LITERAL_char:
04685: case LITERAL_short:
04686: case LITERAL_int:
04687: case LITERAL_float:
04688: case LITERAL_long:
04689: case LITERAL_double:
04690: case LITERAL_any:
04691: case LITERAL_private:
04692: case LITERAL_public:
04693: case LITERAL_protected:
04694: case LITERAL_transient:
04695: case LITERAL_native:
04696: case LITERAL_threadsafe:
04697: case LITERAL_synchronized:
04698: case LITERAL_volatile:
04699: case LCURLY: {
04700: classField();
04701: astFactory.addASTChild(currentAST, returnAST);
04702: break;
04703: }
04704: case RCURLY:
04705: case SEMI:
04706: case NLS: {
04707: break;
04708: }
04709: default: {
04710: throw new NoViableAltException(LT(1),
04711: getFilename());
04712: }
04713: }
04714: }
04715: } else {
04716: throw new NoViableAltException(LT(1), getFilename());
04717: }
04718:
04719: }
04720: {
04721: _loop127: do {
04722: if ((LA(1) == SEMI || LA(1) == NLS)) {
04723: sep();
04724: {
04725: switch (LA(1)) {
04726: case FINAL:
04727: case ABSTRACT:
04728: case STRICTFP:
04729: case LITERAL_static:
04730: case LITERAL_def:
04731: case AT:
04732: case IDENT:
04733: case LITERAL_class:
04734: case LITERAL_interface:
04735: case LITERAL_enum:
04736: case LITERAL_void:
04737: case LITERAL_boolean:
04738: case LITERAL_byte:
04739: case LITERAL_char:
04740: case LITERAL_short:
04741: case LITERAL_int:
04742: case LITERAL_float:
04743: case LITERAL_long:
04744: case LITERAL_double:
04745: case LITERAL_any:
04746: case LITERAL_private:
04747: case LITERAL_public:
04748: case LITERAL_protected:
04749: case LITERAL_transient:
04750: case LITERAL_native:
04751: case LITERAL_threadsafe:
04752: case LITERAL_synchronized:
04753: case LITERAL_volatile:
04754: case LCURLY: {
04755: classField();
04756: astFactory.addASTChild(currentAST,
04757: returnAST);
04758: break;
04759: }
04760: case RCURLY:
04761: case SEMI:
04762: case NLS: {
04763: break;
04764: }
04765: default: {
04766: throw new NoViableAltException(LT(1),
04767: getFilename());
04768: }
04769: }
04770: }
04771: } else {
04772: break _loop127;
04773: }
04774:
04775: } while (true);
04776: }
04777: match(RCURLY);
04778: if (inputState.guessing == 0) {
04779: enumBlock_AST = (AST) currentAST.root;
04780: enumBlock_AST = (AST) astFactory.make((new ASTArray(2))
04781: .add(create(OBJBLOCK, "OBJBLOCK", first, LT(1)))
04782: .add(enumBlock_AST));
04783: currentAST.root = enumBlock_AST;
04784: currentAST.child = enumBlock_AST != null
04785: && enumBlock_AST.getFirstChild() != null ? enumBlock_AST
04786: .getFirstChild()
04787: : enumBlock_AST;
04788: currentAST.advanceChildToEnd();
04789: }
04790: enumBlock_AST = (AST) currentAST.root;
04791: returnAST = enumBlock_AST;
04792: }
04793:
04794: public final void annotationBlock() throws RecognitionException,
04795: TokenStreamException {
04796:
04797: returnAST = null;
04798: ASTPair currentAST = new ASTPair();
04799: AST annotationBlock_AST = null;
04800: Token first = LT(1);
04801:
04802: match(LCURLY);
04803: {
04804: switch (LA(1)) {
04805: case FINAL:
04806: case ABSTRACT:
04807: case STRICTFP:
04808: case LITERAL_static:
04809: case LITERAL_def:
04810: case AT:
04811: case IDENT:
04812: case LITERAL_class:
04813: case LITERAL_interface:
04814: case LITERAL_enum:
04815: case LITERAL_void:
04816: case LITERAL_boolean:
04817: case LITERAL_byte:
04818: case LITERAL_char:
04819: case LITERAL_short:
04820: case LITERAL_int:
04821: case LITERAL_float:
04822: case LITERAL_long:
04823: case LITERAL_double:
04824: case LITERAL_any:
04825: case LITERAL_private:
04826: case LITERAL_public:
04827: case LITERAL_protected:
04828: case LITERAL_transient:
04829: case LITERAL_native:
04830: case LITERAL_threadsafe:
04831: case LITERAL_synchronized:
04832: case LITERAL_volatile: {
04833: annotationField();
04834: astFactory.addASTChild(currentAST, returnAST);
04835: break;
04836: }
04837: case RCURLY:
04838: case SEMI:
04839: case NLS: {
04840: break;
04841: }
04842: default: {
04843: throw new NoViableAltException(LT(1), getFilename());
04844: }
04845: }
04846: }
04847: {
04848: _loop119: do {
04849: if ((LA(1) == SEMI || LA(1) == NLS)) {
04850: sep();
04851: {
04852: switch (LA(1)) {
04853: case FINAL:
04854: case ABSTRACT:
04855: case STRICTFP:
04856: case LITERAL_static:
04857: case LITERAL_def:
04858: case AT:
04859: case IDENT:
04860: case LITERAL_class:
04861: case LITERAL_interface:
04862: case LITERAL_enum:
04863: case LITERAL_void:
04864: case LITERAL_boolean:
04865: case LITERAL_byte:
04866: case LITERAL_char:
04867: case LITERAL_short:
04868: case LITERAL_int:
04869: case LITERAL_float:
04870: case LITERAL_long:
04871: case LITERAL_double:
04872: case LITERAL_any:
04873: case LITERAL_private:
04874: case LITERAL_public:
04875: case LITERAL_protected:
04876: case LITERAL_transient:
04877: case LITERAL_native:
04878: case LITERAL_threadsafe:
04879: case LITERAL_synchronized:
04880: case LITERAL_volatile: {
04881: annotationField();
04882: astFactory.addASTChild(currentAST,
04883: returnAST);
04884: break;
04885: }
04886: case RCURLY:
04887: case SEMI:
04888: case NLS: {
04889: break;
04890: }
04891: default: {
04892: throw new NoViableAltException(LT(1),
04893: getFilename());
04894: }
04895: }
04896: }
04897: } else {
04898: break _loop119;
04899: }
04900:
04901: } while (true);
04902: }
04903: match(RCURLY);
04904: if (inputState.guessing == 0) {
04905: annotationBlock_AST = (AST) currentAST.root;
04906: annotationBlock_AST = (AST) astFactory
04907: .make((new ASTArray(2)).add(
04908: create(OBJBLOCK, "OBJBLOCK", first, LT(1)))
04909: .add(annotationBlock_AST));
04910: currentAST.root = annotationBlock_AST;
04911: currentAST.child = annotationBlock_AST != null
04912: && annotationBlock_AST.getFirstChild() != null ? annotationBlock_AST
04913: .getFirstChild()
04914: : annotationBlock_AST;
04915: currentAST.advanceChildToEnd();
04916: }
04917: annotationBlock_AST = (AST) currentAST.root;
04918: returnAST = annotationBlock_AST;
04919: }
04920:
04921: public final void typeParameter() throws RecognitionException,
04922: TokenStreamException {
04923:
04924: returnAST = null;
04925: ASTPair currentAST = new ASTPair();
04926: AST typeParameter_AST = null;
04927: Token id = null;
04928: AST id_AST = null;
04929: Token first = LT(1);
04930:
04931: {
04932: id = LT(1);
04933: id_AST = astFactory.create(id);
04934: astFactory.addASTChild(currentAST, id_AST);
04935: match(IDENT);
04936: }
04937: {
04938: if ((LA(1) == LITERAL_extends)
04939: && (LA(2) == IDENT || LA(2) == NLS)
04940: && (_tokenSet_55.member(LA(3)))) {
04941: typeParameterBounds();
04942: astFactory.addASTChild(currentAST, returnAST);
04943: } else if ((_tokenSet_56.member(LA(1)))
04944: && (_tokenSet_57.member(LA(2)))
04945: && (_tokenSet_58.member(LA(3)))) {
04946: } else {
04947: throw new NoViableAltException(LT(1), getFilename());
04948: }
04949:
04950: }
04951: if (inputState.guessing == 0) {
04952: typeParameter_AST = (AST) currentAST.root;
04953: typeParameter_AST = (AST) astFactory.make((new ASTArray(2))
04954: .add(
04955: create(TYPE_PARAMETER, "TYPE_PARAMETER",
04956: first, LT(1))).add(
04957: typeParameter_AST));
04958: currentAST.root = typeParameter_AST;
04959: currentAST.child = typeParameter_AST != null
04960: && typeParameter_AST.getFirstChild() != null ? typeParameter_AST
04961: .getFirstChild()
04962: : typeParameter_AST;
04963: currentAST.advanceChildToEnd();
04964: }
04965: typeParameter_AST = (AST) currentAST.root;
04966: returnAST = typeParameter_AST;
04967: }
04968:
04969: public final void typeParameterBounds()
04970: throws RecognitionException, TokenStreamException {
04971:
04972: returnAST = null;
04973: ASTPair currentAST = new ASTPair();
04974: AST typeParameterBounds_AST = null;
04975: Token first = LT(1);
04976:
04977: match(LITERAL_extends);
04978: nls();
04979: classOrInterfaceType(false);
04980: astFactory.addASTChild(currentAST, returnAST);
04981: {
04982: _loop104: do {
04983: if ((LA(1) == BAND)) {
04984: match(BAND);
04985: nls();
04986: classOrInterfaceType(false);
04987: astFactory.addASTChild(currentAST, returnAST);
04988: } else {
04989: break _loop104;
04990: }
04991:
04992: } while (true);
04993: }
04994: if (inputState.guessing == 0) {
04995: typeParameterBounds_AST = (AST) currentAST.root;
04996: typeParameterBounds_AST = (AST) astFactory
04997: .make((new ASTArray(2)).add(
04998: create(TYPE_UPPER_BOUNDS,
04999: "TYPE_UPPER_BOUNDS", first, LT(1)))
05000: .add(typeParameterBounds_AST));
05001: currentAST.root = typeParameterBounds_AST;
05002: currentAST.child = typeParameterBounds_AST != null
05003: && typeParameterBounds_AST.getFirstChild() != null ? typeParameterBounds_AST
05004: .getFirstChild()
05005: : typeParameterBounds_AST;
05006: currentAST.advanceChildToEnd();
05007: }
05008: typeParameterBounds_AST = (AST) currentAST.root;
05009: returnAST = typeParameterBounds_AST;
05010: }
05011:
05012: public final void classField() throws RecognitionException,
05013: TokenStreamException {
05014:
05015: returnAST = null;
05016: ASTPair currentAST = new ASTPair();
05017: AST classField_AST = null;
05018: AST mc_AST = null;
05019: AST ctor_AST = null;
05020: AST d_AST = null;
05021: AST mods_AST = null;
05022: AST td_AST = null;
05023: AST s3_AST = null;
05024: AST s4_AST = null;
05025: Token first = LT(1);
05026:
05027: boolean synPredMatched168 = false;
05028: if (((_tokenSet_59.member(LA(1)))
05029: && (_tokenSet_60.member(LA(2))) && (_tokenSet_61
05030: .member(LA(3))))) {
05031: int _m168 = mark();
05032: synPredMatched168 = true;
05033: inputState.guessing++;
05034: try {
05035: {
05036: constructorStart();
05037: }
05038: } catch (RecognitionException pe) {
05039: synPredMatched168 = false;
05040: }
05041: rewind(_m168);
05042: inputState.guessing--;
05043: }
05044: if (synPredMatched168) {
05045: modifiersOpt();
05046: mc_AST = (AST) returnAST;
05047: constructorDefinition(mc_AST);
05048: ctor_AST = (AST) returnAST;
05049: if (inputState.guessing == 0) {
05050: classField_AST = (AST) currentAST.root;
05051: classField_AST = ctor_AST;
05052: currentAST.root = classField_AST;
05053: currentAST.child = classField_AST != null
05054: && classField_AST.getFirstChild() != null ? classField_AST
05055: .getFirstChild()
05056: : classField_AST;
05057: currentAST.advanceChildToEnd();
05058: }
05059: } else {
05060: boolean synPredMatched170 = false;
05061: if (((_tokenSet_12.member(LA(1)))
05062: && (_tokenSet_13.member(LA(2))) && (_tokenSet_62
05063: .member(LA(3))))) {
05064: int _m170 = mark();
05065: synPredMatched170 = true;
05066: inputState.guessing++;
05067: try {
05068: {
05069: declarationStart();
05070: }
05071: } catch (RecognitionException pe) {
05072: synPredMatched170 = false;
05073: }
05074: rewind(_m170);
05075: inputState.guessing--;
05076: }
05077: if (synPredMatched170) {
05078: declaration();
05079: d_AST = (AST) returnAST;
05080: if (inputState.guessing == 0) {
05081: classField_AST = (AST) currentAST.root;
05082: classField_AST = d_AST;
05083: currentAST.root = classField_AST;
05084: currentAST.child = classField_AST != null
05085: && classField_AST.getFirstChild() != null ? classField_AST
05086: .getFirstChild()
05087: : classField_AST;
05088: currentAST.advanceChildToEnd();
05089: }
05090: } else {
05091: boolean synPredMatched172 = false;
05092: if (((_tokenSet_21.member(LA(1)))
05093: && (_tokenSet_22.member(LA(2))) && (_tokenSet_23
05094: .member(LA(3))))) {
05095: int _m172 = mark();
05096: synPredMatched172 = true;
05097: inputState.guessing++;
05098: try {
05099: {
05100: typeDeclarationStart();
05101: }
05102: } catch (RecognitionException pe) {
05103: synPredMatched172 = false;
05104: }
05105: rewind(_m172);
05106: inputState.guessing--;
05107: }
05108: if (synPredMatched172) {
05109: modifiersOpt();
05110: mods_AST = (AST) returnAST;
05111: {
05112: typeDefinitionInternal(mods_AST);
05113: td_AST = (AST) returnAST;
05114: if (inputState.guessing == 0) {
05115: classField_AST = (AST) currentAST.root;
05116: classField_AST = td_AST;
05117: currentAST.root = classField_AST;
05118: currentAST.child = classField_AST != null
05119: && classField_AST.getFirstChild() != null ? classField_AST
05120: .getFirstChild()
05121: : classField_AST;
05122: currentAST.advanceChildToEnd();
05123: }
05124: }
05125: } else if ((LA(1) == LITERAL_static)
05126: && (LA(2) == LCURLY)) {
05127: match(LITERAL_static);
05128: compoundStatement();
05129: s3_AST = (AST) returnAST;
05130: if (inputState.guessing == 0) {
05131: classField_AST = (AST) currentAST.root;
05132: classField_AST = (AST) astFactory
05133: .make((new ASTArray(2)).add(
05134: create(STATIC_INIT,
05135: "STATIC_INIT", first,
05136: LT(1))).add(s3_AST));
05137: currentAST.root = classField_AST;
05138: currentAST.child = classField_AST != null
05139: && classField_AST.getFirstChild() != null ? classField_AST
05140: .getFirstChild()
05141: : classField_AST;
05142: currentAST.advanceChildToEnd();
05143: }
05144: } else if ((LA(1) == LCURLY)) {
05145: compoundStatement();
05146: s4_AST = (AST) returnAST;
05147: if (inputState.guessing == 0) {
05148: classField_AST = (AST) currentAST.root;
05149: classField_AST = (AST) astFactory
05150: .make((new ASTArray(2)).add(
05151: create(INSTANCE_INIT,
05152: "INSTANCE_INIT", first,
05153: LT(1))).add(s4_AST));
05154: currentAST.root = classField_AST;
05155: currentAST.child = classField_AST != null
05156: && classField_AST.getFirstChild() != null ? classField_AST
05157: .getFirstChild()
05158: : classField_AST;
05159: currentAST.advanceChildToEnd();
05160: }
05161: } else {
05162: throw new NoViableAltException(LT(1), getFilename());
05163: }
05164: }
05165: }
05166: returnAST = classField_AST;
05167: }
05168:
05169: public final void interfaceField() throws RecognitionException,
05170: TokenStreamException {
05171:
05172: returnAST = null;
05173: ASTPair currentAST = new ASTPair();
05174: AST interfaceField_AST = null;
05175: AST d_AST = null;
05176: AST mods_AST = null;
05177: AST td_AST = null;
05178:
05179: boolean synPredMatched176 = false;
05180: if (((_tokenSet_12.member(LA(1)))
05181: && (_tokenSet_13.member(LA(2))) && (_tokenSet_62
05182: .member(LA(3))))) {
05183: int _m176 = mark();
05184: synPredMatched176 = true;
05185: inputState.guessing++;
05186: try {
05187: {
05188: declarationStart();
05189: }
05190: } catch (RecognitionException pe) {
05191: synPredMatched176 = false;
05192: }
05193: rewind(_m176);
05194: inputState.guessing--;
05195: }
05196: if (synPredMatched176) {
05197: declaration();
05198: d_AST = (AST) returnAST;
05199: if (inputState.guessing == 0) {
05200: interfaceField_AST = (AST) currentAST.root;
05201: interfaceField_AST = d_AST;
05202: currentAST.root = interfaceField_AST;
05203: currentAST.child = interfaceField_AST != null
05204: && interfaceField_AST.getFirstChild() != null ? interfaceField_AST
05205: .getFirstChild()
05206: : interfaceField_AST;
05207: currentAST.advanceChildToEnd();
05208: }
05209: } else {
05210: boolean synPredMatched178 = false;
05211: if (((_tokenSet_21.member(LA(1)))
05212: && (_tokenSet_22.member(LA(2))) && (_tokenSet_23
05213: .member(LA(3))))) {
05214: int _m178 = mark();
05215: synPredMatched178 = true;
05216: inputState.guessing++;
05217: try {
05218: {
05219: typeDeclarationStart();
05220: }
05221: } catch (RecognitionException pe) {
05222: synPredMatched178 = false;
05223: }
05224: rewind(_m178);
05225: inputState.guessing--;
05226: }
05227: if (synPredMatched178) {
05228: modifiersOpt();
05229: mods_AST = (AST) returnAST;
05230: {
05231: typeDefinitionInternal(mods_AST);
05232: td_AST = (AST) returnAST;
05233: if (inputState.guessing == 0) {
05234: interfaceField_AST = (AST) currentAST.root;
05235: interfaceField_AST = td_AST;
05236: currentAST.root = interfaceField_AST;
05237: currentAST.child = interfaceField_AST != null
05238: && interfaceField_AST.getFirstChild() != null ? interfaceField_AST
05239: .getFirstChild()
05240: : interfaceField_AST;
05241: currentAST.advanceChildToEnd();
05242: }
05243: }
05244: } else {
05245: throw new NoViableAltException(LT(1), getFilename());
05246: }
05247: }
05248: returnAST = interfaceField_AST;
05249: }
05250:
05251: public final void annotationField() throws RecognitionException,
05252: TokenStreamException {
05253:
05254: returnAST = null;
05255: ASTPair currentAST = new ASTPair();
05256: AST annotationField_AST = null;
05257: AST mods_AST = null;
05258: AST td_AST = null;
05259: AST t_AST = null;
05260: Token i = null;
05261: AST i_AST = null;
05262: AST amvi_AST = null;
05263: AST v_AST = null;
05264: Token first = LT(1);
05265:
05266: modifiersOpt();
05267: mods_AST = (AST) returnAST;
05268: {
05269: switch (LA(1)) {
05270: case AT:
05271: case LITERAL_class:
05272: case LITERAL_interface:
05273: case LITERAL_enum: {
05274: typeDefinitionInternal(mods_AST);
05275: td_AST = (AST) returnAST;
05276: if (inputState.guessing == 0) {
05277: annotationField_AST = (AST) currentAST.root;
05278: annotationField_AST = td_AST;
05279: currentAST.root = annotationField_AST;
05280: currentAST.child = annotationField_AST != null
05281: && annotationField_AST.getFirstChild() != null ? annotationField_AST
05282: .getFirstChild()
05283: : annotationField_AST;
05284: currentAST.advanceChildToEnd();
05285: }
05286: break;
05287: }
05288: case IDENT:
05289: case LITERAL_void:
05290: case LITERAL_boolean:
05291: case LITERAL_byte:
05292: case LITERAL_char:
05293: case LITERAL_short:
05294: case LITERAL_int:
05295: case LITERAL_float:
05296: case LITERAL_long:
05297: case LITERAL_double:
05298: case LITERAL_any: {
05299: typeSpec(false);
05300: t_AST = (AST) returnAST;
05301: {
05302: boolean synPredMatched138 = false;
05303: if (((LA(1) == IDENT) && (LA(2) == LPAREN) && (LA(3) == RPAREN))) {
05304: int _m138 = mark();
05305: synPredMatched138 = true;
05306: inputState.guessing++;
05307: try {
05308: {
05309: match(IDENT);
05310: match(LPAREN);
05311: }
05312: } catch (RecognitionException pe) {
05313: synPredMatched138 = false;
05314: }
05315: rewind(_m138);
05316: inputState.guessing--;
05317: }
05318: if (synPredMatched138) {
05319: i = LT(1);
05320: i_AST = astFactory.create(i);
05321: match(IDENT);
05322: match(LPAREN);
05323: match(RPAREN);
05324: {
05325: switch (LA(1)) {
05326: case LITERAL_default: {
05327: match(LITERAL_default);
05328: nls();
05329: annotationMemberValueInitializer();
05330: amvi_AST = (AST) returnAST;
05331: break;
05332: }
05333: case RCURLY:
05334: case SEMI:
05335: case NLS: {
05336: break;
05337: }
05338: default: {
05339: throw new NoViableAltException(LT(1),
05340: getFilename());
05341: }
05342: }
05343: }
05344: if (inputState.guessing == 0) {
05345: annotationField_AST = (AST) currentAST.root;
05346: annotationField_AST = (AST) astFactory
05347: .make((new ASTArray(5))
05348: .add(
05349: create(
05350: ANNOTATION_FIELD_DEF,
05351: "ANNOTATION_FIELD_DEF",
05352: first,
05353: LT(1)))
05354: .add(mods_AST)
05355: .add(
05356: (AST) astFactory
05357: .make((new ASTArray(
05358: 2))
05359: .add(
05360: create(
05361: TYPE,
05362: "TYPE",
05363: first,
05364: LT(1)))
05365: .add(
05366: t_AST)))
05367: .add(i_AST).add(amvi_AST));
05368: currentAST.root = annotationField_AST;
05369: currentAST.child = annotationField_AST != null
05370: && annotationField_AST
05371: .getFirstChild() != null ? annotationField_AST
05372: .getFirstChild()
05373: : annotationField_AST;
05374: currentAST.advanceChildToEnd();
05375: }
05376: } else if ((LA(1) == IDENT || LA(1) == STRING_LITERAL)
05377: && (_tokenSet_63.member(LA(2)))
05378: && (_tokenSet_64.member(LA(3)))) {
05379: variableDefinitions(mods_AST, t_AST);
05380: v_AST = (AST) returnAST;
05381: if (inputState.guessing == 0) {
05382: annotationField_AST = (AST) currentAST.root;
05383: annotationField_AST = v_AST;
05384: currentAST.root = annotationField_AST;
05385: currentAST.child = annotationField_AST != null
05386: && annotationField_AST
05387: .getFirstChild() != null ? annotationField_AST
05388: .getFirstChild()
05389: : annotationField_AST;
05390: currentAST.advanceChildToEnd();
05391: }
05392: } else {
05393: throw new NoViableAltException(LT(1),
05394: getFilename());
05395: }
05396:
05397: }
05398: break;
05399: }
05400: default: {
05401: throw new NoViableAltException(LT(1), getFilename());
05402: }
05403: }
05404: }
05405: returnAST = annotationField_AST;
05406: }
05407:
05408: /** Guard for enumConstants. */
05409: public final void enumConstantsStart() throws RecognitionException,
05410: TokenStreamException {
05411:
05412: returnAST = null;
05413: ASTPair currentAST = new ASTPair();
05414: AST enumConstantsStart_AST = null;
05415:
05416: enumConstant();
05417: astFactory.addASTChild(currentAST, returnAST);
05418: {
05419: switch (LA(1)) {
05420: case COMMA: {
05421: AST tmp129_AST = null;
05422: tmp129_AST = astFactory.create(LT(1));
05423: astFactory.addASTChild(currentAST, tmp129_AST);
05424: match(COMMA);
05425: break;
05426: }
05427: case SEMI: {
05428: AST tmp130_AST = null;
05429: tmp130_AST = astFactory.create(LT(1));
05430: astFactory.addASTChild(currentAST, tmp130_AST);
05431: match(SEMI);
05432: break;
05433: }
05434: case NLS: {
05435: AST tmp131_AST = null;
05436: tmp131_AST = astFactory.create(LT(1));
05437: astFactory.addASTChild(currentAST, tmp131_AST);
05438: match(NLS);
05439: break;
05440: }
05441: case RCURLY: {
05442: AST tmp132_AST = null;
05443: tmp132_AST = astFactory.create(LT(1));
05444: astFactory.addASTChild(currentAST, tmp132_AST);
05445: match(RCURLY);
05446: break;
05447: }
05448: default: {
05449: throw new NoViableAltException(LT(1), getFilename());
05450: }
05451: }
05452: }
05453: enumConstantsStart_AST = (AST) currentAST.root;
05454: returnAST = enumConstantsStart_AST;
05455: }
05456:
05457: /** Comma-separated list of one or more enum constant definitions. */
05458: public final void enumConstants() throws RecognitionException,
05459: TokenStreamException {
05460:
05461: returnAST = null;
05462: ASTPair currentAST = new ASTPair();
05463: AST enumConstants_AST = null;
05464:
05465: enumConstant();
05466: astFactory.addASTChild(currentAST, returnAST);
05467: {
05468: _loop132: do {
05469: if ((LA(1) == COMMA) && (_tokenSet_65.member(LA(2)))
05470: && (_tokenSet_66.member(LA(3)))) {
05471: match(COMMA);
05472: nls();
05473: enumConstant();
05474: astFactory.addASTChild(currentAST, returnAST);
05475: } else {
05476: break _loop132;
05477: }
05478:
05479: } while (true);
05480: }
05481: {
05482: switch (LA(1)) {
05483: case COMMA: {
05484: match(COMMA);
05485: nls();
05486: break;
05487: }
05488: case RCURLY:
05489: case SEMI:
05490: case NLS: {
05491: break;
05492: }
05493: default: {
05494: throw new NoViableAltException(LT(1), getFilename());
05495: }
05496: }
05497: }
05498: enumConstants_AST = (AST) currentAST.root;
05499: returnAST = enumConstants_AST;
05500: }
05501:
05502: public final void enumConstant() throws RecognitionException,
05503: TokenStreamException {
05504:
05505: returnAST = null;
05506: ASTPair currentAST = new ASTPair();
05507: AST enumConstant_AST = null;
05508: AST an_AST = null;
05509: Token i = null;
05510: AST i_AST = null;
05511: AST a_AST = null;
05512: AST b_AST = null;
05513: Token first = LT(1);
05514:
05515: annotationsOpt();
05516: an_AST = (AST) returnAST;
05517: i = LT(1);
05518: i_AST = astFactory.create(i);
05519: match(IDENT);
05520: {
05521: switch (LA(1)) {
05522: case LPAREN: {
05523: match(LPAREN);
05524: argList();
05525: a_AST = (AST) returnAST;
05526: match(RPAREN);
05527: break;
05528: }
05529: case COMMA:
05530: case LCURLY:
05531: case RCURLY:
05532: case SEMI:
05533: case NLS: {
05534: break;
05535: }
05536: default: {
05537: throw new NoViableAltException(LT(1), getFilename());
05538: }
05539: }
05540: }
05541: {
05542: switch (LA(1)) {
05543: case LCURLY: {
05544: enumConstantBlock();
05545: b_AST = (AST) returnAST;
05546: break;
05547: }
05548: case COMMA:
05549: case RCURLY:
05550: case SEMI:
05551: case NLS: {
05552: break;
05553: }
05554: default: {
05555: throw new NoViableAltException(LT(1), getFilename());
05556: }
05557: }
05558: }
05559: if (inputState.guessing == 0) {
05560: enumConstant_AST = (AST) currentAST.root;
05561: enumConstant_AST = (AST) astFactory.make((new ASTArray(5))
05562: .add(
05563: create(ENUM_CONSTANT_DEF,
05564: "ENUM_CONSTANT_DEF", first, LT(1)))
05565: .add(an_AST).add(i_AST).add(a_AST).add(b_AST));
05566: currentAST.root = enumConstant_AST;
05567: currentAST.child = enumConstant_AST != null
05568: && enumConstant_AST.getFirstChild() != null ? enumConstant_AST
05569: .getFirstChild()
05570: : enumConstant_AST;
05571: currentAST.advanceChildToEnd();
05572: }
05573: returnAST = enumConstant_AST;
05574: }
05575:
05576: public final void argList() throws RecognitionException,
05577: TokenStreamException {
05578:
05579: returnAST = null;
05580: ASTPair currentAST = new ASTPair();
05581: AST argList_AST = null;
05582: Token first = LT(1);
05583: boolean hl = false, hl2;
05584:
05585: {
05586: switch (LA(1)) {
05587: case FINAL:
05588: case ABSTRACT:
05589: case UNUSED_DO:
05590: case STRICTFP:
05591: case LITERAL_static:
05592: case LITERAL_def:
05593: case AT:
05594: case IDENT:
05595: case LBRACK:
05596: case LPAREN:
05597: case LITERAL_class:
05598: case LITERAL_super :
05599: case LITERAL_void:
05600: case LITERAL_boolean:
05601: case LITERAL_byte:
05602: case LITERAL_char:
05603: case LITERAL_short:
05604: case LITERAL_int:
05605: case LITERAL_float:
05606: case LITERAL_long:
05607: case LITERAL_double:
05608: case LITERAL_any:
05609: case STAR:
05610: case LITERAL_as:
05611: case LITERAL_private:
05612: case LITERAL_public:
05613: case LITERAL_protected:
05614: case LITERAL_transient:
05615: case LITERAL_native:
05616: case LITERAL_threadsafe:
05617: case LITERAL_synchronized:
05618: case LITERAL_volatile:
05619: case LCURLY:
05620: case LITERAL_this :
05621: case STRING_LITERAL:
05622: case LITERAL_if:
05623: case LITERAL_else:
05624: case LITERAL_while:
05625: case LITERAL_switch:
05626: case LITERAL_for:
05627: case LITERAL_in:
05628: case LITERAL_return:
05629: case LITERAL_break:
05630: case LITERAL_continue:
05631: case LITERAL_throw:
05632: case LITERAL_assert:
05633: case PLUS:
05634: case MINUS:
05635: case LITERAL_try:
05636: case LITERAL_finally:
05637: case LITERAL_catch:
05638: case INC:
05639: case DEC:
05640: case BNOT:
05641: case LNOT:
05642: case DOLLAR:
05643: case STRING_CTOR_START:
05644: case LITERAL_new:
05645: case LITERAL_true:
05646: case LITERAL_false:
05647: case LITERAL_null:
05648: case NUM_INT:
05649: case NUM_FLOAT:
05650: case NUM_LONG:
05651: case NUM_DOUBLE:
05652: case NUM_BIG_INT:
05653: case NUM_BIG_DECIMAL: {
05654: hl = argument();
05655: astFactory.addASTChild(currentAST, returnAST);
05656: {
05657: _loop446: do {
05658: if ((LA(1) == COMMA)
05659: && (_tokenSet_67.member(LA(2)))
05660: && (_tokenSet_68.member(LA(3)))) {
05661: match(COMMA);
05662: hl2 = argument();
05663: astFactory.addASTChild(currentAST,
05664: returnAST);
05665: if (inputState.guessing == 0) {
05666: hl |= hl2;
05667: }
05668: } else {
05669: break _loop446;
05670: }
05671:
05672: } while (true);
05673: }
05674: if (inputState.guessing == 0) {
05675: argList_AST = (AST) currentAST.root;
05676: argList_AST = (AST) astFactory
05677: .make((new ASTArray(2))
05678: .add(
05679: create(ELIST, "ELIST",
05680: first, LT(1))).add(
05681: argList_AST));
05682: currentAST.root = argList_AST;
05683: currentAST.child = argList_AST != null
05684: && argList_AST.getFirstChild() != null ? argList_AST
05685: .getFirstChild()
05686: : argList_AST;
05687: currentAST.advanceChildToEnd();
05688: }
05689: break;
05690: }
05691: case RBRACK:
05692: case COMMA:
05693: case RPAREN: {
05694: if (inputState.guessing == 0) {
05695: argList_AST = (AST) currentAST.root;
05696: argList_AST = create(ELIST, "ELIST", first, LT(1));
05697: currentAST.root = argList_AST;
05698: currentAST.child = argList_AST != null
05699: && argList_AST.getFirstChild() != null ? argList_AST
05700: .getFirstChild()
05701: : argList_AST;
05702: currentAST.advanceChildToEnd();
05703: }
05704: break;
05705: }
05706: default: {
05707: throw new NoViableAltException(LT(1), getFilename());
05708: }
05709: }
05710: }
05711: {
05712: switch (LA(1)) {
05713: case COMMA: {
05714: match(COMMA);
05715: break;
05716: }
05717: case RBRACK:
05718: case RPAREN: {
05719: break;
05720: }
05721: default: {
05722: throw new NoViableAltException(LT(1), getFilename());
05723: }
05724: }
05725: }
05726: if (inputState.guessing == 0) {
05727: argListHasLabels = hl;
05728: }
05729: argList_AST = (AST) currentAST.root;
05730: returnAST = argList_AST;
05731: }
05732:
05733: public final void enumConstantBlock() throws RecognitionException,
05734: TokenStreamException {
05735:
05736: returnAST = null;
05737: ASTPair currentAST = new ASTPair();
05738: AST enumConstantBlock_AST = null;
05739: Token first = LT(1);
05740:
05741: match(LCURLY);
05742: {
05743: switch (LA(1)) {
05744: case FINAL:
05745: case ABSTRACT:
05746: case STRICTFP:
05747: case LITERAL_static:
05748: case LITERAL_def:
05749: case AT:
05750: case IDENT:
05751: case LITERAL_class:
05752: case LITERAL_interface:
05753: case LITERAL_enum:
05754: case LT:
05755: case LITERAL_void:
05756: case LITERAL_boolean:
05757: case LITERAL_byte:
05758: case LITERAL_char:
05759: case LITERAL_short:
05760: case LITERAL_int:
05761: case LITERAL_float:
05762: case LITERAL_long:
05763: case LITERAL_double:
05764: case LITERAL_any:
05765: case LITERAL_private:
05766: case LITERAL_public:
05767: case LITERAL_protected:
05768: case LITERAL_transient:
05769: case LITERAL_native:
05770: case LITERAL_threadsafe:
05771: case LITERAL_synchronized:
05772: case LITERAL_volatile:
05773: case LCURLY: {
05774: enumConstantField();
05775: astFactory.addASTChild(currentAST, returnAST);
05776: break;
05777: }
05778: case RCURLY:
05779: case SEMI:
05780: case NLS: {
05781: break;
05782: }
05783: default: {
05784: throw new NoViableAltException(LT(1), getFilename());
05785: }
05786: }
05787: }
05788: {
05789: _loop147: do {
05790: if ((LA(1) == SEMI || LA(1) == NLS)) {
05791: sep();
05792: {
05793: switch (LA(1)) {
05794: case FINAL:
05795: case ABSTRACT:
05796: case STRICTFP:
05797: case LITERAL_static:
05798: case LITERAL_def:
05799: case AT:
05800: case IDENT:
05801: case LITERAL_class:
05802: case LITERAL_interface:
05803: case LITERAL_enum:
05804: case LT:
05805: case LITERAL_void:
05806: case LITERAL_boolean:
05807: case LITERAL_byte:
05808: case LITERAL_char:
05809: case LITERAL_short:
05810: case LITERAL_int:
05811: case LITERAL_float:
05812: case LITERAL_long:
05813: case LITERAL_double:
05814: case LITERAL_any:
05815: case LITERAL_private:
05816: case LITERAL_public:
05817: case LITERAL_protected:
05818: case LITERAL_transient:
05819: case LITERAL_native:
05820: case LITERAL_threadsafe:
05821: case LITERAL_synchronized:
05822: case LITERAL_volatile:
05823: case LCURLY: {
05824: enumConstantField();
05825: astFactory.addASTChild(currentAST,
05826: returnAST);
05827: break;
05828: }
05829: case RCURLY:
05830: case SEMI:
05831: case NLS: {
05832: break;
05833: }
05834: default: {
05835: throw new NoViableAltException(LT(1),
05836: getFilename());
05837: }
05838: }
05839: }
05840: } else {
05841: break _loop147;
05842: }
05843:
05844: } while (true);
05845: }
05846: match(RCURLY);
05847: if (inputState.guessing == 0) {
05848: enumConstantBlock_AST = (AST) currentAST.root;
05849: enumConstantBlock_AST = (AST) astFactory
05850: .make((new ASTArray(2)).add(
05851: create(OBJBLOCK, "OBJBLOCK", first, LT(1)))
05852: .add(enumConstantBlock_AST));
05853: currentAST.root = enumConstantBlock_AST;
05854: currentAST.child = enumConstantBlock_AST != null
05855: && enumConstantBlock_AST.getFirstChild() != null ? enumConstantBlock_AST
05856: .getFirstChild()
05857: : enumConstantBlock_AST;
05858: currentAST.advanceChildToEnd();
05859: }
05860: enumConstantBlock_AST = (AST) currentAST.root;
05861: returnAST = enumConstantBlock_AST;
05862: }
05863:
05864: public final void enumConstantField() throws RecognitionException,
05865: TokenStreamException {
05866:
05867: returnAST = null;
05868: ASTPair currentAST = new ASTPair();
05869: AST enumConstantField_AST = null;
05870: AST mods_AST = null;
05871: AST td_AST = null;
05872: AST tp_AST = null;
05873: AST t_AST = null;
05874: AST param_AST = null;
05875: AST tc_AST = null;
05876: AST s2_AST = null;
05877: AST v_AST = null;
05878: AST s4_AST = null;
05879: Token first = LT(1);
05880:
05881: switch (LA(1)) {
05882: case FINAL:
05883: case ABSTRACT:
05884: case STRICTFP:
05885: case LITERAL_static:
05886: case LITERAL_def:
05887: case AT:
05888: case IDENT:
05889: case LITERAL_class:
05890: case LITERAL_interface:
05891: case LITERAL_enum:
05892: case LT:
05893: case LITERAL_void:
05894: case LITERAL_boolean:
05895: case LITERAL_byte:
05896: case LITERAL_char:
05897: case LITERAL_short:
05898: case LITERAL_int:
05899: case LITERAL_float:
05900: case LITERAL_long:
05901: case LITERAL_double:
05902: case LITERAL_any:
05903: case LITERAL_private:
05904: case LITERAL_public:
05905: case LITERAL_protected:
05906: case LITERAL_transient:
05907: case LITERAL_native:
05908: case LITERAL_threadsafe:
05909: case LITERAL_synchronized:
05910: case LITERAL_volatile: {
05911: modifiersOpt();
05912: mods_AST = (AST) returnAST;
05913: {
05914: switch (LA(1)) {
05915: case AT:
05916: case LITERAL_class:
05917: case LITERAL_interface:
05918: case LITERAL_enum: {
05919: typeDefinitionInternal(mods_AST);
05920: td_AST = (AST) returnAST;
05921: if (inputState.guessing == 0) {
05922: enumConstantField_AST = (AST) currentAST.root;
05923: enumConstantField_AST = td_AST;
05924: currentAST.root = enumConstantField_AST;
05925: currentAST.child = enumConstantField_AST != null
05926: && enumConstantField_AST
05927: .getFirstChild() != null ? enumConstantField_AST
05928: .getFirstChild()
05929: : enumConstantField_AST;
05930: currentAST.advanceChildToEnd();
05931: }
05932: break;
05933: }
05934: case IDENT:
05935: case LT:
05936: case LITERAL_void:
05937: case LITERAL_boolean:
05938: case LITERAL_byte:
05939: case LITERAL_char:
05940: case LITERAL_short:
05941: case LITERAL_int:
05942: case LITERAL_float:
05943: case LITERAL_long:
05944: case LITERAL_double:
05945: case LITERAL_any: {
05946: {
05947: switch (LA(1)) {
05948: case LT: {
05949: typeParameters();
05950: tp_AST = (AST) returnAST;
05951: break;
05952: }
05953: case IDENT:
05954: case LITERAL_void:
05955: case LITERAL_boolean:
05956: case LITERAL_byte:
05957: case LITERAL_char:
05958: case LITERAL_short:
05959: case LITERAL_int:
05960: case LITERAL_float:
05961: case LITERAL_long:
05962: case LITERAL_double:
05963: case LITERAL_any: {
05964: break;
05965: }
05966: default: {
05967: throw new NoViableAltException(LT(1),
05968: getFilename());
05969: }
05970: }
05971: }
05972: typeSpec(false);
05973: t_AST = (AST) returnAST;
05974: {
05975: boolean synPredMatched153 = false;
05976: if (((LA(1) == IDENT) && (LA(2) == LPAREN) && (_tokenSet_69
05977: .member(LA(3))))) {
05978: int _m153 = mark();
05979: synPredMatched153 = true;
05980: inputState.guessing++;
05981: try {
05982: {
05983: match(IDENT);
05984: match(LPAREN);
05985: }
05986: } catch (RecognitionException pe) {
05987: synPredMatched153 = false;
05988: }
05989: rewind(_m153);
05990: inputState.guessing--;
05991: }
05992: if (synPredMatched153) {
05993: AST tmp141_AST = null;
05994: tmp141_AST = astFactory.create(LT(1));
05995: match(IDENT);
05996: match(LPAREN);
05997: parameterDeclarationList();
05998: param_AST = (AST) returnAST;
05999: match(RPAREN);
06000: {
06001: boolean synPredMatched156 = false;
06002: if (((LA(1) == NLS || LA(1) == LITERAL_throws)
06003: && (_tokenSet_30.member(LA(2))) && (_tokenSet_70
06004: .member(LA(3))))) {
06005: int _m156 = mark();
06006: synPredMatched156 = true;
06007: inputState.guessing++;
06008: try {
06009: {
06010: nls();
06011: match(LITERAL_throws);
06012: }
06013: } catch (RecognitionException pe) {
06014: synPredMatched156 = false;
06015: }
06016: rewind(_m156);
06017: inputState.guessing--;
06018: }
06019: if (synPredMatched156) {
06020: throwsClause();
06021: tc_AST = (AST) returnAST;
06022: } else if (((LA(1) >= LCURLY && LA(1) <= NLS))
06023: && (_tokenSet_71.member(LA(2)))
06024: && (_tokenSet_8.member(LA(3)))) {
06025: } else {
06026: throw new NoViableAltException(
06027: LT(1), getFilename());
06028: }
06029:
06030: }
06031: {
06032: switch (LA(1)) {
06033: case LCURLY: {
06034: compoundStatement();
06035: s2_AST = (AST) returnAST;
06036: break;
06037: }
06038: case RCURLY:
06039: case SEMI:
06040: case NLS: {
06041: break;
06042: }
06043: default: {
06044: throw new NoViableAltException(
06045: LT(1), getFilename());
06046: }
06047: }
06048: }
06049: if (inputState.guessing == 0) {
06050: enumConstantField_AST = (AST) currentAST.root;
06051: enumConstantField_AST = (AST) astFactory
06052: .make((new ASTArray(8))
06053: .add(
06054: create(
06055: METHOD_DEF,
06056: "METHOD_DEF",
06057: first,
06058: LT(1)))
06059: .add(mods_AST)
06060: .add(tp_AST)
06061: .add(
06062: (AST) astFactory
06063: .make((new ASTArray(
06064: 2))
06065: .add(
06066: create(
06067: TYPE,
06068: "TYPE",
06069: first,
06070: LT(1)))
06071: .add(
06072: t_AST)))
06073: .add(tmp141_AST).add(
06074: param_AST).add(
06075: tc_AST).add(
06076: s2_AST));
06077: currentAST.root = enumConstantField_AST;
06078: currentAST.child = enumConstantField_AST != null
06079: && enumConstantField_AST
06080: .getFirstChild() != null ? enumConstantField_AST
06081: .getFirstChild()
06082: : enumConstantField_AST;
06083: currentAST.advanceChildToEnd();
06084: }
06085: } else if ((LA(1) == IDENT || LA(1) == STRING_LITERAL)
06086: && (_tokenSet_63.member(LA(2)))
06087: && (_tokenSet_72.member(LA(3)))) {
06088: variableDefinitions(mods_AST, t_AST);
06089: v_AST = (AST) returnAST;
06090: if (inputState.guessing == 0) {
06091: enumConstantField_AST = (AST) currentAST.root;
06092: enumConstantField_AST = v_AST;
06093: currentAST.root = enumConstantField_AST;
06094: currentAST.child = enumConstantField_AST != null
06095: && enumConstantField_AST
06096: .getFirstChild() != null ? enumConstantField_AST
06097: .getFirstChild()
06098: : enumConstantField_AST;
06099: currentAST.advanceChildToEnd();
06100: }
06101: } else {
06102: throw new NoViableAltException(LT(1),
06103: getFilename());
06104: }
06105:
06106: }
06107: break;
06108: }
06109: default: {
06110: throw new NoViableAltException(LT(1), getFilename());
06111: }
06112: }
06113: }
06114: break;
06115: }
06116: case LCURLY: {
06117: compoundStatement();
06118: s4_AST = (AST) returnAST;
06119: if (inputState.guessing == 0) {
06120: enumConstantField_AST = (AST) currentAST.root;
06121: enumConstantField_AST = (AST) astFactory
06122: .make((new ASTArray(2)).add(
06123: create(INSTANCE_INIT, "INSTANCE_INIT",
06124: first, LT(1))).add(s4_AST));
06125: currentAST.root = enumConstantField_AST;
06126: currentAST.child = enumConstantField_AST != null
06127: && enumConstantField_AST.getFirstChild() != null ? enumConstantField_AST
06128: .getFirstChild()
06129: : enumConstantField_AST;
06130: currentAST.advanceChildToEnd();
06131: }
06132: break;
06133: }
06134: default: {
06135: throw new NoViableAltException(LT(1), getFilename());
06136: }
06137: }
06138: returnAST = enumConstantField_AST;
06139: }
06140:
06141: /** A list of zero or more formal parameters.
06142: * If a parameter is variable length (e.g. String... myArg) it should be
06143: * to the right of any other parameters of the same kind.
06144: * General form: (req, ..., opt, ..., [rest], key, ..., [restKeys], [block]
06145: * This must be sorted out after parsing, since the various declaration forms
06146: * are impossible to tell apart without backtracking.
06147: */
06148: public final void parameterDeclarationList()
06149: throws RecognitionException, TokenStreamException {
06150:
06151: returnAST = null;
06152: ASTPair currentAST = new ASTPair();
06153: AST parameterDeclarationList_AST = null;
06154: Token first = LT(1);
06155:
06156: {
06157: switch (LA(1)) {
06158: case FINAL:
06159: case LITERAL_def:
06160: case AT:
06161: case IDENT:
06162: case LITERAL_void:
06163: case LITERAL_boolean:
06164: case LITERAL_byte:
06165: case LITERAL_char:
06166: case LITERAL_short:
06167: case LITERAL_int:
06168: case LITERAL_float:
06169: case LITERAL_long:
06170: case LITERAL_double:
06171: case LITERAL_any:
06172: case TRIPLE_DOT: {
06173: parameterDeclaration();
06174: astFactory.addASTChild(currentAST, returnAST);
06175: {
06176: _loop217: do {
06177: if ((LA(1) == COMMA)) {
06178: match(COMMA);
06179: nls();
06180: parameterDeclaration();
06181: astFactory.addASTChild(currentAST,
06182: returnAST);
06183: } else {
06184: break _loop217;
06185: }
06186:
06187: } while (true);
06188: }
06189: break;
06190: }
06191: case RPAREN:
06192: case NLS:
06193: case CLOSABLE_BLOCK_OP: {
06194: break;
06195: }
06196: default: {
06197: throw new NoViableAltException(LT(1), getFilename());
06198: }
06199: }
06200: }
06201: if (inputState.guessing == 0) {
06202: parameterDeclarationList_AST = (AST) currentAST.root;
06203: parameterDeclarationList_AST = (AST) astFactory
06204: .make((new ASTArray(2)).add(
06205: create(PARAMETERS, "PARAMETERS", first,
06206: LT(1))).add(
06207: parameterDeclarationList_AST));
06208: currentAST.root = parameterDeclarationList_AST;
06209: currentAST.child = parameterDeclarationList_AST != null
06210: && parameterDeclarationList_AST.getFirstChild() != null ? parameterDeclarationList_AST
06211: .getFirstChild()
06212: : parameterDeclarationList_AST;
06213: currentAST.advanceChildToEnd();
06214: }
06215: parameterDeclarationList_AST = (AST) currentAST.root;
06216: returnAST = parameterDeclarationList_AST;
06217: }
06218:
06219: public final void throwsClause() throws RecognitionException,
06220: TokenStreamException {
06221:
06222: returnAST = null;
06223: ASTPair currentAST = new ASTPair();
06224: AST throwsClause_AST = null;
06225:
06226: nls();
06227: AST tmp145_AST = null;
06228: tmp145_AST = astFactory.create(LT(1));
06229: astFactory.makeASTRoot(currentAST, tmp145_AST);
06230: match(LITERAL_throws);
06231: nls();
06232: identifier();
06233: astFactory.addASTChild(currentAST, returnAST);
06234: {
06235: _loop213: do {
06236: if ((LA(1) == COMMA)) {
06237: match(COMMA);
06238: nls();
06239: identifier();
06240: astFactory.addASTChild(currentAST, returnAST);
06241: } else {
06242: break _loop213;
06243: }
06244:
06245: } while (true);
06246: }
06247: throwsClause_AST = (AST) currentAST.root;
06248: returnAST = throwsClause_AST;
06249: }
06250:
06251: public final void compoundStatement() throws RecognitionException,
06252: TokenStreamException {
06253:
06254: returnAST = null;
06255: ASTPair currentAST = new ASTPair();
06256: AST compoundStatement_AST = null;
06257:
06258: openBlock();
06259: astFactory.addASTChild(currentAST, returnAST);
06260: compoundStatement_AST = (AST) currentAST.root;
06261: returnAST = compoundStatement_AST;
06262: }
06263:
06264: /** I've split out constructors separately; we could maybe integrate back into variableDefinitions
06265: * later on if we maybe simplified 'def' to be a type declaration?
06266: */
06267: public final void constructorDefinition(AST mods)
06268: throws RecognitionException, TokenStreamException {
06269:
06270: returnAST = null;
06271: ASTPair currentAST = new ASTPair();
06272: AST constructorDefinition_AST = null;
06273: Token id = null;
06274: AST id_AST = null;
06275: AST param_AST = null;
06276: AST tc_AST = null;
06277: AST cb_AST = null;
06278: Token first = LT(1);
06279:
06280: id = LT(1);
06281: id_AST = astFactory.create(id);
06282: astFactory.addASTChild(currentAST, id_AST);
06283: match(IDENT);
06284: match(LPAREN);
06285: parameterDeclarationList();
06286: param_AST = (AST) returnAST;
06287: match(RPAREN);
06288: {
06289: boolean synPredMatched202 = false;
06290: if (((LA(1) == NLS || LA(1) == LITERAL_throws)
06291: && (_tokenSet_30.member(LA(2))) && (_tokenSet_73
06292: .member(LA(3))))) {
06293: int _m202 = mark();
06294: synPredMatched202 = true;
06295: inputState.guessing++;
06296: try {
06297: {
06298: nls();
06299: match(LITERAL_throws);
06300: }
06301: } catch (RecognitionException pe) {
06302: synPredMatched202 = false;
06303: }
06304: rewind(_m202);
06305: inputState.guessing--;
06306: }
06307: if (synPredMatched202) {
06308: throwsClause();
06309: tc_AST = (AST) returnAST;
06310: } else if ((LA(1) == LCURLY || LA(1) == NLS)
06311: && (_tokenSet_74.member(LA(2)))
06312: && (_tokenSet_75.member(LA(3)))) {
06313: } else {
06314: throw new NoViableAltException(LT(1), getFilename());
06315: }
06316:
06317: }
06318: nlsWarn();
06319: if (inputState.guessing == 0) {
06320: isConstructorIdent(id);
06321: }
06322: constructorBody();
06323: cb_AST = (AST) returnAST;
06324: if (inputState.guessing == 0) {
06325: constructorDefinition_AST = (AST) currentAST.root;
06326: constructorDefinition_AST = (AST) astFactory
06327: .make((new ASTArray(5)).add(
06328: create(CTOR_IDENT, "CTOR_IDENT", first,
06329: LT(1))).add(mods).add(param_AST)
06330: .add(tc_AST).add(cb_AST));
06331:
06332: currentAST.root = constructorDefinition_AST;
06333: currentAST.child = constructorDefinition_AST != null
06334: && constructorDefinition_AST.getFirstChild() != null ? constructorDefinition_AST
06335: .getFirstChild()
06336: : constructorDefinition_AST;
06337: currentAST.advanceChildToEnd();
06338: }
06339: constructorDefinition_AST = (AST) currentAST.root;
06340: returnAST = constructorDefinition_AST;
06341: }
06342:
06343: public final void constructorBody() throws RecognitionException,
06344: TokenStreamException {
06345:
06346: returnAST = null;
06347: ASTPair currentAST = new ASTPair();
06348: AST constructorBody_AST = null;
06349: Token lc = null;
06350: AST lc_AST = null;
06351:
06352: lc = LT(1);
06353: lc_AST = astFactory.create(lc);
06354: astFactory.makeASTRoot(currentAST, lc_AST);
06355: match(LCURLY);
06356: nls();
06357: if (inputState.guessing == 0) {
06358: lc_AST.setType(SLIST);
06359: }
06360: {
06361: boolean synPredMatched183 = false;
06362: if (((_tokenSet_76.member(LA(1)))
06363: && (_tokenSet_77.member(LA(2))) && (_tokenSet_78
06364: .member(LA(3))))) {
06365: int _m183 = mark();
06366: synPredMatched183 = true;
06367: inputState.guessing++;
06368: try {
06369: {
06370: explicitConstructorInvocation();
06371: }
06372: } catch (RecognitionException pe) {
06373: synPredMatched183 = false;
06374: }
06375: rewind(_m183);
06376: inputState.guessing--;
06377: }
06378: if (synPredMatched183) {
06379: explicitConstructorInvocation();
06380: astFactory.addASTChild(currentAST, returnAST);
06381: {
06382: switch (LA(1)) {
06383: case SEMI:
06384: case NLS: {
06385: sep();
06386: blockBody(sepToken);
06387: astFactory.addASTChild(currentAST, returnAST);
06388: break;
06389: }
06390: case RCURLY: {
06391: break;
06392: }
06393: default: {
06394: throw new NoViableAltException(LT(1),
06395: getFilename());
06396: }
06397: }
06398: }
06399: } else if ((_tokenSet_33.member(LA(1)))
06400: && (_tokenSet_75.member(LA(2)))
06401: && (_tokenSet_18.member(LA(3)))) {
06402: blockBody(EOF);
06403: astFactory.addASTChild(currentAST, returnAST);
06404: } else {
06405: throw new NoViableAltException(LT(1), getFilename());
06406: }
06407:
06408: }
06409: match(RCURLY);
06410: constructorBody_AST = (AST) currentAST.root;
06411: returnAST = constructorBody_AST;
06412: }
06413:
06414: /** Catch obvious constructor calls, but not the expr.super(...) calls */
06415: public final void explicitConstructorInvocation()
06416: throws RecognitionException, TokenStreamException {
06417:
06418: returnAST = null;
06419: ASTPair currentAST = new ASTPair();
06420: AST explicitConstructorInvocation_AST = null;
06421: Token lp1 = null;
06422: AST lp1_AST = null;
06423: Token lp2 = null;
06424: AST lp2_AST = null;
06425:
06426: {
06427: switch (LA(1)) {
06428: case LT: {
06429: typeArguments();
06430: astFactory.addASTChild(currentAST, returnAST);
06431: break;
06432: }
06433: case LITERAL_super :
06434: case LITERAL_this : {
06435: break;
06436: }
06437: default: {
06438: throw new NoViableAltException(LT(1), getFilename());
06439: }
06440: }
06441: }
06442: {
06443: switch (LA(1)) {
06444: case LITERAL_this : {
06445: match(LITERAL_this );
06446: lp1 = LT(1);
06447: lp1_AST = astFactory.create(lp1);
06448: astFactory.makeASTRoot(currentAST, lp1_AST);
06449: match(LPAREN);
06450: argList();
06451: astFactory.addASTChild(currentAST, returnAST);
06452: match(RPAREN);
06453: if (inputState.guessing == 0) {
06454: lp1_AST.setType(CTOR_CALL);
06455: }
06456: break;
06457: }
06458: case LITERAL_super : {
06459: match(LITERAL_super );
06460: lp2 = LT(1);
06461: lp2_AST = astFactory.create(lp2);
06462: astFactory.makeASTRoot(currentAST, lp2_AST);
06463: match(LPAREN);
06464: argList();
06465: astFactory.addASTChild(currentAST, returnAST);
06466: match(RPAREN);
06467: if (inputState.guessing == 0) {
06468: lp2_AST.setType(SUPER_CTOR_CALL);
06469: }
06470: break;
06471: }
06472: default: {
06473: throw new NoViableAltException(LT(1), getFilename());
06474: }
06475: }
06476: }
06477: explicitConstructorInvocation_AST = (AST) currentAST.root;
06478: returnAST = explicitConstructorInvocation_AST;
06479: }
06480:
06481: /** Declaration of a variable. This can be a class/instance variable,
06482: * or a local variable in a method
06483: * It can also include possible initialization.
06484: */
06485: public final void variableDeclarator(AST mods, AST t)
06486: throws RecognitionException, TokenStreamException {
06487:
06488: returnAST = null;
06489: ASTPair currentAST = new ASTPair();
06490: AST variableDeclarator_AST = null;
06491: AST id_AST = null;
06492: AST v_AST = null;
06493: Token first = LT(1);
06494:
06495: variableName();
06496: id_AST = (AST) returnAST;
06497: {
06498: switch (LA(1)) {
06499: case ASSIGN: {
06500: varInitializer();
06501: v_AST = (AST) returnAST;
06502: break;
06503: }
06504: case EOF:
06505: case COMMA:
06506: case RCURLY:
06507: case SEMI:
06508: case NLS:
06509: case LITERAL_default:
06510: case LITERAL_else:
06511: case LITERAL_case: {
06512: break;
06513: }
06514: default: {
06515: throw new NoViableAltException(LT(1), getFilename());
06516: }
06517: }
06518: }
06519: if (inputState.guessing == 0) {
06520: variableDeclarator_AST = (AST) currentAST.root;
06521: variableDeclarator_AST = (AST) astFactory
06522: .make((new ASTArray(5)).add(
06523: create(VARIABLE_DEF, "VARIABLE_DEF", first,
06524: LT(1))).add(mods).add(
06525: (AST) astFactory.make((new ASTArray(2))
06526: .add(
06527: create(TYPE, "TYPE", first,
06528: LT(1))).add(t)))
06529: .add(id_AST).add(v_AST));
06530: currentAST.root = variableDeclarator_AST;
06531: currentAST.child = variableDeclarator_AST != null
06532: && variableDeclarator_AST.getFirstChild() != null ? variableDeclarator_AST
06533: .getFirstChild()
06534: : variableDeclarator_AST;
06535: currentAST.advanceChildToEnd();
06536: }
06537: returnAST = variableDeclarator_AST;
06538: }
06539:
06540: /** Zero or more insignificant newlines, all gobbled up and thrown away,
06541: * but a warning message is left for the user, if there was a newline.
06542: */
06543: public final void nlsWarn() throws RecognitionException,
06544: TokenStreamException {
06545:
06546: returnAST = null;
06547: ASTPair currentAST = new ASTPair();
06548: AST nlsWarn_AST = null;
06549:
06550: {
06551: boolean synPredMatched485 = false;
06552: if (((_tokenSet_15.member(LA(1)))
06553: && (_tokenSet_8.member(LA(2))) && (_tokenSet_18
06554: .member(LA(3))))) {
06555: int _m485 = mark();
06556: synPredMatched485 = true;
06557: inputState.guessing++;
06558: try {
06559: {
06560: match(NLS);
06561: }
06562: } catch (RecognitionException pe) {
06563: synPredMatched485 = false;
06564: }
06565: rewind(_m485);
06566: inputState.guessing--;
06567: }
06568: if (synPredMatched485) {
06569: if (inputState.guessing == 0) {
06570: addWarning(
06571: "A newline at this point does not follow the Groovy Coding Conventions.",
06572: "Keep this statement on one line, or use curly braces to break across multiple lines.");
06573: }
06574: } else if ((_tokenSet_15.member(LA(1)))
06575: && (_tokenSet_8.member(LA(2)))
06576: && (_tokenSet_18.member(LA(3)))) {
06577: } else {
06578: throw new NoViableAltException(LT(1), getFilename());
06579: }
06580:
06581: }
06582: nls();
06583: returnAST = nlsWarn_AST;
06584: }
06585:
06586: /** An open block is not allowed to have closure arguments. */
06587: public final void openBlock() throws RecognitionException,
06588: TokenStreamException {
06589:
06590: returnAST = null;
06591: ASTPair currentAST = new ASTPair();
06592: AST openBlock_AST = null;
06593: Token lc = null;
06594: AST lc_AST = null;
06595:
06596: lc = LT(1);
06597: lc_AST = astFactory.create(lc);
06598: astFactory.makeASTRoot(currentAST, lc_AST);
06599: match(LCURLY);
06600: nls();
06601: if (inputState.guessing == 0) {
06602: lc_AST.setType(SLIST);
06603: }
06604: blockBody(EOF);
06605: astFactory.addASTChild(currentAST, returnAST);
06606: match(RCURLY);
06607: openBlock_AST = (AST) currentAST.root;
06608: returnAST = openBlock_AST;
06609: }
06610:
06611: public final void variableName() throws RecognitionException,
06612: TokenStreamException {
06613:
06614: returnAST = null;
06615: ASTPair currentAST = new ASTPair();
06616: AST variableName_AST = null;
06617:
06618: AST tmp155_AST = null;
06619: tmp155_AST = astFactory.create(LT(1));
06620: astFactory.addASTChild(currentAST, tmp155_AST);
06621: match(IDENT);
06622: variableName_AST = (AST) currentAST.root;
06623: returnAST = variableName_AST;
06624: }
06625:
06626: public final void expression(int lc_stmt)
06627: throws RecognitionException, TokenStreamException {
06628:
06629: returnAST = null;
06630: ASTPair currentAST = new ASTPair();
06631: AST expression_AST = null;
06632:
06633: assignmentExpression(lc_stmt);
06634: astFactory.addASTChild(currentAST, returnAST);
06635: expression_AST = (AST) currentAST.root;
06636: returnAST = expression_AST;
06637: }
06638:
06639: /** A formal parameter for a method or closure. */
06640: public final void parameterDeclaration()
06641: throws RecognitionException, TokenStreamException {
06642:
06643: returnAST = null;
06644: ASTPair currentAST = new ASTPair();
06645: AST parameterDeclaration_AST = null;
06646: AST pm_AST = null;
06647: AST t_AST = null;
06648: Token id = null;
06649: AST id_AST = null;
06650: AST exp_AST = null;
06651: Token first = LT(1);
06652: boolean spreadParam = false;
06653:
06654: parameterModifiersOpt();
06655: pm_AST = (AST) returnAST;
06656: {
06657: if ((_tokenSet_26.member(LA(1)))
06658: && (_tokenSet_79.member(LA(2)))
06659: && (_tokenSet_80.member(LA(3)))) {
06660: typeSpec(false);
06661: t_AST = (AST) returnAST;
06662: } else if ((LA(1) == IDENT || LA(1) == TRIPLE_DOT)
06663: && (_tokenSet_81.member(LA(2)))
06664: && (_tokenSet_82.member(LA(3)))) {
06665: } else {
06666: throw new NoViableAltException(LT(1), getFilename());
06667: }
06668:
06669: }
06670: {
06671: switch (LA(1)) {
06672: case TRIPLE_DOT: {
06673: match(TRIPLE_DOT);
06674: if (inputState.guessing == 0) {
06675: spreadParam = true;
06676: }
06677: break;
06678: }
06679: case IDENT: {
06680: break;
06681: }
06682: default: {
06683: throw new NoViableAltException(LT(1), getFilename());
06684: }
06685: }
06686: }
06687: id = LT(1);
06688: id_AST = astFactory.create(id);
06689: match(IDENT);
06690: {
06691: switch (LA(1)) {
06692: case ASSIGN: {
06693: varInitializer();
06694: exp_AST = (AST) returnAST;
06695: break;
06696: }
06697: case COMMA:
06698: case RPAREN:
06699: case NLS:
06700: case CLOSABLE_BLOCK_OP: {
06701: break;
06702: }
06703: default: {
06704: throw new NoViableAltException(LT(1), getFilename());
06705: }
06706: }
06707: }
06708: if (inputState.guessing == 0) {
06709: parameterDeclaration_AST = (AST) currentAST.root;
06710:
06711: if (spreadParam) {
06712: parameterDeclaration_AST = (AST) astFactory
06713: .make((new ASTArray(5)).add(
06714: create(VARIABLE_PARAMETER_DEF,
06715: "VARIABLE_PARAMETER_DEF",
06716: first, LT(1))).add(pm_AST).add(
06717: (AST) astFactory.make((new ASTArray(2))
06718: .add(
06719: create(TYPE, "TYPE",
06720: first, LT(1)))
06721: .add(t_AST))).add(id_AST).add(
06722: exp_AST));
06723: } else {
06724: parameterDeclaration_AST = (AST) astFactory
06725: .make((new ASTArray(5)).add(
06726: create(PARAMETER_DEF, "PARAMETER_DEF",
06727: first, LT(1))).add(pm_AST).add(
06728: (AST) astFactory.make((new ASTArray(2))
06729: .add(
06730: create(TYPE, "TYPE",
06731: first, LT(1)))
06732: .add(t_AST))).add(id_AST).add(
06733: exp_AST));
06734: }
06735:
06736: currentAST.root = parameterDeclaration_AST;
06737: currentAST.child = parameterDeclaration_AST != null
06738: && parameterDeclaration_AST.getFirstChild() != null ? parameterDeclaration_AST
06739: .getFirstChild()
06740: : parameterDeclaration_AST;
06741: currentAST.advanceChildToEnd();
06742: }
06743: returnAST = parameterDeclaration_AST;
06744: }
06745:
06746: public final void parameterModifiersOpt()
06747: throws RecognitionException, TokenStreamException {
06748:
06749: returnAST = null;
06750: ASTPair currentAST = new ASTPair();
06751: AST parameterModifiersOpt_AST = null;
06752: Token first = LT(1);
06753: int seenDef = 0;
06754:
06755: {
06756: _loop224: do {
06757: switch (LA(1)) {
06758: case FINAL: {
06759: AST tmp157_AST = null;
06760: tmp157_AST = astFactory.create(LT(1));
06761: astFactory.addASTChild(currentAST, tmp157_AST);
06762: match(FINAL);
06763: nls();
06764: break;
06765: }
06766: case AT: {
06767: annotation();
06768: astFactory.addASTChild(currentAST, returnAST);
06769: nls();
06770: break;
06771: }
06772: default:
06773: if (((LA(1) == LITERAL_def)) && (seenDef++ == 0)) {
06774: match(LITERAL_def);
06775: nls();
06776: } else {
06777: break _loop224;
06778: }
06779: }
06780: } while (true);
06781: }
06782: if (inputState.guessing == 0) {
06783: parameterModifiersOpt_AST = (AST) currentAST.root;
06784: parameterModifiersOpt_AST = (AST) astFactory
06785: .make((new ASTArray(2))
06786: .add(
06787: create(MODIFIERS, "MODIFIERS",
06788: first, LT(1))).add(
06789: parameterModifiersOpt_AST));
06790: currentAST.root = parameterModifiersOpt_AST;
06791: currentAST.child = parameterModifiersOpt_AST != null
06792: && parameterModifiersOpt_AST.getFirstChild() != null ? parameterModifiersOpt_AST
06793: .getFirstChild()
06794: : parameterModifiersOpt_AST;
06795: currentAST.advanceChildToEnd();
06796: }
06797: parameterModifiersOpt_AST = (AST) currentAST.root;
06798: returnAST = parameterModifiersOpt_AST;
06799: }
06800:
06801: /** Closure parameters are exactly like method parameters,
06802: * except that they are not enclosed in parentheses, but rather
06803: * are prepended to the front of a block, just after the brace.
06804: * They are separated from the closure body by a CLOSABLE_BLOCK_OP token '->'.
06805: */
06806: public final void closableBlockParamsOpt(boolean addImplicit)
06807: throws RecognitionException, TokenStreamException {
06808:
06809: returnAST = null;
06810: ASTPair currentAST = new ASTPair();
06811: AST closableBlockParamsOpt_AST = null;
06812:
06813: boolean synPredMatched227 = false;
06814: if (((_tokenSet_83.member(LA(1)))
06815: && (_tokenSet_84.member(LA(2))) && (_tokenSet_20
06816: .member(LA(3))))) {
06817: int _m227 = mark();
06818: synPredMatched227 = true;
06819: inputState.guessing++;
06820: try {
06821: {
06822: parameterDeclarationList();
06823: nls();
06824: match(CLOSABLE_BLOCK_OP);
06825: }
06826: } catch (RecognitionException pe) {
06827: synPredMatched227 = false;
06828: }
06829: rewind(_m227);
06830: inputState.guessing--;
06831: }
06832: if (synPredMatched227) {
06833: parameterDeclarationList();
06834: astFactory.addASTChild(currentAST, returnAST);
06835: nls();
06836: match(CLOSABLE_BLOCK_OP);
06837: nls();
06838: closableBlockParamsOpt_AST = (AST) currentAST.root;
06839: } else if (((_tokenSet_33.member(LA(1)))
06840: && (_tokenSet_20.member(LA(2))) && (_tokenSet_5
06841: .member(LA(3))))
06842: && (addImplicit)) {
06843: implicitParameters();
06844: astFactory.addASTChild(currentAST, returnAST);
06845: closableBlockParamsOpt_AST = (AST) currentAST.root;
06846: } else if ((_tokenSet_33.member(LA(1)))
06847: && (_tokenSet_20.member(LA(2)))
06848: && (_tokenSet_5.member(LA(3)))) {
06849: closableBlockParamsOpt_AST = (AST) currentAST.root;
06850: } else {
06851: throw new NoViableAltException(LT(1), getFilename());
06852: }
06853:
06854: returnAST = closableBlockParamsOpt_AST;
06855: }
06856:
06857: /** A block known to be a closure, but which omits its arguments, is given this placeholder.
06858: * A subsequent pass is responsible for deciding if there is an implicit 'it' parameter,
06859: * or if the parameter list should be empty.
06860: */
06861: public final void implicitParameters() throws RecognitionException,
06862: TokenStreamException {
06863:
06864: returnAST = null;
06865: ASTPair currentAST = new ASTPair();
06866: AST implicitParameters_AST = null;
06867: Token first = LT(1);
06868:
06869: if (inputState.guessing == 0) {
06870: implicitParameters_AST = (AST) currentAST.root;
06871: implicitParameters_AST = (AST) astFactory
06872: .make((new ASTArray(1)).add(create(
06873: IMPLICIT_PARAMETERS, "IMPLICIT_PARAMETERS",
06874: first, LT(1))));
06875: currentAST.root = implicitParameters_AST;
06876: currentAST.child = implicitParameters_AST != null
06877: && implicitParameters_AST.getFirstChild() != null ? implicitParameters_AST
06878: .getFirstChild()
06879: : implicitParameters_AST;
06880: currentAST.advanceChildToEnd();
06881: }
06882: implicitParameters_AST = (AST) currentAST.root;
06883: returnAST = implicitParameters_AST;
06884: }
06885:
06886: /** Lookahead to check whether a block begins with explicit closure arguments. */
06887: public final void closableBlockParamsStart()
06888: throws RecognitionException, TokenStreamException {
06889:
06890: returnAST = null;
06891: ASTPair currentAST = new ASTPair();
06892: AST closableBlockParamsStart_AST = null;
06893:
06894: parameterDeclarationList();
06895: nls();
06896: AST tmp160_AST = null;
06897: tmp160_AST = astFactory.create(LT(1));
06898: match(CLOSABLE_BLOCK_OP);
06899: returnAST = closableBlockParamsStart_AST;
06900: }
06901:
06902: /** Simple names, as in {x|...}, are completely equivalent to {(def x)|...}. Build the right AST. */
06903: public final void closableBlockParam() throws RecognitionException,
06904: TokenStreamException {
06905:
06906: returnAST = null;
06907: ASTPair currentAST = new ASTPair();
06908: AST closableBlockParam_AST = null;
06909: Token id = null;
06910: AST id_AST = null;
06911: Token first = LT(1);
06912:
06913: id = LT(1);
06914: id_AST = astFactory.create(id);
06915: match(IDENT);
06916: if (inputState.guessing == 0) {
06917: closableBlockParam_AST = (AST) currentAST.root;
06918: closableBlockParam_AST = (AST) astFactory
06919: .make((new ASTArray(4)).add(
06920: create(PARAMETER_DEF, "PARAMETER_DEF",
06921: first, LT(1))).add(
06922: (AST) astFactory.make((new ASTArray(1))
06923: .add(create(MODIFIERS, "MODIFIERS",
06924: first, LT(1))))).add(
06925: (AST) astFactory.make((new ASTArray(1))
06926: .add(create(TYPE, "TYPE", first,
06927: LT(1))))).add(id_AST));
06928: currentAST.root = closableBlockParam_AST;
06929: currentAST.child = closableBlockParam_AST != null
06930: && closableBlockParam_AST.getFirstChild() != null ? closableBlockParam_AST
06931: .getFirstChild()
06932: : closableBlockParam_AST;
06933: currentAST.advanceChildToEnd();
06934: }
06935: returnAST = closableBlockParam_AST;
06936: }
06937:
06938: /** A block which is known to be a closure, even if it has no apparent arguments.
06939: * A block inside an expression or after a method call is always assumed to be a closure.
06940: * Only labeled, unparameterized blocks which occur directly as substatements are kept open.
06941: */
06942: public final void closableBlock() throws RecognitionException,
06943: TokenStreamException {
06944:
06945: returnAST = null;
06946: ASTPair currentAST = new ASTPair();
06947: AST closableBlock_AST = null;
06948: Token lc = null;
06949: AST lc_AST = null;
06950:
06951: lc = LT(1);
06952: lc_AST = astFactory.create(lc);
06953: astFactory.makeASTRoot(currentAST, lc_AST);
06954: match(LCURLY);
06955: nls();
06956: if (inputState.guessing == 0) {
06957: lc_AST.setType(CLOSABLE_BLOCK);
06958: }
06959: closableBlockParamsOpt(true);
06960: astFactory.addASTChild(currentAST, returnAST);
06961: blockBody(EOF);
06962: astFactory.addASTChild(currentAST, returnAST);
06963: match(RCURLY);
06964: closableBlock_AST = (AST) currentAST.root;
06965: returnAST = closableBlock_AST;
06966: }
06967:
06968: /** A sub-block of a block can be either open or closable.
06969: * It is closable if and only if there are explicit closure arguments.
06970: * Compare this to a block which is appended to a method call,
06971: * which is given closure arguments, even if they are not explicit in the code.
06972: */
06973: public final void openOrClosableBlock()
06974: throws RecognitionException, TokenStreamException {
06975:
06976: returnAST = null;
06977: ASTPair currentAST = new ASTPair();
06978: AST openOrClosableBlock_AST = null;
06979: Token lc = null;
06980: AST lc_AST = null;
06981: AST cp_AST = null;
06982:
06983: lc = LT(1);
06984: lc_AST = astFactory.create(lc);
06985: astFactory.makeASTRoot(currentAST, lc_AST);
06986: match(LCURLY);
06987: nls();
06988: closableBlockParamsOpt(false);
06989: cp_AST = (AST) returnAST;
06990: astFactory.addASTChild(currentAST, returnAST);
06991: if (inputState.guessing == 0) {
06992: if (cp_AST == null)
06993: lc_AST.setType(SLIST);
06994: else
06995: lc_AST.setType(CLOSABLE_BLOCK);
06996:
06997: }
06998: blockBody(EOF);
06999: astFactory.addASTChild(currentAST, returnAST);
07000: match(RCURLY);
07001: openOrClosableBlock_AST = (AST) currentAST.root;
07002: returnAST = openOrClosableBlock_AST;
07003: }
07004:
07005: /** A labeled statement, consisting of a vanilla identifier followed by a colon. */
07006: public final void statementLabelPrefix()
07007: throws RecognitionException, TokenStreamException {
07008:
07009: returnAST = null;
07010: ASTPair currentAST = new ASTPair();
07011: AST statementLabelPrefix_AST = null;
07012: Token c = null;
07013: AST c_AST = null;
07014:
07015: AST tmp163_AST = null;
07016: tmp163_AST = astFactory.create(LT(1));
07017: astFactory.addASTChild(currentAST, tmp163_AST);
07018: match(IDENT);
07019: c = LT(1);
07020: c_AST = astFactory.create(c);
07021: astFactory.makeASTRoot(currentAST, c_AST);
07022: match(COLON);
07023: if (inputState.guessing == 0) {
07024: c_AST.setType(LABELED_STAT);
07025: }
07026: nls();
07027: statementLabelPrefix_AST = (AST) currentAST.root;
07028: returnAST = statementLabelPrefix_AST;
07029: }
07030:
07031: /** An expression statement can be any general expression.
07032: * <p>
07033: * An expression statement can also be a <em>command</em>,
07034: * which is a simple method call in which the outermost parentheses are omitted.
07035: * <p>
07036: * Certain "suspicious" looking forms are flagged for the user to disambiguate.
07037: */
07038: public final void expressionStatement(int prevToken)
07039: throws RecognitionException, TokenStreamException {
07040:
07041: returnAST = null;
07042: ASTPair currentAST = new ASTPair();
07043: AST expressionStatement_AST = null;
07044: AST head_AST = null;
07045: AST cmd_AST = null;
07046: Token first = LT(1);
07047: boolean isPathExpr = false;
07048:
07049: {
07050: boolean synPredMatched281 = false;
07051: if (((_tokenSet_19.member(LA(1)))
07052: && (_tokenSet_8.member(LA(2))) && (_tokenSet_20
07053: .member(LA(3))))) {
07054: int _m281 = mark();
07055: synPredMatched281 = true;
07056: inputState.guessing++;
07057: try {
07058: {
07059: suspiciousExpressionStatementStart();
07060: }
07061: } catch (RecognitionException pe) {
07062: synPredMatched281 = false;
07063: }
07064: rewind(_m281);
07065: inputState.guessing--;
07066: }
07067: if (synPredMatched281) {
07068: checkSuspiciousExpressionStatement(prevToken);
07069: astFactory.addASTChild(currentAST, returnAST);
07070: } else if ((_tokenSet_19.member(LA(1)))
07071: && (_tokenSet_8.member(LA(2)))
07072: && (_tokenSet_20.member(LA(3)))) {
07073: } else {
07074: throw new NoViableAltException(LT(1), getFilename());
07075: }
07076:
07077: }
07078: expression(LC_STMT);
07079: head_AST = (AST) returnAST;
07080: astFactory.addASTChild(currentAST, returnAST);
07081: if (inputState.guessing == 0) {
07082: isPathExpr = (head_AST == lastPathExpression);
07083: }
07084: {
07085: if (((_tokenSet_19.member(LA(1)))) && (isPathExpr)) {
07086: commandArguments(head_AST);
07087: cmd_AST = (AST) returnAST;
07088: if (inputState.guessing == 0) {
07089: expressionStatement_AST = (AST) currentAST.root;
07090: expressionStatement_AST = cmd_AST;
07091: currentAST.root = expressionStatement_AST;
07092: currentAST.child = expressionStatement_AST != null
07093: && expressionStatement_AST.getFirstChild() != null ? expressionStatement_AST
07094: .getFirstChild()
07095: : expressionStatement_AST;
07096: currentAST.advanceChildToEnd();
07097: }
07098: } else if ((_tokenSet_9.member(LA(1)))) {
07099: } else {
07100: throw new NoViableAltException(LT(1), getFilename());
07101: }
07102:
07103: }
07104: if (inputState.guessing == 0) {
07105: expressionStatement_AST = (AST) currentAST.root;
07106: expressionStatement_AST = (AST) astFactory
07107: .make((new ASTArray(2)).add(
07108: create(EXPR, "EXPR", first, LT(1))).add(
07109: expressionStatement_AST));
07110: currentAST.root = expressionStatement_AST;
07111: currentAST.child = expressionStatement_AST != null
07112: && expressionStatement_AST.getFirstChild() != null ? expressionStatement_AST
07113: .getFirstChild()
07114: : expressionStatement_AST;
07115: currentAST.advanceChildToEnd();
07116: }
07117: expressionStatement_AST = (AST) currentAST.root;
07118: returnAST = expressionStatement_AST;
07119: }
07120:
07121: public final void assignmentLessExpression()
07122: throws RecognitionException, TokenStreamException {
07123:
07124: returnAST = null;
07125: ASTPair currentAST = new ASTPair();
07126: AST assignmentLessExpression_AST = null;
07127: Token first = LT(1);
07128:
07129: {
07130: conditionalExpression(0);
07131: astFactory.addASTChild(currentAST, returnAST);
07132: }
07133: if (inputState.guessing == 0) {
07134: assignmentLessExpression_AST = (AST) currentAST.root;
07135: assignmentLessExpression_AST = (AST) astFactory
07136: .make((new ASTArray(2)).add(
07137: create(EXPR, "EXPR", first, LT(1))).add(
07138: assignmentLessExpression_AST));
07139: currentAST.root = assignmentLessExpression_AST;
07140: currentAST.child = assignmentLessExpression_AST != null
07141: && assignmentLessExpression_AST.getFirstChild() != null ? assignmentLessExpression_AST
07142: .getFirstChild()
07143: : assignmentLessExpression_AST;
07144: currentAST.advanceChildToEnd();
07145: }
07146: assignmentLessExpression_AST = (AST) currentAST.root;
07147: returnAST = assignmentLessExpression_AST;
07148: }
07149:
07150: /** In Java, "if", "while", and "for" statements can take random, non-braced statements as their bodies.
07151: * Support this practice, even though it isn't very Groovy.
07152: */
07153: public final void compatibleBodyStatement()
07154: throws RecognitionException, TokenStreamException {
07155:
07156: returnAST = null;
07157: ASTPair currentAST = new ASTPair();
07158: AST compatibleBodyStatement_AST = null;
07159:
07160: boolean synPredMatched267 = false;
07161: if (((LA(1) == LCURLY) && (_tokenSet_33.member(LA(2))) && (_tokenSet_8
07162: .member(LA(3))))) {
07163: int _m267 = mark();
07164: synPredMatched267 = true;
07165: inputState.guessing++;
07166: try {
07167: {
07168: match(LCURLY);
07169: }
07170: } catch (RecognitionException pe) {
07171: synPredMatched267 = false;
07172: }
07173: rewind(_m267);
07174: inputState.guessing--;
07175: }
07176: if (synPredMatched267) {
07177: compoundStatement();
07178: astFactory.addASTChild(currentAST, returnAST);
07179: compatibleBodyStatement_AST = (AST) currentAST.root;
07180: } else if ((_tokenSet_17.member(LA(1)))
07181: && (_tokenSet_8.member(LA(2)))
07182: && (_tokenSet_18.member(LA(3)))) {
07183: statement(EOF);
07184: astFactory.addASTChild(currentAST, returnAST);
07185: compatibleBodyStatement_AST = (AST) currentAST.root;
07186: } else {
07187: throw new NoViableAltException(LT(1), getFilename());
07188: }
07189:
07190: returnAST = compatibleBodyStatement_AST;
07191: }
07192:
07193: public final void forStatement() throws RecognitionException,
07194: TokenStreamException {
07195:
07196: returnAST = null;
07197: ASTPair currentAST = new ASTPair();
07198: AST forStatement_AST = null;
07199: Token f = null;
07200: AST f_AST = null;
07201:
07202: f = LT(1);
07203: f_AST = astFactory.create(f);
07204: astFactory.makeASTRoot(currentAST, f_AST);
07205: match(LITERAL_for);
07206: match(LPAREN);
07207: {
07208: boolean synPredMatched258 = false;
07209: if (((_tokenSet_85.member(LA(1)))
07210: && (_tokenSet_75.member(LA(2))) && (_tokenSet_86
07211: .member(LA(3))))) {
07212: int _m258 = mark();
07213: synPredMatched258 = true;
07214: inputState.guessing++;
07215: try {
07216: {
07217: forInit();
07218: match(SEMI);
07219: }
07220: } catch (RecognitionException pe) {
07221: synPredMatched258 = false;
07222: }
07223: rewind(_m258);
07224: inputState.guessing--;
07225: }
07226: if (synPredMatched258) {
07227: traditionalForClause();
07228: astFactory.addASTChild(currentAST, returnAST);
07229: } else if ((_tokenSet_12.member(LA(1)))
07230: && (_tokenSet_87.member(LA(2)))
07231: && (_tokenSet_88.member(LA(3)))) {
07232: forInClause();
07233: astFactory.addASTChild(currentAST, returnAST);
07234: } else {
07235: throw new NoViableAltException(LT(1), getFilename());
07236: }
07237:
07238: }
07239: match(RPAREN);
07240: nlsWarn();
07241: compatibleBodyStatement();
07242: astFactory.addASTChild(currentAST, returnAST);
07243: forStatement_AST = (AST) currentAST.root;
07244: returnAST = forStatement_AST;
07245: }
07246:
07247: /** Things that can show up as expressions, but only in strict
07248: * contexts like inside parentheses, argument lists, and list constructors.
07249: */
07250: public final void strictContextExpression()
07251: throws RecognitionException, TokenStreamException {
07252:
07253: returnAST = null;
07254: ASTPair currentAST = new ASTPair();
07255: AST strictContextExpression_AST = null;
07256: Token first = LT(1);
07257:
07258: {
07259: boolean synPredMatched428 = false;
07260: if (((_tokenSet_12.member(LA(1)))
07261: && (_tokenSet_89.member(LA(2))) && (_tokenSet_90
07262: .member(LA(3))))) {
07263: int _m428 = mark();
07264: synPredMatched428 = true;
07265: inputState.guessing++;
07266: try {
07267: {
07268: declarationStart();
07269: }
07270: } catch (RecognitionException pe) {
07271: synPredMatched428 = false;
07272: }
07273: rewind(_m428);
07274: inputState.guessing--;
07275: }
07276: if (synPredMatched428) {
07277: singleDeclaration();
07278: astFactory.addASTChild(currentAST, returnAST);
07279: } else if ((_tokenSet_19.member(LA(1)))
07280: && (_tokenSet_68.member(LA(2)))
07281: && (_tokenSet_20.member(LA(3)))) {
07282: expression(0);
07283: astFactory.addASTChild(currentAST, returnAST);
07284: } else if (((LA(1) >= LITERAL_return && LA(1) <= LITERAL_assert))) {
07285: branchStatement();
07286: astFactory.addASTChild(currentAST, returnAST);
07287: } else if ((LA(1) == AT) && (LA(2) == IDENT)
07288: && (_tokenSet_91.member(LA(3)))) {
07289: annotation();
07290: astFactory.addASTChild(currentAST, returnAST);
07291: } else {
07292: throw new NoViableAltException(LT(1), getFilename());
07293: }
07294:
07295: }
07296: if (inputState.guessing == 0) {
07297: strictContextExpression_AST = (AST) currentAST.root;
07298: strictContextExpression_AST = (AST) astFactory
07299: .make((new ASTArray(2)).add(
07300: create(EXPR, "EXPR", first, LT(1))).add(
07301: strictContextExpression_AST));
07302: currentAST.root = strictContextExpression_AST;
07303: currentAST.child = strictContextExpression_AST != null
07304: && strictContextExpression_AST.getFirstChild() != null ? strictContextExpression_AST
07305: .getFirstChild()
07306: : strictContextExpression_AST;
07307: currentAST.advanceChildToEnd();
07308: }
07309: strictContextExpression_AST = (AST) currentAST.root;
07310: returnAST = strictContextExpression_AST;
07311: }
07312:
07313: public final void casesGroup() throws RecognitionException,
07314: TokenStreamException {
07315:
07316: returnAST = null;
07317: ASTPair currentAST = new ASTPair();
07318: AST casesGroup_AST = null;
07319: Token first = LT(1);
07320:
07321: {
07322: int _cnt293 = 0;
07323: _loop293: do {
07324: if ((LA(1) == LITERAL_default || LA(1) == LITERAL_case)) {
07325: aCase();
07326: astFactory.addASTChild(currentAST, returnAST);
07327: } else {
07328: if (_cnt293 >= 1) {
07329: break _loop293;
07330: } else {
07331: throw new NoViableAltException(LT(1),
07332: getFilename());
07333: }
07334: }
07335:
07336: _cnt293++;
07337: } while (true);
07338: }
07339: caseSList();
07340: astFactory.addASTChild(currentAST, returnAST);
07341: if (inputState.guessing == 0) {
07342: casesGroup_AST = (AST) currentAST.root;
07343: casesGroup_AST = (AST) astFactory
07344: .make((new ASTArray(2)).add(
07345: create(CASE_GROUP, "CASE_GROUP", first,
07346: LT(1))).add(casesGroup_AST));
07347: currentAST.root = casesGroup_AST;
07348: currentAST.child = casesGroup_AST != null
07349: && casesGroup_AST.getFirstChild() != null ? casesGroup_AST
07350: .getFirstChild()
07351: : casesGroup_AST;
07352: currentAST.advanceChildToEnd();
07353: }
07354: casesGroup_AST = (AST) currentAST.root;
07355: returnAST = casesGroup_AST;
07356: }
07357:
07358: public final void tryBlock() throws RecognitionException,
07359: TokenStreamException {
07360:
07361: returnAST = null;
07362: ASTPair currentAST = new ASTPair();
07363: AST tryBlock_AST = null;
07364:
07365: AST tmp166_AST = null;
07366: tmp166_AST = astFactory.create(LT(1));
07367: astFactory.makeASTRoot(currentAST, tmp166_AST);
07368: match(LITERAL_try);
07369: nlsWarn();
07370: compoundStatement();
07371: astFactory.addASTChild(currentAST, returnAST);
07372: {
07373: _loop310: do {
07374: if ((LA(1) == NLS || LA(1) == LITERAL_catch)
07375: && (LA(2) == LPAREN || LA(2) == LITERAL_catch)
07376: && (_tokenSet_92.member(LA(3)))) {
07377: nls();
07378: handler();
07379: astFactory.addASTChild(currentAST, returnAST);
07380: } else {
07381: break _loop310;
07382: }
07383:
07384: } while (true);
07385: }
07386: {
07387: if ((LA(1) == NLS || LA(1) == LITERAL_finally)
07388: && (_tokenSet_93.member(LA(2)))
07389: && (_tokenSet_33.member(LA(3)))) {
07390: nls();
07391: finallyClause();
07392: astFactory.addASTChild(currentAST, returnAST);
07393: } else if ((_tokenSet_9.member(LA(1)))
07394: && (_tokenSet_10.member(LA(2)))
07395: && (_tokenSet_11.member(LA(3)))) {
07396: } else {
07397: throw new NoViableAltException(LT(1), getFilename());
07398: }
07399:
07400: }
07401: tryBlock_AST = (AST) currentAST.root;
07402: returnAST = tryBlock_AST;
07403: }
07404:
07405: /** In Groovy, return, break, continue, throw, and assert can be used in a parenthesized expression context.
07406: * Example: println (x || (return)); println assert x, "won't print a false value!"
07407: * If an optional expression is missing, its value is void (this coerces to null when a value is required).
07408: */
07409: public final void branchStatement() throws RecognitionException,
07410: TokenStreamException {
07411:
07412: returnAST = null;
07413: ASTPair currentAST = new ASTPair();
07414: AST branchStatement_AST = null;
07415:
07416: switch (LA(1)) {
07417: case LITERAL_return: {
07418: AST tmp167_AST = null;
07419: tmp167_AST = astFactory.create(LT(1));
07420: astFactory.makeASTRoot(currentAST, tmp167_AST);
07421: match(LITERAL_return);
07422: {
07423: switch (LA(1)) {
07424: case IDENT:
07425: case LBRACK:
07426: case LPAREN:
07427: case LITERAL_super :
07428: case LITERAL_void:
07429: case LITERAL_boolean:
07430: case LITERAL_byte:
07431: case LITERAL_char:
07432: case LITERAL_short:
07433: case LITERAL_int:
07434: case LITERAL_float:
07435: case LITERAL_long:
07436: case LITERAL_double:
07437: case LITERAL_any:
07438: case LCURLY:
07439: case LITERAL_this :
07440: case STRING_LITERAL:
07441: case PLUS:
07442: case MINUS:
07443: case INC:
07444: case DEC:
07445: case BNOT:
07446: case LNOT:
07447: case DOLLAR:
07448: case STRING_CTOR_START:
07449: case LITERAL_new:
07450: case LITERAL_true:
07451: case LITERAL_false:
07452: case LITERAL_null:
07453: case NUM_INT:
07454: case NUM_FLOAT:
07455: case NUM_LONG:
07456: case NUM_DOUBLE:
07457: case NUM_BIG_INT:
07458: case NUM_BIG_DECIMAL: {
07459: expression(0);
07460: astFactory.addASTChild(currentAST, returnAST);
07461: break;
07462: }
07463: case EOF:
07464: case RBRACK:
07465: case COMMA:
07466: case RPAREN:
07467: case RCURLY:
07468: case SEMI:
07469: case NLS:
07470: case LITERAL_default:
07471: case LITERAL_else:
07472: case LITERAL_case: {
07473: break;
07474: }
07475: default: {
07476: throw new NoViableAltException(LT(1), getFilename());
07477: }
07478: }
07479: }
07480: branchStatement_AST = (AST) currentAST.root;
07481: break;
07482: }
07483: case LITERAL_break:
07484: case LITERAL_continue: {
07485: {
07486: switch (LA(1)) {
07487: case LITERAL_break: {
07488: AST tmp168_AST = null;
07489: tmp168_AST = astFactory.create(LT(1));
07490: astFactory.makeASTRoot(currentAST, tmp168_AST);
07491: match(LITERAL_break);
07492: break;
07493: }
07494: case LITERAL_continue: {
07495: AST tmp169_AST = null;
07496: tmp169_AST = astFactory.create(LT(1));
07497: astFactory.makeASTRoot(currentAST, tmp169_AST);
07498: match(LITERAL_continue);
07499: break;
07500: }
07501: default: {
07502: throw new NoViableAltException(LT(1), getFilename());
07503: }
07504: }
07505: }
07506: {
07507: boolean synPredMatched273 = false;
07508: if (((LA(1) == IDENT) && (LA(2) == COLON) && (_tokenSet_94
07509: .member(LA(3))))) {
07510: int _m273 = mark();
07511: synPredMatched273 = true;
07512: inputState.guessing++;
07513: try {
07514: {
07515: match(IDENT);
07516: match(COLON);
07517: }
07518: } catch (RecognitionException pe) {
07519: synPredMatched273 = false;
07520: }
07521: rewind(_m273);
07522: inputState.guessing--;
07523: }
07524: if (synPredMatched273) {
07525: statementLabelPrefix();
07526: astFactory.addASTChild(currentAST, returnAST);
07527: } else if ((_tokenSet_94.member(LA(1)))
07528: && (_tokenSet_20.member(LA(2)))
07529: && (_tokenSet_11.member(LA(3)))) {
07530: } else {
07531: throw new NoViableAltException(LT(1), getFilename());
07532: }
07533:
07534: }
07535: {
07536: switch (LA(1)) {
07537: case IDENT:
07538: case LBRACK:
07539: case LPAREN:
07540: case LITERAL_super :
07541: case LITERAL_void:
07542: case LITERAL_boolean:
07543: case LITERAL_byte:
07544: case LITERAL_char:
07545: case LITERAL_short:
07546: case LITERAL_int:
07547: case LITERAL_float:
07548: case LITERAL_long:
07549: case LITERAL_double:
07550: case LITERAL_any:
07551: case LCURLY:
07552: case LITERAL_this :
07553: case STRING_LITERAL:
07554: case PLUS:
07555: case MINUS:
07556: case INC:
07557: case DEC:
07558: case BNOT:
07559: case LNOT:
07560: case DOLLAR:
07561: case STRING_CTOR_START:
07562: case LITERAL_new:
07563: case LITERAL_true:
07564: case LITERAL_false:
07565: case LITERAL_null:
07566: case NUM_INT:
07567: case NUM_FLOAT:
07568: case NUM_LONG:
07569: case NUM_DOUBLE:
07570: case NUM_BIG_INT:
07571: case NUM_BIG_DECIMAL: {
07572: expression(0);
07573: astFactory.addASTChild(currentAST, returnAST);
07574: break;
07575: }
07576: case EOF:
07577: case RBRACK:
07578: case COMMA:
07579: case RPAREN:
07580: case RCURLY:
07581: case SEMI:
07582: case NLS:
07583: case LITERAL_default:
07584: case LITERAL_else:
07585: case LITERAL_case: {
07586: break;
07587: }
07588: default: {
07589: throw new NoViableAltException(LT(1), getFilename());
07590: }
07591: }
07592: }
07593: branchStatement_AST = (AST) currentAST.root;
07594: break;
07595: }
07596: case LITERAL_throw: {
07597: AST tmp170_AST = null;
07598: tmp170_AST = astFactory.create(LT(1));
07599: astFactory.makeASTRoot(currentAST, tmp170_AST);
07600: match(LITERAL_throw);
07601: expression(0);
07602: astFactory.addASTChild(currentAST, returnAST);
07603: branchStatement_AST = (AST) currentAST.root;
07604: break;
07605: }
07606: case LITERAL_assert: {
07607: AST tmp171_AST = null;
07608: tmp171_AST = astFactory.create(LT(1));
07609: astFactory.makeASTRoot(currentAST, tmp171_AST);
07610: match(LITERAL_assert);
07611: assignmentLessExpression();
07612: astFactory.addASTChild(currentAST, returnAST);
07613: {
07614: if ((LA(1) == COMMA || LA(1) == COLON)
07615: && (_tokenSet_19.member(LA(2)))
07616: && (_tokenSet_95.member(LA(3)))) {
07617: {
07618: switch (LA(1)) {
07619: case COMMA: {
07620: match(COMMA);
07621: break;
07622: }
07623: case COLON: {
07624: match(COLON);
07625: break;
07626: }
07627: default: {
07628: throw new NoViableAltException(LT(1),
07629: getFilename());
07630: }
07631: }
07632: }
07633: expression(0);
07634: astFactory.addASTChild(currentAST, returnAST);
07635: } else if ((_tokenSet_96.member(LA(1)))
07636: && (_tokenSet_97.member(LA(2)))
07637: && (_tokenSet_11.member(LA(3)))) {
07638: } else {
07639: throw new NoViableAltException(LT(1), getFilename());
07640: }
07641:
07642: }
07643: branchStatement_AST = (AST) currentAST.root;
07644: break;
07645: }
07646: default: {
07647: throw new NoViableAltException(LT(1), getFilename());
07648: }
07649: }
07650: returnAST = branchStatement_AST;
07651: }
07652:
07653: public final void forInit() throws RecognitionException,
07654: TokenStreamException {
07655:
07656: returnAST = null;
07657: ASTPair currentAST = new ASTPair();
07658: AST forInit_AST = null;
07659: Token first = LT(1);
07660:
07661: boolean synPredMatched302 = false;
07662: if (((_tokenSet_12.member(LA(1)))
07663: && (_tokenSet_13.member(LA(2))) && (_tokenSet_98
07664: .member(LA(3))))) {
07665: int _m302 = mark();
07666: synPredMatched302 = true;
07667: inputState.guessing++;
07668: try {
07669: {
07670: declarationStart();
07671: }
07672: } catch (RecognitionException pe) {
07673: synPredMatched302 = false;
07674: }
07675: rewind(_m302);
07676: inputState.guessing--;
07677: }
07678: if (synPredMatched302) {
07679: declaration();
07680: astFactory.addASTChild(currentAST, returnAST);
07681: forInit_AST = (AST) currentAST.root;
07682: } else if ((_tokenSet_85.member(LA(1)))
07683: && (_tokenSet_75.member(LA(2)))
07684: && (_tokenSet_86.member(LA(3)))) {
07685: {
07686: switch (LA(1)) {
07687: case FINAL:
07688: case ABSTRACT:
07689: case STRICTFP:
07690: case LITERAL_static:
07691: case LITERAL_def:
07692: case AT:
07693: case IDENT:
07694: case LBRACK:
07695: case LPAREN:
07696: case LITERAL_super :
07697: case LITERAL_void:
07698: case LITERAL_boolean:
07699: case LITERAL_byte:
07700: case LITERAL_char:
07701: case LITERAL_short:
07702: case LITERAL_int:
07703: case LITERAL_float:
07704: case LITERAL_long:
07705: case LITERAL_double:
07706: case LITERAL_any:
07707: case LITERAL_private:
07708: case LITERAL_public:
07709: case LITERAL_protected:
07710: case LITERAL_transient:
07711: case LITERAL_native:
07712: case LITERAL_threadsafe:
07713: case LITERAL_synchronized:
07714: case LITERAL_volatile:
07715: case LCURLY:
07716: case LITERAL_this :
07717: case STRING_LITERAL:
07718: case LITERAL_return:
07719: case LITERAL_break:
07720: case LITERAL_continue:
07721: case LITERAL_throw:
07722: case LITERAL_assert:
07723: case PLUS:
07724: case MINUS:
07725: case INC:
07726: case DEC:
07727: case BNOT:
07728: case LNOT:
07729: case DOLLAR:
07730: case STRING_CTOR_START:
07731: case LITERAL_new:
07732: case LITERAL_true:
07733: case LITERAL_false:
07734: case LITERAL_null:
07735: case NUM_INT:
07736: case NUM_FLOAT:
07737: case NUM_LONG:
07738: case NUM_DOUBLE:
07739: case NUM_BIG_INT:
07740: case NUM_BIG_DECIMAL: {
07741: controlExpressionList();
07742: astFactory.addASTChild(currentAST, returnAST);
07743: break;
07744: }
07745: case SEMI: {
07746: break;
07747: }
07748: default: {
07749: throw new NoViableAltException(LT(1), getFilename());
07750: }
07751: }
07752: }
07753: if (inputState.guessing == 0) {
07754: forInit_AST = (AST) currentAST.root;
07755: forInit_AST = (AST) astFactory
07756: .make((new ASTArray(2)).add(
07757: create(FOR_INIT, "FOR_INIT", first,
07758: LT(1))).add(forInit_AST));
07759: currentAST.root = forInit_AST;
07760: currentAST.child = forInit_AST != null
07761: && forInit_AST.getFirstChild() != null ? forInit_AST
07762: .getFirstChild()
07763: : forInit_AST;
07764: currentAST.advanceChildToEnd();
07765: }
07766: forInit_AST = (AST) currentAST.root;
07767: } else {
07768: throw new NoViableAltException(LT(1), getFilename());
07769: }
07770:
07771: returnAST = forInit_AST;
07772: }
07773:
07774: public final void traditionalForClause()
07775: throws RecognitionException, TokenStreamException {
07776:
07777: returnAST = null;
07778: ASTPair currentAST = new ASTPair();
07779: AST traditionalForClause_AST = null;
07780:
07781: forInit();
07782: astFactory.addASTChild(currentAST, returnAST);
07783: match(SEMI);
07784: forCond();
07785: astFactory.addASTChild(currentAST, returnAST);
07786: match(SEMI);
07787: forIter();
07788: astFactory.addASTChild(currentAST, returnAST);
07789: traditionalForClause_AST = (AST) currentAST.root;
07790: returnAST = traditionalForClause_AST;
07791: }
07792:
07793: public final void forInClause() throws RecognitionException,
07794: TokenStreamException {
07795:
07796: returnAST = null;
07797: ASTPair currentAST = new ASTPair();
07798: AST forInClause_AST = null;
07799: AST decl_AST = null;
07800: Token i = null;
07801: AST i_AST = null;
07802: Token c = null;
07803: AST c_AST = null;
07804:
07805: {
07806: boolean synPredMatched263 = false;
07807: if (((_tokenSet_12.member(LA(1))) && (_tokenSet_89
07808: .member(LA(2))))) {
07809: int _m263 = mark();
07810: synPredMatched263 = true;
07811: inputState.guessing++;
07812: try {
07813: {
07814: declarationStart();
07815: }
07816: } catch (RecognitionException pe) {
07817: synPredMatched263 = false;
07818: }
07819: rewind(_m263);
07820: inputState.guessing--;
07821: }
07822: if (synPredMatched263) {
07823: singleDeclarationNoInit();
07824: decl_AST = (AST) returnAST;
07825: astFactory.addASTChild(currentAST, returnAST);
07826: } else if ((LA(1) == IDENT)
07827: && (LA(2) == COLON || LA(2) == LITERAL_in)) {
07828: AST tmp176_AST = null;
07829: tmp176_AST = astFactory.create(LT(1));
07830: astFactory.addASTChild(currentAST, tmp176_AST);
07831: match(IDENT);
07832: } else {
07833: throw new NoViableAltException(LT(1), getFilename());
07834: }
07835:
07836: }
07837: {
07838: switch (LA(1)) {
07839: case LITERAL_in: {
07840: i = LT(1);
07841: i_AST = astFactory.create(i);
07842: astFactory.makeASTRoot(currentAST, i_AST);
07843: match(LITERAL_in);
07844: if (inputState.guessing == 0) {
07845: i_AST.setType(FOR_IN_ITERABLE);
07846: }
07847: shiftExpression(0);
07848: astFactory.addASTChild(currentAST, returnAST);
07849: break;
07850: }
07851: case COLON: {
07852: if (inputState.guessing == 0) {
07853: addWarning(
07854: "A colon at this point is legal Java but not recommended in Groovy.",
07855: "Use the 'in' keyword.");
07856: require(
07857: decl_AST != null,
07858: "Java-style for-each statement requires a type declaration.",
07859: "Use the 'in' keyword, as for (x in y) {...}");
07860:
07861: }
07862: c = LT(1);
07863: c_AST = astFactory.create(c);
07864: astFactory.makeASTRoot(currentAST, c_AST);
07865: match(COLON);
07866: if (inputState.guessing == 0) {
07867: c_AST.setType(FOR_IN_ITERABLE);
07868: }
07869: expression(0);
07870: astFactory.addASTChild(currentAST, returnAST);
07871: break;
07872: }
07873: default: {
07874: throw new NoViableAltException(LT(1), getFilename());
07875: }
07876: }
07877: }
07878: forInClause_AST = (AST) currentAST.root;
07879: returnAST = forInClause_AST;
07880: }
07881:
07882: public final void forCond() throws RecognitionException,
07883: TokenStreamException {
07884:
07885: returnAST = null;
07886: ASTPair currentAST = new ASTPair();
07887: AST forCond_AST = null;
07888: Token first = LT(1);
07889:
07890: {
07891: switch (LA(1)) {
07892: case FINAL:
07893: case ABSTRACT:
07894: case STRICTFP:
07895: case LITERAL_static:
07896: case LITERAL_def:
07897: case AT:
07898: case IDENT:
07899: case LBRACK:
07900: case LPAREN:
07901: case LITERAL_super :
07902: case LITERAL_void:
07903: case LITERAL_boolean:
07904: case LITERAL_byte:
07905: case LITERAL_char:
07906: case LITERAL_short:
07907: case LITERAL_int:
07908: case LITERAL_float:
07909: case LITERAL_long:
07910: case LITERAL_double:
07911: case LITERAL_any:
07912: case LITERAL_private:
07913: case LITERAL_public:
07914: case LITERAL_protected:
07915: case LITERAL_transient:
07916: case LITERAL_native:
07917: case LITERAL_threadsafe:
07918: case LITERAL_synchronized:
07919: case LITERAL_volatile:
07920: case LCURLY:
07921: case LITERAL_this :
07922: case STRING_LITERAL:
07923: case LITERAL_return:
07924: case LITERAL_break:
07925: case LITERAL_continue:
07926: case LITERAL_throw:
07927: case LITERAL_assert:
07928: case PLUS:
07929: case MINUS:
07930: case INC:
07931: case DEC:
07932: case BNOT:
07933: case LNOT:
07934: case DOLLAR:
07935: case STRING_CTOR_START:
07936: case LITERAL_new:
07937: case LITERAL_true:
07938: case LITERAL_false:
07939: case LITERAL_null:
07940: case NUM_INT:
07941: case NUM_FLOAT:
07942: case NUM_LONG:
07943: case NUM_DOUBLE:
07944: case NUM_BIG_INT:
07945: case NUM_BIG_DECIMAL: {
07946: strictContextExpression();
07947: astFactory.addASTChild(currentAST, returnAST);
07948: break;
07949: }
07950: case SEMI: {
07951: break;
07952: }
07953: default: {
07954: throw new NoViableAltException(LT(1), getFilename());
07955: }
07956: }
07957: }
07958: if (inputState.guessing == 0) {
07959: forCond_AST = (AST) currentAST.root;
07960: forCond_AST = (AST) astFactory.make((new ASTArray(2))
07961: .add(
07962: create(FOR_CONDITION, "FOR_CONDITION",
07963: first, LT(1))).add(forCond_AST));
07964: currentAST.root = forCond_AST;
07965: currentAST.child = forCond_AST != null
07966: && forCond_AST.getFirstChild() != null ? forCond_AST
07967: .getFirstChild()
07968: : forCond_AST;
07969: currentAST.advanceChildToEnd();
07970: }
07971: forCond_AST = (AST) currentAST.root;
07972: returnAST = forCond_AST;
07973: }
07974:
07975: public final void forIter() throws RecognitionException,
07976: TokenStreamException {
07977:
07978: returnAST = null;
07979: ASTPair currentAST = new ASTPair();
07980: AST forIter_AST = null;
07981: Token first = LT(1);
07982:
07983: {
07984: switch (LA(1)) {
07985: case FINAL:
07986: case ABSTRACT:
07987: case STRICTFP:
07988: case LITERAL_static:
07989: case LITERAL_def:
07990: case AT:
07991: case IDENT:
07992: case LBRACK:
07993: case LPAREN:
07994: case LITERAL_super :
07995: case LITERAL_void:
07996: case LITERAL_boolean:
07997: case LITERAL_byte:
07998: case LITERAL_char:
07999: case LITERAL_short:
08000: case LITERAL_int:
08001: case LITERAL_float:
08002: case LITERAL_long:
08003: case LITERAL_double:
08004: case LITERAL_any:
08005: case LITERAL_private:
08006: case LITERAL_public:
08007: case LITERAL_protected:
08008: case LITERAL_transient:
08009: case LITERAL_native:
08010: case LITERAL_threadsafe:
08011: case LITERAL_synchronized:
08012: case LITERAL_volatile:
08013: case LCURLY:
08014: case LITERAL_this :
08015: case STRING_LITERAL:
08016: case LITERAL_return:
08017: case LITERAL_break:
08018: case LITERAL_continue:
08019: case LITERAL_throw:
08020: case LITERAL_assert:
08021: case PLUS:
08022: case MINUS:
08023: case INC:
08024: case DEC:
08025: case BNOT:
08026: case LNOT:
08027: case DOLLAR:
08028: case STRING_CTOR_START:
08029: case LITERAL_new:
08030: case LITERAL_true:
08031: case LITERAL_false:
08032: case LITERAL_null:
08033: case NUM_INT:
08034: case NUM_FLOAT:
08035: case NUM_LONG:
08036: case NUM_DOUBLE:
08037: case NUM_BIG_INT:
08038: case NUM_BIG_DECIMAL: {
08039: controlExpressionList();
08040: astFactory.addASTChild(currentAST, returnAST);
08041: break;
08042: }
08043: case RPAREN: {
08044: break;
08045: }
08046: default: {
08047: throw new NoViableAltException(LT(1), getFilename());
08048: }
08049: }
08050: }
08051: if (inputState.guessing == 0) {
08052: forIter_AST = (AST) currentAST.root;
08053: forIter_AST = (AST) astFactory.make((new ASTArray(2)).add(
08054: create(FOR_ITERATOR, "FOR_ITERATOR", first, LT(1)))
08055: .add(forIter_AST));
08056: currentAST.root = forIter_AST;
08057: currentAST.child = forIter_AST != null
08058: && forIter_AST.getFirstChild() != null ? forIter_AST
08059: .getFirstChild()
08060: : forIter_AST;
08061: currentAST.advanceChildToEnd();
08062: }
08063: forIter_AST = (AST) currentAST.root;
08064: returnAST = forIter_AST;
08065: }
08066:
08067: public final void shiftExpression(int lc_stmt)
08068: throws RecognitionException, TokenStreamException {
08069:
08070: returnAST = null;
08071: ASTPair currentAST = new ASTPair();
08072: AST shiftExpression_AST = null;
08073:
08074: additiveExpression(lc_stmt);
08075: astFactory.addASTChild(currentAST, returnAST);
08076: {
08077: _loop380: do {
08078: if ((_tokenSet_99.member(LA(1)))) {
08079: {
08080: switch (LA(1)) {
08081: case SR:
08082: case BSR:
08083: case SL: {
08084: {
08085: switch (LA(1)) {
08086: case SL: {
08087: AST tmp177_AST = null;
08088: tmp177_AST = astFactory
08089: .create(LT(1));
08090: astFactory.makeASTRoot(currentAST,
08091: tmp177_AST);
08092: match(SL);
08093: break;
08094: }
08095: case SR: {
08096: AST tmp178_AST = null;
08097: tmp178_AST = astFactory
08098: .create(LT(1));
08099: astFactory.makeASTRoot(currentAST,
08100: tmp178_AST);
08101: match(SR);
08102: break;
08103: }
08104: case BSR: {
08105: AST tmp179_AST = null;
08106: tmp179_AST = astFactory
08107: .create(LT(1));
08108: astFactory.makeASTRoot(currentAST,
08109: tmp179_AST);
08110: match(BSR);
08111: break;
08112: }
08113: default: {
08114: throw new NoViableAltException(
08115: LT(1), getFilename());
08116: }
08117: }
08118: }
08119: break;
08120: }
08121: case RANGE_INCLUSIVE: {
08122: AST tmp180_AST = null;
08123: tmp180_AST = astFactory.create(LT(1));
08124: astFactory.makeASTRoot(currentAST,
08125: tmp180_AST);
08126: match(RANGE_INCLUSIVE);
08127: break;
08128: }
08129: case RANGE_EXCLUSIVE: {
08130: AST tmp181_AST = null;
08131: tmp181_AST = astFactory.create(LT(1));
08132: astFactory.makeASTRoot(currentAST,
08133: tmp181_AST);
08134: match(RANGE_EXCLUSIVE);
08135: break;
08136: }
08137: default: {
08138: throw new NoViableAltException(LT(1),
08139: getFilename());
08140: }
08141: }
08142: }
08143: nls();
08144: additiveExpression(0);
08145: astFactory.addASTChild(currentAST, returnAST);
08146: } else {
08147: break _loop380;
08148: }
08149:
08150: } while (true);
08151: }
08152: shiftExpression_AST = (AST) currentAST.root;
08153: returnAST = shiftExpression_AST;
08154: }
08155:
08156: /** Lookahead for suspicious statement warnings and errors. */
08157: public final void suspiciousExpressionStatementStart()
08158: throws RecognitionException, TokenStreamException {
08159:
08160: returnAST = null;
08161: ASTPair currentAST = new ASTPair();
08162: AST suspiciousExpressionStatementStart_AST = null;
08163:
08164: {
08165: switch (LA(1)) {
08166: case PLUS:
08167: case MINUS: {
08168: {
08169: switch (LA(1)) {
08170: case PLUS: {
08171: AST tmp182_AST = null;
08172: tmp182_AST = astFactory.create(LT(1));
08173: astFactory.addASTChild(currentAST, tmp182_AST);
08174: match(PLUS);
08175: break;
08176: }
08177: case MINUS: {
08178: AST tmp183_AST = null;
08179: tmp183_AST = astFactory.create(LT(1));
08180: astFactory.addASTChild(currentAST, tmp183_AST);
08181: match(MINUS);
08182: break;
08183: }
08184: default: {
08185: throw new NoViableAltException(LT(1),
08186: getFilename());
08187: }
08188: }
08189: }
08190: break;
08191: }
08192: case LBRACK:
08193: case LPAREN:
08194: case LCURLY: {
08195: {
08196: switch (LA(1)) {
08197: case LBRACK: {
08198: AST tmp184_AST = null;
08199: tmp184_AST = astFactory.create(LT(1));
08200: astFactory.addASTChild(currentAST, tmp184_AST);
08201: match(LBRACK);
08202: break;
08203: }
08204: case LPAREN: {
08205: AST tmp185_AST = null;
08206: tmp185_AST = astFactory.create(LT(1));
08207: astFactory.addASTChild(currentAST, tmp185_AST);
08208: match(LPAREN);
08209: break;
08210: }
08211: case LCURLY: {
08212: AST tmp186_AST = null;
08213: tmp186_AST = astFactory.create(LT(1));
08214: astFactory.addASTChild(currentAST, tmp186_AST);
08215: match(LCURLY);
08216: break;
08217: }
08218: default: {
08219: throw new NoViableAltException(LT(1),
08220: getFilename());
08221: }
08222: }
08223: }
08224: break;
08225: }
08226: default: {
08227: throw new NoViableAltException(LT(1), getFilename());
08228: }
08229: }
08230: }
08231: suspiciousExpressionStatementStart_AST = (AST) currentAST.root;
08232: returnAST = suspiciousExpressionStatementStart_AST;
08233: }
08234:
08235: /**
08236: * If two statements are separated by newline (not SEMI), the second had
08237: * better not look like the latter half of an expression. If it does, issue a warning.
08238: * <p>
08239: * Also, if the expression starts with a closure, it needs to
08240: * have an explicit parameter list, in order to avoid the appearance of a
08241: * compound statement. This is a hard error.
08242: * <p>
08243: * These rules are different from Java's "dumb expression" restriction.
08244: * Unlike Java, Groovy blocks can end with arbitrary (even dumb) expressions,
08245: * as a consequence of optional 'return' and 'continue' tokens.
08246: * <p>
08247: * To make the programmer's intention clear, a leading closure must have an
08248: * explicit parameter list, and must not follow a previous statement separated
08249: * only by newlines.
08250: */
08251: public final void checkSuspiciousExpressionStatement(int prevToken)
08252: throws RecognitionException, TokenStreamException {
08253:
08254: returnAST = null;
08255: ASTPair currentAST = new ASTPair();
08256: AST checkSuspiciousExpressionStatement_AST = null;
08257:
08258: boolean synPredMatched285 = false;
08259: if (((_tokenSet_19.member(LA(1)))
08260: && (_tokenSet_8.member(LA(2))) && (_tokenSet_20
08261: .member(LA(3))))) {
08262: int _m285 = mark();
08263: synPredMatched285 = true;
08264: inputState.guessing++;
08265: try {
08266: {
08267: if ((_tokenSet_100.member(LA(1)))) {
08268: matchNot(LCURLY);
08269: } else if ((LA(1) == LCURLY)) {
08270: match(LCURLY);
08271: closableBlockParamsStart();
08272: } else {
08273: throw new NoViableAltException(LT(1),
08274: getFilename());
08275: }
08276:
08277: }
08278: } catch (RecognitionException pe) {
08279: synPredMatched285 = false;
08280: }
08281: rewind(_m285);
08282: inputState.guessing--;
08283: }
08284: if (synPredMatched285) {
08285: {
08286: if (((_tokenSet_19.member(LA(1)))
08287: && (_tokenSet_8.member(LA(2))) && (_tokenSet_20
08288: .member(LA(3))))
08289: && (prevToken == NLS)) {
08290: if (inputState.guessing == 0) {
08291: addWarning(
08292: "Expression statement looks like it may continue a previous statement.",
08293: "Either remove previous newline, or add an explicit semicolon ';'.");
08294:
08295: }
08296: } else if ((_tokenSet_19.member(LA(1)))
08297: && (_tokenSet_8.member(LA(2)))
08298: && (_tokenSet_20.member(LA(3)))) {
08299: } else {
08300: throw new NoViableAltException(LT(1), getFilename());
08301: }
08302:
08303: }
08304: checkSuspiciousExpressionStatement_AST = (AST) currentAST.root;
08305: } else if (((_tokenSet_19.member(LA(1)))
08306: && (_tokenSet_8.member(LA(2))) && (_tokenSet_20
08307: .member(LA(3))))
08308: && (prevToken == NLS)) {
08309: if (inputState.guessing == 0) {
08310: require(
08311: false,
08312: "Closure expression looks like it may be an isolated open block, "
08313: + "or it may continue a previous statement.",
08314: "Add an explicit parameter list, as in {it -> ...}, or label it as L:{...}, "
08315: + "and also either remove previous newline, or add an explicit semicolon ';'.");
08316:
08317: }
08318: checkSuspiciousExpressionStatement_AST = (AST) currentAST.root;
08319: } else if (((_tokenSet_19.member(LA(1)))
08320: && (_tokenSet_8.member(LA(2))) && (_tokenSet_20
08321: .member(LA(3))))
08322: && (prevToken != NLS)) {
08323: if (inputState.guessing == 0) {
08324: require(
08325: false,
08326: "Closure expression looks like it may be an isolated open block.",
08327: "Add an explicit parameter list, as in {it -> ...}, or label it as L:{...}.");
08328:
08329: }
08330: checkSuspiciousExpressionStatement_AST = (AST) currentAST.root;
08331: } else {
08332: throw new NoViableAltException(LT(1), getFilename());
08333: }
08334:
08335: returnAST = checkSuspiciousExpressionStatement_AST;
08336: }
08337:
08338: /** A member name (x.y) or element name (x[y]) can serve as a command name,
08339: * which may be followed by a list of arguments.
08340: * Unlike parenthesized arguments, these must be plain expressions,
08341: * without labels or spread operators.
08342: */
08343: public final void commandArguments(AST head)
08344: throws RecognitionException, TokenStreamException {
08345:
08346: returnAST = null;
08347: ASTPair currentAST = new ASTPair();
08348: AST commandArguments_AST = null;
08349: Token first = LT(1);
08350:
08351: expression(0);
08352: astFactory.addASTChild(currentAST, returnAST);
08353: {
08354: _loop316: do {
08355: if ((LA(1) == COMMA)) {
08356: match(COMMA);
08357: nls();
08358: expression(0);
08359: astFactory.addASTChild(currentAST, returnAST);
08360: } else {
08361: break _loop316;
08362: }
08363:
08364: } while (true);
08365: }
08366: if (inputState.guessing == 0) {
08367: commandArguments_AST = (AST) currentAST.root;
08368:
08369: AST elist = (AST) astFactory.make((new ASTArray(2)).add(
08370: create(ELIST, "ELIST", first, LT(1))).add(
08371: commandArguments_AST));
08372: AST headid = getASTFactory().dup(head);
08373: headid.setType(METHOD_CALL);
08374: headid.setText("<command>");
08375: commandArguments_AST = (AST) astFactory.make((new ASTArray(
08376: 3)).add(headid).add(head).add(elist));
08377:
08378: currentAST.root = commandArguments_AST;
08379: currentAST.child = commandArguments_AST != null
08380: && commandArguments_AST.getFirstChild() != null ? commandArguments_AST
08381: .getFirstChild()
08382: : commandArguments_AST;
08383: currentAST.advanceChildToEnd();
08384: }
08385: commandArguments_AST = (AST) currentAST.root;
08386: returnAST = commandArguments_AST;
08387: }
08388:
08389: public final void aCase() throws RecognitionException,
08390: TokenStreamException {
08391:
08392: returnAST = null;
08393: ASTPair currentAST = new ASTPair();
08394: AST aCase_AST = null;
08395:
08396: {
08397: switch (LA(1)) {
08398: case LITERAL_case: {
08399: AST tmp188_AST = null;
08400: tmp188_AST = astFactory.create(LT(1));
08401: astFactory.makeASTRoot(currentAST, tmp188_AST);
08402: match(LITERAL_case);
08403: expression(0);
08404: astFactory.addASTChild(currentAST, returnAST);
08405: break;
08406: }
08407: case LITERAL_default: {
08408: AST tmp189_AST = null;
08409: tmp189_AST = astFactory.create(LT(1));
08410: astFactory.addASTChild(currentAST, tmp189_AST);
08411: match(LITERAL_default);
08412: break;
08413: }
08414: default: {
08415: throw new NoViableAltException(LT(1), getFilename());
08416: }
08417: }
08418: }
08419: match(COLON);
08420: nls();
08421: aCase_AST = (AST) currentAST.root;
08422: returnAST = aCase_AST;
08423: }
08424:
08425: public final void caseSList() throws RecognitionException,
08426: TokenStreamException {
08427:
08428: returnAST = null;
08429: ASTPair currentAST = new ASTPair();
08430: AST caseSList_AST = null;
08431: Token first = LT(1);
08432:
08433: statement(COLON);
08434: astFactory.addASTChild(currentAST, returnAST);
08435: {
08436: _loop299: do {
08437: if ((LA(1) == SEMI || LA(1) == NLS)) {
08438: sep();
08439: {
08440: switch (LA(1)) {
08441: case FINAL:
08442: case ABSTRACT:
08443: case STRICTFP:
08444: case LITERAL_import:
08445: case LITERAL_static:
08446: case LITERAL_def:
08447: case AT:
08448: case IDENT:
08449: case LBRACK:
08450: case LPAREN:
08451: case LITERAL_class:
08452: case LITERAL_interface:
08453: case LITERAL_enum:
08454: case LITERAL_super :
08455: case LITERAL_void:
08456: case LITERAL_boolean:
08457: case LITERAL_byte:
08458: case LITERAL_char:
08459: case LITERAL_short:
08460: case LITERAL_int:
08461: case LITERAL_float:
08462: case LITERAL_long:
08463: case LITERAL_double:
08464: case LITERAL_any:
08465: case STAR:
08466: case LITERAL_private:
08467: case LITERAL_public:
08468: case LITERAL_protected:
08469: case LITERAL_transient:
08470: case LITERAL_native:
08471: case LITERAL_threadsafe:
08472: case LITERAL_synchronized:
08473: case LITERAL_volatile:
08474: case LCURLY:
08475: case LITERAL_this :
08476: case STRING_LITERAL:
08477: case LITERAL_if:
08478: case LITERAL_while:
08479: case LITERAL_with:
08480: case LITERAL_switch:
08481: case LITERAL_for:
08482: case LITERAL_return:
08483: case LITERAL_break:
08484: case LITERAL_continue:
08485: case LITERAL_throw:
08486: case LITERAL_assert:
08487: case PLUS:
08488: case MINUS:
08489: case LITERAL_try:
08490: case INC:
08491: case DEC:
08492: case BNOT:
08493: case LNOT:
08494: case DOLLAR:
08495: case STRING_CTOR_START:
08496: case LITERAL_new:
08497: case LITERAL_true:
08498: case LITERAL_false:
08499: case LITERAL_null:
08500: case NUM_INT:
08501: case NUM_FLOAT:
08502: case NUM_LONG:
08503: case NUM_DOUBLE:
08504: case NUM_BIG_INT:
08505: case NUM_BIG_DECIMAL: {
08506: statement(sepToken);
08507: astFactory.addASTChild(currentAST,
08508: returnAST);
08509: break;
08510: }
08511: case RCURLY:
08512: case SEMI:
08513: case NLS:
08514: case LITERAL_default:
08515: case LITERAL_case: {
08516: break;
08517: }
08518: default: {
08519: throw new NoViableAltException(LT(1),
08520: getFilename());
08521: }
08522: }
08523: }
08524: } else {
08525: break _loop299;
08526: }
08527:
08528: } while (true);
08529: }
08530: if (inputState.guessing == 0) {
08531: caseSList_AST = (AST) currentAST.root;
08532: caseSList_AST = (AST) astFactory.make((new ASTArray(2))
08533: .add(create(SLIST, "SLIST", first, LT(1))).add(
08534: caseSList_AST));
08535: currentAST.root = caseSList_AST;
08536: currentAST.child = caseSList_AST != null
08537: && caseSList_AST.getFirstChild() != null ? caseSList_AST
08538: .getFirstChild()
08539: : caseSList_AST;
08540: currentAST.advanceChildToEnd();
08541: }
08542: caseSList_AST = (AST) currentAST.root;
08543: returnAST = caseSList_AST;
08544: }
08545:
08546: public final void controlExpressionList()
08547: throws RecognitionException, TokenStreamException {
08548:
08549: returnAST = null;
08550: ASTPair currentAST = new ASTPair();
08551: AST controlExpressionList_AST = null;
08552: Token first = LT(1);
08553:
08554: strictContextExpression();
08555: astFactory.addASTChild(currentAST, returnAST);
08556: {
08557: _loop320: do {
08558: if ((LA(1) == COMMA)) {
08559: match(COMMA);
08560: nls();
08561: strictContextExpression();
08562: astFactory.addASTChild(currentAST, returnAST);
08563: } else {
08564: break _loop320;
08565: }
08566:
08567: } while (true);
08568: }
08569: if (inputState.guessing == 0) {
08570: controlExpressionList_AST = (AST) currentAST.root;
08571: controlExpressionList_AST = (AST) astFactory
08572: .make((new ASTArray(2)).add(
08573: create(ELIST, "ELIST", first, LT(1))).add(
08574: controlExpressionList_AST));
08575: currentAST.root = controlExpressionList_AST;
08576: currentAST.child = controlExpressionList_AST != null
08577: && controlExpressionList_AST.getFirstChild() != null ? controlExpressionList_AST
08578: .getFirstChild()
08579: : controlExpressionList_AST;
08580: currentAST.advanceChildToEnd();
08581: }
08582: controlExpressionList_AST = (AST) currentAST.root;
08583: returnAST = controlExpressionList_AST;
08584: }
08585:
08586: public final void handler() throws RecognitionException,
08587: TokenStreamException {
08588:
08589: returnAST = null;
08590: ASTPair currentAST = new ASTPair();
08591: AST handler_AST = null;
08592:
08593: AST tmp192_AST = null;
08594: tmp192_AST = astFactory.create(LT(1));
08595: astFactory.makeASTRoot(currentAST, tmp192_AST);
08596: match(LITERAL_catch);
08597: match(LPAREN);
08598: parameterDeclaration();
08599: astFactory.addASTChild(currentAST, returnAST);
08600: match(RPAREN);
08601: nlsWarn();
08602: compoundStatement();
08603: astFactory.addASTChild(currentAST, returnAST);
08604: handler_AST = (AST) currentAST.root;
08605: returnAST = handler_AST;
08606: }
08607:
08608: public final void finallyClause() throws RecognitionException,
08609: TokenStreamException {
08610:
08611: returnAST = null;
08612: ASTPair currentAST = new ASTPair();
08613: AST finallyClause_AST = null;
08614:
08615: AST tmp195_AST = null;
08616: tmp195_AST = astFactory.create(LT(1));
08617: astFactory.makeASTRoot(currentAST, tmp195_AST);
08618: match(LITERAL_finally);
08619: nlsWarn();
08620: compoundStatement();
08621: astFactory.addASTChild(currentAST, returnAST);
08622: finallyClause_AST = (AST) currentAST.root;
08623: returnAST = finallyClause_AST;
08624: }
08625:
08626: public final void assignmentExpression(int lc_stmt)
08627: throws RecognitionException, TokenStreamException {
08628:
08629: returnAST = null;
08630: ASTPair currentAST = new ASTPair();
08631: AST assignmentExpression_AST = null;
08632:
08633: conditionalExpression(lc_stmt);
08634: astFactory.addASTChild(currentAST, returnAST);
08635: {
08636: switch (LA(1)) {
08637: case ASSIGN:
08638: case PLUS_ASSIGN:
08639: case MINUS_ASSIGN:
08640: case STAR_ASSIGN:
08641: case DIV_ASSIGN:
08642: case MOD_ASSIGN:
08643: case SR_ASSIGN:
08644: case BSR_ASSIGN:
08645: case SL_ASSIGN:
08646: case BAND_ASSIGN:
08647: case BXOR_ASSIGN:
08648: case BOR_ASSIGN:
08649: case STAR_STAR_ASSIGN: {
08650: {
08651: switch (LA(1)) {
08652: case ASSIGN: {
08653: AST tmp196_AST = null;
08654: tmp196_AST = astFactory.create(LT(1));
08655: astFactory.makeASTRoot(currentAST, tmp196_AST);
08656: match(ASSIGN);
08657: break;
08658: }
08659: case PLUS_ASSIGN: {
08660: AST tmp197_AST = null;
08661: tmp197_AST = astFactory.create(LT(1));
08662: astFactory.makeASTRoot(currentAST, tmp197_AST);
08663: match(PLUS_ASSIGN);
08664: break;
08665: }
08666: case MINUS_ASSIGN: {
08667: AST tmp198_AST = null;
08668: tmp198_AST = astFactory.create(LT(1));
08669: astFactory.makeASTRoot(currentAST, tmp198_AST);
08670: match(MINUS_ASSIGN);
08671: break;
08672: }
08673: case STAR_ASSIGN: {
08674: AST tmp199_AST = null;
08675: tmp199_AST = astFactory.create(LT(1));
08676: astFactory.makeASTRoot(currentAST, tmp199_AST);
08677: match(STAR_ASSIGN);
08678: break;
08679: }
08680: case DIV_ASSIGN: {
08681: AST tmp200_AST = null;
08682: tmp200_AST = astFactory.create(LT(1));
08683: astFactory.makeASTRoot(currentAST, tmp200_AST);
08684: match(DIV_ASSIGN);
08685: break;
08686: }
08687: case MOD_ASSIGN: {
08688: AST tmp201_AST = null;
08689: tmp201_AST = astFactory.create(LT(1));
08690: astFactory.makeASTRoot(currentAST, tmp201_AST);
08691: match(MOD_ASSIGN);
08692: break;
08693: }
08694: case SR_ASSIGN: {
08695: AST tmp202_AST = null;
08696: tmp202_AST = astFactory.create(LT(1));
08697: astFactory.makeASTRoot(currentAST, tmp202_AST);
08698: match(SR_ASSIGN);
08699: break;
08700: }
08701: case BSR_ASSIGN: {
08702: AST tmp203_AST = null;
08703: tmp203_AST = astFactory.create(LT(1));
08704: astFactory.makeASTRoot(currentAST, tmp203_AST);
08705: match(BSR_ASSIGN);
08706: break;
08707: }
08708: case SL_ASSIGN: {
08709: AST tmp204_AST = null;
08710: tmp204_AST = astFactory.create(LT(1));
08711: astFactory.makeASTRoot(currentAST, tmp204_AST);
08712: match(SL_ASSIGN);
08713: break;
08714: }
08715: case BAND_ASSIGN: {
08716: AST tmp205_AST = null;
08717: tmp205_AST = astFactory.create(LT(1));
08718: astFactory.makeASTRoot(currentAST, tmp205_AST);
08719: match(BAND_ASSIGN);
08720: break;
08721: }
08722: case BXOR_ASSIGN: {
08723: AST tmp206_AST = null;
08724: tmp206_AST = astFactory.create(LT(1));
08725: astFactory.makeASTRoot(currentAST, tmp206_AST);
08726: match(BXOR_ASSIGN);
08727: break;
08728: }
08729: case BOR_ASSIGN: {
08730: AST tmp207_AST = null;
08731: tmp207_AST = astFactory.create(LT(1));
08732: astFactory.makeASTRoot(currentAST, tmp207_AST);
08733: match(BOR_ASSIGN);
08734: break;
08735: }
08736: case STAR_STAR_ASSIGN: {
08737: AST tmp208_AST = null;
08738: tmp208_AST = astFactory.create(LT(1));
08739: astFactory.makeASTRoot(currentAST, tmp208_AST);
08740: match(STAR_STAR_ASSIGN);
08741: break;
08742: }
08743: default: {
08744: throw new NoViableAltException(LT(1),
08745: getFilename());
08746: }
08747: }
08748: }
08749: nls();
08750: assignmentExpression(lc_stmt == LC_STMT ? LC_INIT : 0);
08751: astFactory.addASTChild(currentAST, returnAST);
08752: break;
08753: }
08754: case EOF:
08755: case IDENT:
08756: case LBRACK:
08757: case RBRACK:
08758: case LPAREN:
08759: case LITERAL_super :
08760: case COMMA:
08761: case LITERAL_void:
08762: case LITERAL_boolean:
08763: case LITERAL_byte:
08764: case LITERAL_char:
08765: case LITERAL_short:
08766: case LITERAL_int:
08767: case LITERAL_float:
08768: case LITERAL_long:
08769: case LITERAL_double:
08770: case LITERAL_any:
08771: case RPAREN:
08772: case LCURLY:
08773: case RCURLY:
08774: case SEMI:
08775: case NLS:
08776: case LITERAL_default:
08777: case LITERAL_this :
08778: case STRING_LITERAL:
08779: case CLOSABLE_BLOCK_OP:
08780: case COLON:
08781: case LITERAL_else:
08782: case PLUS:
08783: case MINUS:
08784: case LITERAL_case:
08785: case INC:
08786: case DEC:
08787: case BNOT:
08788: case LNOT:
08789: case DOLLAR:
08790: case STRING_CTOR_START:
08791: case LITERAL_new:
08792: case LITERAL_true:
08793: case LITERAL_false:
08794: case LITERAL_null:
08795: case NUM_INT:
08796: case NUM_FLOAT:
08797: case NUM_LONG:
08798: case NUM_DOUBLE:
08799: case NUM_BIG_INT:
08800: case NUM_BIG_DECIMAL: {
08801: break;
08802: }
08803: default: {
08804: throw new NoViableAltException(LT(1), getFilename());
08805: }
08806: }
08807: }
08808: assignmentExpression_AST = (AST) currentAST.root;
08809: returnAST = assignmentExpression_AST;
08810: }
08811:
08812: /** A "path expression" is a name or other primary, possibly qualified by various
08813: * forms of dot, and/or followed by various kinds of brackets.
08814: * It can be used for value or assigned to, or else further qualified, indexed, or called.
08815: * It is called a "path" because it looks like a linear path through a data structure.
08816: * Examples: x.y, x?.y, x*.y, x.@y; x[], x[y], x[y,z]; x(), x(y), x(y,z); x{s}; a.b[n].c(x).d{s}
08817: * (Compare to a C lvalue, or LeftHandSide in the JLS section 15.26.)
08818: * General expressions are built up from path expressions, using operators like '+' and '='.
08819: */
08820: public final void pathExpression(int lc_stmt)
08821: throws RecognitionException, TokenStreamException {
08822:
08823: returnAST = null;
08824: ASTPair currentAST = new ASTPair();
08825: AST pathExpression_AST = null;
08826: AST pre_AST = null;
08827: AST pe_AST = null;
08828: AST apb_AST = null;
08829: AST prefix = null;
08830:
08831: primaryExpression();
08832: pre_AST = (AST) returnAST;
08833: if (inputState.guessing == 0) {
08834: prefix = pre_AST;
08835: }
08836: {
08837: _loop327: do {
08838: boolean synPredMatched324 = false;
08839: if (((_tokenSet_101.member(LA(1)))
08840: && (_tokenSet_102.member(LA(2))) && (_tokenSet_95
08841: .member(LA(3))))) {
08842: int _m324 = mark();
08843: synPredMatched324 = true;
08844: inputState.guessing++;
08845: try {
08846: {
08847: pathElementStart();
08848: }
08849: } catch (RecognitionException pe) {
08850: synPredMatched324 = false;
08851: }
08852: rewind(_m324);
08853: inputState.guessing--;
08854: }
08855: if (synPredMatched324) {
08856: nls();
08857: pathElement(prefix);
08858: pe_AST = (AST) returnAST;
08859: if (inputState.guessing == 0) {
08860: prefix = pe_AST;
08861: }
08862: } else {
08863: boolean synPredMatched326 = false;
08864: if ((((LA(1) == LCURLY || LA(1) == NLS)
08865: && (_tokenSet_16.member(LA(2))) && (_tokenSet_95
08866: .member(LA(3)))) && (lc_stmt == LC_STMT || lc_stmt == LC_INIT))) {
08867: int _m326 = mark();
08868: synPredMatched326 = true;
08869: inputState.guessing++;
08870: try {
08871: {
08872: nls();
08873: match(LCURLY);
08874: }
08875: } catch (RecognitionException pe) {
08876: synPredMatched326 = false;
08877: }
08878: rewind(_m326);
08879: inputState.guessing--;
08880: }
08881: if (synPredMatched326) {
08882: nlsWarn();
08883: appendedBlock(prefix);
08884: apb_AST = (AST) returnAST;
08885: if (inputState.guessing == 0) {
08886: prefix = apb_AST;
08887: }
08888: } else {
08889: break _loop327;
08890: }
08891: }
08892: } while (true);
08893: }
08894: if (inputState.guessing == 0) {
08895: pathExpression_AST = (AST) currentAST.root;
08896:
08897: pathExpression_AST = prefix;
08898: lastPathExpression = pathExpression_AST;
08899:
08900: currentAST.root = pathExpression_AST;
08901: currentAST.child = pathExpression_AST != null
08902: && pathExpression_AST.getFirstChild() != null ? pathExpression_AST
08903: .getFirstChild()
08904: : pathExpression_AST;
08905: currentAST.advanceChildToEnd();
08906: }
08907: pathExpression_AST = (AST) currentAST.root;
08908: returnAST = pathExpression_AST;
08909: }
08910:
08911: public final void primaryExpression() throws RecognitionException,
08912: TokenStreamException {
08913:
08914: returnAST = null;
08915: ASTPair currentAST = new ASTPair();
08916: AST primaryExpression_AST = null;
08917:
08918: switch (LA(1)) {
08919: case IDENT: {
08920: AST tmp209_AST = null;
08921: tmp209_AST = astFactory.create(LT(1));
08922: astFactory.addASTChild(currentAST, tmp209_AST);
08923: match(IDENT);
08924: primaryExpression_AST = (AST) currentAST.root;
08925: break;
08926: }
08927: case STRING_LITERAL:
08928: case LITERAL_true:
08929: case LITERAL_false:
08930: case LITERAL_null:
08931: case NUM_INT:
08932: case NUM_FLOAT:
08933: case NUM_LONG:
08934: case NUM_DOUBLE:
08935: case NUM_BIG_INT:
08936: case NUM_BIG_DECIMAL: {
08937: constant();
08938: astFactory.addASTChild(currentAST, returnAST);
08939: primaryExpression_AST = (AST) currentAST.root;
08940: break;
08941: }
08942: case LITERAL_new: {
08943: newExpression();
08944: astFactory.addASTChild(currentAST, returnAST);
08945: primaryExpression_AST = (AST) currentAST.root;
08946: break;
08947: }
08948: case LITERAL_this : {
08949: AST tmp210_AST = null;
08950: tmp210_AST = astFactory.create(LT(1));
08951: astFactory.addASTChild(currentAST, tmp210_AST);
08952: match(LITERAL_this );
08953: primaryExpression_AST = (AST) currentAST.root;
08954: break;
08955: }
08956: case LITERAL_super : {
08957: AST tmp211_AST = null;
08958: tmp211_AST = astFactory.create(LT(1));
08959: astFactory.addASTChild(currentAST, tmp211_AST);
08960: match(LITERAL_super );
08961: primaryExpression_AST = (AST) currentAST.root;
08962: break;
08963: }
08964: case LPAREN: {
08965: parenthesizedExpression();
08966: astFactory.addASTChild(currentAST, returnAST);
08967: primaryExpression_AST = (AST) currentAST.root;
08968: break;
08969: }
08970: case LCURLY: {
08971: closableBlockConstructorExpression();
08972: astFactory.addASTChild(currentAST, returnAST);
08973: primaryExpression_AST = (AST) currentAST.root;
08974: break;
08975: }
08976: case LBRACK: {
08977: listOrMapConstructorExpression();
08978: astFactory.addASTChild(currentAST, returnAST);
08979: primaryExpression_AST = (AST) currentAST.root;
08980: break;
08981: }
08982: case STRING_CTOR_START: {
08983: stringConstructorExpression();
08984: astFactory.addASTChild(currentAST, returnAST);
08985: primaryExpression_AST = (AST) currentAST.root;
08986: break;
08987: }
08988: case DOLLAR: {
08989: scopeEscapeExpression();
08990: astFactory.addASTChild(currentAST, returnAST);
08991: primaryExpression_AST = (AST) currentAST.root;
08992: break;
08993: }
08994: case LITERAL_void:
08995: case LITERAL_boolean:
08996: case LITERAL_byte:
08997: case LITERAL_char:
08998: case LITERAL_short:
08999: case LITERAL_int:
09000: case LITERAL_float:
09001: case LITERAL_long:
09002: case LITERAL_double:
09003: case LITERAL_any: {
09004: builtInType();
09005: astFactory.addASTChild(currentAST, returnAST);
09006: primaryExpression_AST = (AST) currentAST.root;
09007: break;
09008: }
09009: default: {
09010: throw new NoViableAltException(LT(1), getFilename());
09011: }
09012: }
09013: returnAST = primaryExpression_AST;
09014: }
09015:
09016: public final void pathElementStart() throws RecognitionException,
09017: TokenStreamException {
09018:
09019: returnAST = null;
09020: ASTPair currentAST = new ASTPair();
09021: AST pathElementStart_AST = null;
09022:
09023: switch (LA(1)) {
09024: case DOT:
09025: case NLS: {
09026: {
09027: nls();
09028: AST tmp212_AST = null;
09029: tmp212_AST = astFactory.create(LT(1));
09030: match(DOT);
09031: }
09032: break;
09033: }
09034: case SPREAD_DOT: {
09035: AST tmp213_AST = null;
09036: tmp213_AST = astFactory.create(LT(1));
09037: match(SPREAD_DOT);
09038: break;
09039: }
09040: case OPTIONAL_DOT: {
09041: AST tmp214_AST = null;
09042: tmp214_AST = astFactory.create(LT(1));
09043: match(OPTIONAL_DOT);
09044: break;
09045: }
09046: case MEMBER_POINTER: {
09047: AST tmp215_AST = null;
09048: tmp215_AST = astFactory.create(LT(1));
09049: match(MEMBER_POINTER);
09050: break;
09051: }
09052: case LBRACK: {
09053: AST tmp216_AST = null;
09054: tmp216_AST = astFactory.create(LT(1));
09055: match(LBRACK);
09056: break;
09057: }
09058: case LPAREN: {
09059: AST tmp217_AST = null;
09060: tmp217_AST = astFactory.create(LT(1));
09061: match(LPAREN);
09062: break;
09063: }
09064: case LCURLY: {
09065: AST tmp218_AST = null;
09066: tmp218_AST = astFactory.create(LT(1));
09067: match(LCURLY);
09068: break;
09069: }
09070: default: {
09071: throw new NoViableAltException(LT(1), getFilename());
09072: }
09073: }
09074: returnAST = pathElementStart_AST;
09075: }
09076:
09077: public final void pathElement(AST prefix)
09078: throws RecognitionException, TokenStreamException {
09079:
09080: returnAST = null;
09081: ASTPair currentAST = new ASTPair();
09082: AST pathElement_AST = null;
09083: AST mca_AST = null;
09084: AST apb_AST = null;
09085: AST ipa_AST = null;
09086:
09087: switch (LA(1)) {
09088: case DOT:
09089: case NLS:
09090: case SPREAD_DOT:
09091: case OPTIONAL_DOT:
09092: case MEMBER_POINTER: {
09093: if (inputState.guessing == 0) {
09094: pathElement_AST = (AST) currentAST.root;
09095: pathElement_AST = prefix;
09096: currentAST.root = pathElement_AST;
09097: currentAST.child = pathElement_AST != null
09098: && pathElement_AST.getFirstChild() != null ? pathElement_AST
09099: .getFirstChild()
09100: : pathElement_AST;
09101: currentAST.advanceChildToEnd();
09102: }
09103: {
09104: switch (LA(1)) {
09105: case SPREAD_DOT: {
09106: AST tmp219_AST = null;
09107: tmp219_AST = astFactory.create(LT(1));
09108: astFactory.makeASTRoot(currentAST, tmp219_AST);
09109: match(SPREAD_DOT);
09110: break;
09111: }
09112: case OPTIONAL_DOT: {
09113: AST tmp220_AST = null;
09114: tmp220_AST = astFactory.create(LT(1));
09115: astFactory.makeASTRoot(currentAST, tmp220_AST);
09116: match(OPTIONAL_DOT);
09117: break;
09118: }
09119: case MEMBER_POINTER: {
09120: AST tmp221_AST = null;
09121: tmp221_AST = astFactory.create(LT(1));
09122: astFactory.makeASTRoot(currentAST, tmp221_AST);
09123: match(MEMBER_POINTER);
09124: break;
09125: }
09126: case DOT:
09127: case NLS: {
09128: {
09129: nls();
09130: AST tmp222_AST = null;
09131: tmp222_AST = astFactory.create(LT(1));
09132: astFactory.makeASTRoot(currentAST, tmp222_AST);
09133: match(DOT);
09134: }
09135: break;
09136: }
09137: default: {
09138: throw new NoViableAltException(LT(1), getFilename());
09139: }
09140: }
09141: }
09142: nls();
09143: {
09144: switch (LA(1)) {
09145: case LT: {
09146: typeArguments();
09147: astFactory.addASTChild(currentAST, returnAST);
09148: break;
09149: }
09150: case UNUSED_DO:
09151: case LITERAL_def:
09152: case AT:
09153: case IDENT:
09154: case LPAREN:
09155: case LITERAL_class:
09156: case LITERAL_void:
09157: case LITERAL_boolean:
09158: case LITERAL_byte:
09159: case LITERAL_char:
09160: case LITERAL_short:
09161: case LITERAL_int:
09162: case LITERAL_float:
09163: case LITERAL_long:
09164: case LITERAL_double:
09165: case LITERAL_any:
09166: case LITERAL_as:
09167: case LCURLY:
09168: case STRING_LITERAL:
09169: case LITERAL_if:
09170: case LITERAL_else:
09171: case LITERAL_while:
09172: case LITERAL_switch:
09173: case LITERAL_for:
09174: case LITERAL_in:
09175: case LITERAL_try:
09176: case LITERAL_finally:
09177: case LITERAL_catch:
09178: case STRING_CTOR_START: {
09179: break;
09180: }
09181: default: {
09182: throw new NoViableAltException(LT(1), getFilename());
09183: }
09184: }
09185: }
09186: namePart();
09187: astFactory.addASTChild(currentAST, returnAST);
09188: pathElement_AST = (AST) currentAST.root;
09189: break;
09190: }
09191: case LPAREN: {
09192: methodCallArgs(prefix);
09193: mca_AST = (AST) returnAST;
09194: if (inputState.guessing == 0) {
09195: pathElement_AST = (AST) currentAST.root;
09196: pathElement_AST = mca_AST;
09197: currentAST.root = pathElement_AST;
09198: currentAST.child = pathElement_AST != null
09199: && pathElement_AST.getFirstChild() != null ? pathElement_AST
09200: .getFirstChild()
09201: : pathElement_AST;
09202: currentAST.advanceChildToEnd();
09203: }
09204: pathElement_AST = (AST) currentAST.root;
09205: break;
09206: }
09207: case LCURLY: {
09208: appendedBlock(prefix);
09209: apb_AST = (AST) returnAST;
09210: if (inputState.guessing == 0) {
09211: pathElement_AST = (AST) currentAST.root;
09212: pathElement_AST = apb_AST;
09213: currentAST.root = pathElement_AST;
09214: currentAST.child = pathElement_AST != null
09215: && pathElement_AST.getFirstChild() != null ? pathElement_AST
09216: .getFirstChild()
09217: : pathElement_AST;
09218: currentAST.advanceChildToEnd();
09219: }
09220: pathElement_AST = (AST) currentAST.root;
09221: break;
09222: }
09223: case LBRACK: {
09224: indexPropertyArgs(prefix);
09225: ipa_AST = (AST) returnAST;
09226: if (inputState.guessing == 0) {
09227: pathElement_AST = (AST) currentAST.root;
09228: pathElement_AST = ipa_AST;
09229: currentAST.root = pathElement_AST;
09230: currentAST.child = pathElement_AST != null
09231: && pathElement_AST.getFirstChild() != null ? pathElement_AST
09232: .getFirstChild()
09233: : pathElement_AST;
09234: currentAST.advanceChildToEnd();
09235: }
09236: pathElement_AST = (AST) currentAST.root;
09237: break;
09238: }
09239: default: {
09240: throw new NoViableAltException(LT(1), getFilename());
09241: }
09242: }
09243: returnAST = pathElement_AST;
09244: }
09245:
09246: /** An appended block follows any expression.
09247: * If the expression is not a method call, it is given an empty argument list.
09248: */
09249: public final void appendedBlock(AST callee)
09250: throws RecognitionException, TokenStreamException {
09251:
09252: returnAST = null;
09253: ASTPair currentAST = new ASTPair();
09254: AST appendedBlock_AST = null;
09255:
09256: if (inputState.guessing == 0) {
09257: appendedBlock_AST = (AST) currentAST.root;
09258:
09259: // If the callee is itself a call, flatten the AST.
09260: if (callee != null && callee.getType() == METHOD_CALL) {
09261: appendedBlock_AST = callee;
09262: } else {
09263: AST lbrace = getASTFactory().create(LT(1));
09264: lbrace.setType(METHOD_CALL);
09265: if (callee != null)
09266: lbrace.addChild(callee);
09267: appendedBlock_AST = lbrace;
09268: }
09269:
09270: currentAST.root = appendedBlock_AST;
09271: currentAST.child = appendedBlock_AST != null
09272: && appendedBlock_AST.getFirstChild() != null ? appendedBlock_AST
09273: .getFirstChild()
09274: : appendedBlock_AST;
09275: currentAST.advanceChildToEnd();
09276: }
09277: closableBlock();
09278: astFactory.addASTChild(currentAST, returnAST);
09279: appendedBlock_AST = (AST) currentAST.root;
09280: returnAST = appendedBlock_AST;
09281: }
09282:
09283: /** This is the grammar for what can follow a dot: x.a, x.@a, x.&a, x.'a', etc.
09284: * Note: <code>typeArguments</code> is handled by the caller of <code>namePart</code>.
09285: */
09286: public final void namePart() throws RecognitionException,
09287: TokenStreamException {
09288:
09289: returnAST = null;
09290: ASTPair currentAST = new ASTPair();
09291: AST namePart_AST = null;
09292: Token ats = null;
09293: AST ats_AST = null;
09294: Token sl = null;
09295: AST sl_AST = null;
09296: Token first = LT(1);
09297:
09298: {
09299: switch (LA(1)) {
09300: case AT: {
09301: ats = LT(1);
09302: ats_AST = astFactory.create(ats);
09303: astFactory.makeASTRoot(currentAST, ats_AST);
09304: match(AT);
09305: if (inputState.guessing == 0) {
09306: ats_AST.setType(SELECT_SLOT);
09307: }
09308: break;
09309: }
09310: case UNUSED_DO:
09311: case LITERAL_def:
09312: case IDENT:
09313: case LPAREN:
09314: case LITERAL_class:
09315: case LITERAL_void:
09316: case LITERAL_boolean:
09317: case LITERAL_byte:
09318: case LITERAL_char:
09319: case LITERAL_short:
09320: case LITERAL_int:
09321: case LITERAL_float:
09322: case LITERAL_long:
09323: case LITERAL_double:
09324: case LITERAL_any:
09325: case LITERAL_as:
09326: case LCURLY:
09327: case STRING_LITERAL:
09328: case LITERAL_if:
09329: case LITERAL_else:
09330: case LITERAL_while:
09331: case LITERAL_switch:
09332: case LITERAL_for:
09333: case LITERAL_in:
09334: case LITERAL_try:
09335: case LITERAL_finally:
09336: case LITERAL_catch:
09337: case STRING_CTOR_START: {
09338: break;
09339: }
09340: default: {
09341: throw new NoViableAltException(LT(1), getFilename());
09342: }
09343: }
09344: }
09345: {
09346: switch (LA(1)) {
09347: case IDENT: {
09348: AST tmp223_AST = null;
09349: tmp223_AST = astFactory.create(LT(1));
09350: astFactory.addASTChild(currentAST, tmp223_AST);
09351: match(IDENT);
09352: break;
09353: }
09354: case STRING_LITERAL: {
09355: sl = LT(1);
09356: sl_AST = astFactory.create(sl);
09357: astFactory.addASTChild(currentAST, sl_AST);
09358: match(STRING_LITERAL);
09359: if (inputState.guessing == 0) {
09360: sl_AST.setType(IDENT);
09361: }
09362: break;
09363: }
09364: case LPAREN:
09365: case STRING_CTOR_START: {
09366: dynamicMemberName();
09367: astFactory.addASTChild(currentAST, returnAST);
09368: break;
09369: }
09370: case LCURLY: {
09371: openBlock();
09372: astFactory.addASTChild(currentAST, returnAST);
09373: break;
09374: }
09375: case UNUSED_DO:
09376: case LITERAL_def:
09377: case LITERAL_class:
09378: case LITERAL_void:
09379: case LITERAL_boolean:
09380: case LITERAL_byte:
09381: case LITERAL_char:
09382: case LITERAL_short:
09383: case LITERAL_int:
09384: case LITERAL_float:
09385: case LITERAL_long:
09386: case LITERAL_double:
09387: case LITERAL_any:
09388: case LITERAL_as:
09389: case LITERAL_if:
09390: case LITERAL_else:
09391: case LITERAL_while:
09392: case LITERAL_switch:
09393: case LITERAL_for:
09394: case LITERAL_in:
09395: case LITERAL_try:
09396: case LITERAL_finally:
09397: case LITERAL_catch: {
09398: keywordPropertyNames();
09399: astFactory.addASTChild(currentAST, returnAST);
09400: break;
09401: }
09402: default: {
09403: throw new NoViableAltException(LT(1), getFilename());
09404: }
09405: }
09406: }
09407: namePart_AST = (AST) currentAST.root;
09408: returnAST = namePart_AST;
09409: }
09410:
09411: /** An expression may be followed by one or both of (...) and {...}.
09412: * Note: If either is (...) or {...} present, it is a method call.
09413: * The {...} is appended to the argument list, and matches a formal of type Closure.
09414: * If there is no method member, a property (or field) is used instead, and must itself be callable.
09415: * <p>
09416: * If the methodCallArgs are absent, it is a property reference.
09417: * If there is no property, it is treated as a field reference, but never a method reference.
09418: * <p>
09419: * Arguments in the (...) can be labeled, and the appended block can be labeled also.
09420: * If there is a mix of unlabeled and labeled arguments,
09421: * all the labeled arguments must follow the unlabeled arguments,
09422: * except that the closure (labeled or not) is always a separate final argument.
09423: * Labeled arguments are collected up and passed as a single argument to a formal of type Map.
09424: * <p>
09425: * Therefore, f(x,y, a:p, b:q) {s} is equivalent in all ways to f(x,y, [a:p,b:q], {s}).
09426: * Spread arguments of sequence type count as unlabeled arguments,
09427: * while spread arguments of map type count as labeled arguments.
09428: * (This distinction must sometimes be checked dynamically.)
09429: *
09430: * A plain unlabeled argument is allowed to match a trailing Map or Closure argument:
09431: * f(x, a:p) {s} === f(*[ x, [a:p], {s} ])
09432: */
09433: public final void methodCallArgs(AST callee)
09434: throws RecognitionException, TokenStreamException {
09435:
09436: returnAST = null;
09437: ASTPair currentAST = new ASTPair();
09438: AST methodCallArgs_AST = null;
09439: Token lp = null;
09440: AST lp_AST = null;
09441:
09442: if (inputState.guessing == 0) {
09443: methodCallArgs_AST = (AST) currentAST.root;
09444: methodCallArgs_AST = callee;
09445: currentAST.root = methodCallArgs_AST;
09446: currentAST.child = methodCallArgs_AST != null
09447: && methodCallArgs_AST.getFirstChild() != null ? methodCallArgs_AST
09448: .getFirstChild()
09449: : methodCallArgs_AST;
09450: currentAST.advanceChildToEnd();
09451: }
09452: lp = LT(1);
09453: lp_AST = astFactory.create(lp);
09454: astFactory.makeASTRoot(currentAST, lp_AST);
09455: match(LPAREN);
09456: if (inputState.guessing == 0) {
09457: lp_AST.setType(METHOD_CALL);
09458: }
09459: argList();
09460: astFactory.addASTChild(currentAST, returnAST);
09461: match(RPAREN);
09462: methodCallArgs_AST = (AST) currentAST.root;
09463: returnAST = methodCallArgs_AST;
09464: }
09465:
09466: /** An expression may be followed by [...].
09467: * Unlike Java, these brackets may contain a general argument list,
09468: * which is passed to the array element operator, which can make of it what it wants.
09469: * The brackets may also be empty, as in T[]. This is how Groovy names array types.
09470: * <p>Returned AST is [INDEX_OP, indexee, ELIST].
09471: */
09472: public final void indexPropertyArgs(AST indexee)
09473: throws RecognitionException, TokenStreamException {
09474:
09475: returnAST = null;
09476: ASTPair currentAST = new ASTPair();
09477: AST indexPropertyArgs_AST = null;
09478: Token lb = null;
09479: AST lb_AST = null;
09480:
09481: if (inputState.guessing == 0) {
09482: indexPropertyArgs_AST = (AST) currentAST.root;
09483: indexPropertyArgs_AST = indexee;
09484: currentAST.root = indexPropertyArgs_AST;
09485: currentAST.child = indexPropertyArgs_AST != null
09486: && indexPropertyArgs_AST.getFirstChild() != null ? indexPropertyArgs_AST
09487: .getFirstChild()
09488: : indexPropertyArgs_AST;
09489: currentAST.advanceChildToEnd();
09490: }
09491: lb = LT(1);
09492: lb_AST = astFactory.create(lb);
09493: astFactory.makeASTRoot(currentAST, lb_AST);
09494: match(LBRACK);
09495: if (inputState.guessing == 0) {
09496: lb_AST.setType(INDEX_OP);
09497: }
09498: argList();
09499: astFactory.addASTChild(currentAST, returnAST);
09500: match(RBRACK);
09501: indexPropertyArgs_AST = (AST) currentAST.root;
09502: returnAST = indexPropertyArgs_AST;
09503: }
09504:
09505: /** If a dot is followed by a parenthesized or quoted expression, the member is computed dynamically,
09506: * and the member selection is done only at runtime. This forces a statically unchecked member access.
09507: */
09508: public final void dynamicMemberName() throws RecognitionException,
09509: TokenStreamException {
09510:
09511: returnAST = null;
09512: ASTPair currentAST = new ASTPair();
09513: AST dynamicMemberName_AST = null;
09514: Token first = LT(1);
09515:
09516: {
09517: switch (LA(1)) {
09518: case LPAREN: {
09519: parenthesizedExpression();
09520: astFactory.addASTChild(currentAST, returnAST);
09521: break;
09522: }
09523: case STRING_CTOR_START: {
09524: stringConstructorExpression();
09525: astFactory.addASTChild(currentAST, returnAST);
09526: break;
09527: }
09528: default: {
09529: throw new NoViableAltException(LT(1), getFilename());
09530: }
09531: }
09532: }
09533: if (inputState.guessing == 0) {
09534: dynamicMemberName_AST = (AST) currentAST.root;
09535: dynamicMemberName_AST = (AST) astFactory
09536: .make((new ASTArray(2)).add(
09537: create(DYNAMIC_MEMBER, "DYNAMIC_MEMBER",
09538: first, LT(1))).add(
09539: dynamicMemberName_AST));
09540: currentAST.root = dynamicMemberName_AST;
09541: currentAST.child = dynamicMemberName_AST != null
09542: && dynamicMemberName_AST.getFirstChild() != null ? dynamicMemberName_AST
09543: .getFirstChild()
09544: : dynamicMemberName_AST;
09545: currentAST.advanceChildToEnd();
09546: }
09547: dynamicMemberName_AST = (AST) currentAST.root;
09548: returnAST = dynamicMemberName_AST;
09549: }
09550:
09551: /** Allowed keywords after dot (as a member name) and before colon (as a label).
09552: * TODO: What's the rationale for these?
09553: */
09554: public final void keywordPropertyNames()
09555: throws RecognitionException, TokenStreamException {
09556:
09557: returnAST = null;
09558: ASTPair currentAST = new ASTPair();
09559: AST keywordPropertyNames_AST = null;
09560:
09561: {
09562: switch (LA(1)) {
09563: case LITERAL_class: {
09564: AST tmp226_AST = null;
09565: tmp226_AST = astFactory.create(LT(1));
09566: astFactory.addASTChild(currentAST, tmp226_AST);
09567: match(LITERAL_class);
09568: break;
09569: }
09570: case LITERAL_in: {
09571: AST tmp227_AST = null;
09572: tmp227_AST = astFactory.create(LT(1));
09573: astFactory.addASTChild(currentAST, tmp227_AST);
09574: match(LITERAL_in);
09575: break;
09576: }
09577: case LITERAL_as: {
09578: AST tmp228_AST = null;
09579: tmp228_AST = astFactory.create(LT(1));
09580: astFactory.addASTChild(currentAST, tmp228_AST);
09581: match(LITERAL_as);
09582: break;
09583: }
09584: case LITERAL_def: {
09585: AST tmp229_AST = null;
09586: tmp229_AST = astFactory.create(LT(1));
09587: astFactory.addASTChild(currentAST, tmp229_AST);
09588: match(LITERAL_def);
09589: break;
09590: }
09591: case LITERAL_if: {
09592: AST tmp230_AST = null;
09593: tmp230_AST = astFactory.create(LT(1));
09594: astFactory.addASTChild(currentAST, tmp230_AST);
09595: match(LITERAL_if);
09596: break;
09597: }
09598: case LITERAL_else: {
09599: AST tmp231_AST = null;
09600: tmp231_AST = astFactory.create(LT(1));
09601: astFactory.addASTChild(currentAST, tmp231_AST);
09602: match(LITERAL_else);
09603: break;
09604: }
09605: case LITERAL_for: {
09606: AST tmp232_AST = null;
09607: tmp232_AST = astFactory.create(LT(1));
09608: astFactory.addASTChild(currentAST, tmp232_AST);
09609: match(LITERAL_for);
09610: break;
09611: }
09612: case LITERAL_while: {
09613: AST tmp233_AST = null;
09614: tmp233_AST = astFactory.create(LT(1));
09615: astFactory.addASTChild(currentAST, tmp233_AST);
09616: match(LITERAL_while);
09617: break;
09618: }
09619: case UNUSED_DO: {
09620: AST tmp234_AST = null;
09621: tmp234_AST = astFactory.create(LT(1));
09622: astFactory.addASTChild(currentAST, tmp234_AST);
09623: match(UNUSED_DO);
09624: break;
09625: }
09626: case LITERAL_switch: {
09627: AST tmp235_AST = null;
09628: tmp235_AST = astFactory.create(LT(1));
09629: astFactory.addASTChild(currentAST, tmp235_AST);
09630: match(LITERAL_switch);
09631: break;
09632: }
09633: case LITERAL_try: {
09634: AST tmp236_AST = null;
09635: tmp236_AST = astFactory.create(LT(1));
09636: astFactory.addASTChild(currentAST, tmp236_AST);
09637: match(LITERAL_try);
09638: break;
09639: }
09640: case LITERAL_catch: {
09641: AST tmp237_AST = null;
09642: tmp237_AST = astFactory.create(LT(1));
09643: astFactory.addASTChild(currentAST, tmp237_AST);
09644: match(LITERAL_catch);
09645: break;
09646: }
09647: case LITERAL_finally: {
09648: AST tmp238_AST = null;
09649: tmp238_AST = astFactory.create(LT(1));
09650: astFactory.addASTChild(currentAST, tmp238_AST);
09651: match(LITERAL_finally);
09652: break;
09653: }
09654: case LITERAL_void:
09655: case LITERAL_boolean:
09656: case LITERAL_byte:
09657: case LITERAL_char:
09658: case LITERAL_short:
09659: case LITERAL_int:
09660: case LITERAL_float:
09661: case LITERAL_long:
09662: case LITERAL_double:
09663: case LITERAL_any: {
09664: builtInType();
09665: astFactory.addASTChild(currentAST, returnAST);
09666: break;
09667: }
09668: default: {
09669: throw new NoViableAltException(LT(1), getFilename());
09670: }
09671: }
09672: }
09673: if (inputState.guessing == 0) {
09674: keywordPropertyNames_AST = (AST) currentAST.root;
09675: keywordPropertyNames_AST.setType(IDENT);
09676: }
09677: keywordPropertyNames_AST = (AST) currentAST.root;
09678: returnAST = keywordPropertyNames_AST;
09679: }
09680:
09681: public final void parenthesizedExpression()
09682: throws RecognitionException, TokenStreamException {
09683:
09684: returnAST = null;
09685: ASTPair currentAST = new ASTPair();
09686: AST parenthesizedExpression_AST = null;
09687:
09688: match(LPAREN);
09689: strictContextExpression();
09690: astFactory.addASTChild(currentAST, returnAST);
09691: match(RPAREN);
09692: parenthesizedExpression_AST = (AST) currentAST.root;
09693: returnAST = parenthesizedExpression_AST;
09694: }
09695:
09696: public final void stringConstructorExpression()
09697: throws RecognitionException, TokenStreamException {
09698:
09699: returnAST = null;
09700: ASTPair currentAST = new ASTPair();
09701: AST stringConstructorExpression_AST = null;
09702: Token cs = null;
09703: AST cs_AST = null;
09704: Token cm = null;
09705: AST cm_AST = null;
09706: Token ce = null;
09707: AST ce_AST = null;
09708: Token first = LT(1);
09709:
09710: cs = LT(1);
09711: cs_AST = astFactory.create(cs);
09712: astFactory.addASTChild(currentAST, cs_AST);
09713: match(STRING_CTOR_START);
09714: if (inputState.guessing == 0) {
09715: cs_AST.setType(STRING_LITERAL);
09716: }
09717: stringConstructorValuePart();
09718: astFactory.addASTChild(currentAST, returnAST);
09719: {
09720: _loop434: do {
09721: if ((LA(1) == STRING_CTOR_MIDDLE)) {
09722: cm = LT(1);
09723: cm_AST = astFactory.create(cm);
09724: astFactory.addASTChild(currentAST, cm_AST);
09725: match(STRING_CTOR_MIDDLE);
09726: if (inputState.guessing == 0) {
09727: cm_AST.setType(STRING_LITERAL);
09728: }
09729: stringConstructorValuePart();
09730: astFactory.addASTChild(currentAST, returnAST);
09731: } else {
09732: break _loop434;
09733: }
09734:
09735: } while (true);
09736: }
09737: ce = LT(1);
09738: ce_AST = astFactory.create(ce);
09739: astFactory.addASTChild(currentAST, ce_AST);
09740: match(STRING_CTOR_END);
09741: if (inputState.guessing == 0) {
09742: stringConstructorExpression_AST = (AST) currentAST.root;
09743: ce_AST.setType(STRING_LITERAL);
09744: stringConstructorExpression_AST = (AST) astFactory
09745: .make((new ASTArray(2))
09746: .add(
09747: create(STRING_CONSTRUCTOR,
09748: "STRING_CONSTRUCTOR",
09749: first, LT(1))).add(
09750: stringConstructorExpression_AST));
09751:
09752: currentAST.root = stringConstructorExpression_AST;
09753: currentAST.child = stringConstructorExpression_AST != null
09754: && stringConstructorExpression_AST.getFirstChild() != null ? stringConstructorExpression_AST
09755: .getFirstChild()
09756: : stringConstructorExpression_AST;
09757: currentAST.advanceChildToEnd();
09758: }
09759: stringConstructorExpression_AST = (AST) currentAST.root;
09760: returnAST = stringConstructorExpression_AST;
09761: }
09762:
09763: public final void logicalOrExpression(int lc_stmt)
09764: throws RecognitionException, TokenStreamException {
09765:
09766: returnAST = null;
09767: ASTPair currentAST = new ASTPair();
09768: AST logicalOrExpression_AST = null;
09769:
09770: logicalAndExpression(lc_stmt);
09771: astFactory.addASTChild(currentAST, returnAST);
09772: {
09773: _loop351: do {
09774: if ((LA(1) == LOR)) {
09775: AST tmp241_AST = null;
09776: tmp241_AST = astFactory.create(LT(1));
09777: astFactory.makeASTRoot(currentAST, tmp241_AST);
09778: match(LOR);
09779: nls();
09780: logicalAndExpression(0);
09781: astFactory.addASTChild(currentAST, returnAST);
09782: } else {
09783: break _loop351;
09784: }
09785:
09786: } while (true);
09787: }
09788: logicalOrExpression_AST = (AST) currentAST.root;
09789: returnAST = logicalOrExpression_AST;
09790: }
09791:
09792: public final void logicalAndExpression(int lc_stmt)
09793: throws RecognitionException, TokenStreamException {
09794:
09795: returnAST = null;
09796: ASTPair currentAST = new ASTPair();
09797: AST logicalAndExpression_AST = null;
09798:
09799: inclusiveOrExpression(lc_stmt);
09800: astFactory.addASTChild(currentAST, returnAST);
09801: {
09802: _loop354: do {
09803: if ((LA(1) == LAND)) {
09804: AST tmp242_AST = null;
09805: tmp242_AST = astFactory.create(LT(1));
09806: astFactory.makeASTRoot(currentAST, tmp242_AST);
09807: match(LAND);
09808: nls();
09809: inclusiveOrExpression(0);
09810: astFactory.addASTChild(currentAST, returnAST);
09811: } else {
09812: break _loop354;
09813: }
09814:
09815: } while (true);
09816: }
09817: logicalAndExpression_AST = (AST) currentAST.root;
09818: returnAST = logicalAndExpression_AST;
09819: }
09820:
09821: public final void inclusiveOrExpression(int lc_stmt)
09822: throws RecognitionException, TokenStreamException {
09823:
09824: returnAST = null;
09825: ASTPair currentAST = new ASTPair();
09826: AST inclusiveOrExpression_AST = null;
09827:
09828: exclusiveOrExpression(lc_stmt);
09829: astFactory.addASTChild(currentAST, returnAST);
09830: {
09831: _loop357: do {
09832: if ((LA(1) == BOR)) {
09833: AST tmp243_AST = null;
09834: tmp243_AST = astFactory.create(LT(1));
09835: astFactory.makeASTRoot(currentAST, tmp243_AST);
09836: match(BOR);
09837: nls();
09838: exclusiveOrExpression(0);
09839: astFactory.addASTChild(currentAST, returnAST);
09840: } else {
09841: break _loop357;
09842: }
09843:
09844: } while (true);
09845: }
09846: inclusiveOrExpression_AST = (AST) currentAST.root;
09847: returnAST = inclusiveOrExpression_AST;
09848: }
09849:
09850: public final void exclusiveOrExpression(int lc_stmt)
09851: throws RecognitionException, TokenStreamException {
09852:
09853: returnAST = null;
09854: ASTPair currentAST = new ASTPair();
09855: AST exclusiveOrExpression_AST = null;
09856:
09857: andExpression(lc_stmt);
09858: astFactory.addASTChild(currentAST, returnAST);
09859: {
09860: _loop360: do {
09861: if ((LA(1) == BXOR)) {
09862: AST tmp244_AST = null;
09863: tmp244_AST = astFactory.create(LT(1));
09864: astFactory.makeASTRoot(currentAST, tmp244_AST);
09865: match(BXOR);
09866: nls();
09867: andExpression(0);
09868: astFactory.addASTChild(currentAST, returnAST);
09869: } else {
09870: break _loop360;
09871: }
09872:
09873: } while (true);
09874: }
09875: exclusiveOrExpression_AST = (AST) currentAST.root;
09876: returnAST = exclusiveOrExpression_AST;
09877: }
09878:
09879: public final void andExpression(int lc_stmt)
09880: throws RecognitionException, TokenStreamException {
09881:
09882: returnAST = null;
09883: ASTPair currentAST = new ASTPair();
09884: AST andExpression_AST = null;
09885:
09886: regexExpression(lc_stmt);
09887: astFactory.addASTChild(currentAST, returnAST);
09888: {
09889: _loop363: do {
09890: if ((LA(1) == BAND)) {
09891: AST tmp245_AST = null;
09892: tmp245_AST = astFactory.create(LT(1));
09893: astFactory.makeASTRoot(currentAST, tmp245_AST);
09894: match(BAND);
09895: nls();
09896: regexExpression(0);
09897: astFactory.addASTChild(currentAST, returnAST);
09898: } else {
09899: break _loop363;
09900: }
09901:
09902: } while (true);
09903: }
09904: andExpression_AST = (AST) currentAST.root;
09905: returnAST = andExpression_AST;
09906: }
09907:
09908: public final void regexExpression(int lc_stmt)
09909: throws RecognitionException, TokenStreamException {
09910:
09911: returnAST = null;
09912: ASTPair currentAST = new ASTPair();
09913: AST regexExpression_AST = null;
09914:
09915: equalityExpression(lc_stmt);
09916: astFactory.addASTChild(currentAST, returnAST);
09917: {
09918: _loop367: do {
09919: if ((LA(1) == REGEX_FIND || LA(1) == REGEX_MATCH)) {
09920: {
09921: switch (LA(1)) {
09922: case REGEX_FIND: {
09923: AST tmp246_AST = null;
09924: tmp246_AST = astFactory.create(LT(1));
09925: astFactory.makeASTRoot(currentAST,
09926: tmp246_AST);
09927: match(REGEX_FIND);
09928: break;
09929: }
09930: case REGEX_MATCH: {
09931: AST tmp247_AST = null;
09932: tmp247_AST = astFactory.create(LT(1));
09933: astFactory.makeASTRoot(currentAST,
09934: tmp247_AST);
09935: match(REGEX_MATCH);
09936: break;
09937: }
09938: default: {
09939: throw new NoViableAltException(LT(1),
09940: getFilename());
09941: }
09942: }
09943: }
09944: nls();
09945: equalityExpression(0);
09946: astFactory.addASTChild(currentAST, returnAST);
09947: } else {
09948: break _loop367;
09949: }
09950:
09951: } while (true);
09952: }
09953: regexExpression_AST = (AST) currentAST.root;
09954: returnAST = regexExpression_AST;
09955: }
09956:
09957: public final void equalityExpression(int lc_stmt)
09958: throws RecognitionException, TokenStreamException {
09959:
09960: returnAST = null;
09961: ASTPair currentAST = new ASTPair();
09962: AST equalityExpression_AST = null;
09963:
09964: relationalExpression(lc_stmt);
09965: astFactory.addASTChild(currentAST, returnAST);
09966: {
09967: _loop371: do {
09968: if (((LA(1) >= NOT_EQUAL && LA(1) <= COMPARE_TO))) {
09969: {
09970: switch (LA(1)) {
09971: case NOT_EQUAL: {
09972: AST tmp248_AST = null;
09973: tmp248_AST = astFactory.create(LT(1));
09974: astFactory.makeASTRoot(currentAST,
09975: tmp248_AST);
09976: match(NOT_EQUAL);
09977: break;
09978: }
09979: case EQUAL: {
09980: AST tmp249_AST = null;
09981: tmp249_AST = astFactory.create(LT(1));
09982: astFactory.makeASTRoot(currentAST,
09983: tmp249_AST);
09984: match(EQUAL);
09985: break;
09986: }
09987: case COMPARE_TO: {
09988: AST tmp250_AST = null;
09989: tmp250_AST = astFactory.create(LT(1));
09990: astFactory.makeASTRoot(currentAST,
09991: tmp250_AST);
09992: match(COMPARE_TO);
09993: break;
09994: }
09995: default: {
09996: throw new NoViableAltException(LT(1),
09997: getFilename());
09998: }
09999: }
10000: }
10001: nls();
10002: relationalExpression(0);
10003: astFactory.addASTChild(currentAST, returnAST);
10004: } else {
10005: break _loop371;
10006: }
10007:
10008: } while (true);
10009: }
10010: equalityExpression_AST = (AST) currentAST.root;
10011: returnAST = equalityExpression_AST;
10012: }
10013:
10014: public final void relationalExpression(int lc_stmt)
10015: throws RecognitionException, TokenStreamException {
10016:
10017: returnAST = null;
10018: ASTPair currentAST = new ASTPair();
10019: AST relationalExpression_AST = null;
10020:
10021: shiftExpression(lc_stmt);
10022: astFactory.addASTChild(currentAST, returnAST);
10023: {
10024: switch (LA(1)) {
10025: case EOF:
10026: case IDENT:
10027: case LBRACK:
10028: case RBRACK:
10029: case LPAREN:
10030: case QUESTION:
10031: case LITERAL_super :
10032: case LT:
10033: case COMMA:
10034: case GT:
10035: case LITERAL_void:
10036: case LITERAL_boolean:
10037: case LITERAL_byte:
10038: case LITERAL_char:
10039: case LITERAL_short:
10040: case LITERAL_int:
10041: case LITERAL_float:
10042: case LITERAL_long:
10043: case LITERAL_double:
10044: case LITERAL_any:
10045: case RPAREN:
10046: case ASSIGN:
10047: case BAND:
10048: case LCURLY:
10049: case RCURLY:
10050: case SEMI:
10051: case NLS:
10052: case LITERAL_default:
10053: case LITERAL_this :
10054: case STRING_LITERAL:
10055: case CLOSABLE_BLOCK_OP:
10056: case COLON:
10057: case LITERAL_else:
10058: case LITERAL_in:
10059: case PLUS:
10060: case MINUS:
10061: case LITERAL_case:
10062: case PLUS_ASSIGN:
10063: case MINUS_ASSIGN:
10064: case STAR_ASSIGN:
10065: case DIV_ASSIGN:
10066: case MOD_ASSIGN:
10067: case SR_ASSIGN:
10068: case BSR_ASSIGN:
10069: case SL_ASSIGN:
10070: case BAND_ASSIGN:
10071: case BXOR_ASSIGN:
10072: case BOR_ASSIGN:
10073: case STAR_STAR_ASSIGN:
10074: case LOR:
10075: case LAND:
10076: case BOR:
10077: case BXOR:
10078: case REGEX_FIND:
10079: case REGEX_MATCH:
10080: case NOT_EQUAL:
10081: case EQUAL:
10082: case COMPARE_TO:
10083: case LE:
10084: case GE:
10085: case INC:
10086: case DEC:
10087: case BNOT:
10088: case LNOT:
10089: case DOLLAR:
10090: case STRING_CTOR_START:
10091: case LITERAL_new:
10092: case LITERAL_true:
10093: case LITERAL_false:
10094: case LITERAL_null:
10095: case NUM_INT:
10096: case NUM_FLOAT:
10097: case NUM_LONG:
10098: case NUM_DOUBLE:
10099: case NUM_BIG_INT:
10100: case NUM_BIG_DECIMAL: {
10101: {
10102: switch (LA(1)) {
10103: case LT:
10104: case GT:
10105: case LITERAL_in:
10106: case LE:
10107: case GE: {
10108: {
10109: switch (LA(1)) {
10110: case LT: {
10111: AST tmp251_AST = null;
10112: tmp251_AST = astFactory.create(LT(1));
10113: astFactory.makeASTRoot(currentAST,
10114: tmp251_AST);
10115: match(LT);
10116: break;
10117: }
10118: case GT: {
10119: AST tmp252_AST = null;
10120: tmp252_AST = astFactory.create(LT(1));
10121: astFactory.makeASTRoot(currentAST,
10122: tmp252_AST);
10123: match(GT);
10124: break;
10125: }
10126: case LE: {
10127: AST tmp253_AST = null;
10128: tmp253_AST = astFactory.create(LT(1));
10129: astFactory.makeASTRoot(currentAST,
10130: tmp253_AST);
10131: match(LE);
10132: break;
10133: }
10134: case GE: {
10135: AST tmp254_AST = null;
10136: tmp254_AST = astFactory.create(LT(1));
10137: astFactory.makeASTRoot(currentAST,
10138: tmp254_AST);
10139: match(GE);
10140: break;
10141: }
10142: case LITERAL_in: {
10143: AST tmp255_AST = null;
10144: tmp255_AST = astFactory.create(LT(1));
10145: astFactory.makeASTRoot(currentAST,
10146: tmp255_AST);
10147: match(LITERAL_in);
10148: break;
10149: }
10150: default: {
10151: throw new NoViableAltException(LT(1),
10152: getFilename());
10153: }
10154: }
10155: }
10156: nls();
10157: shiftExpression(0);
10158: astFactory.addASTChild(currentAST, returnAST);
10159: break;
10160: }
10161: case EOF:
10162: case IDENT:
10163: case LBRACK:
10164: case RBRACK:
10165: case LPAREN:
10166: case QUESTION:
10167: case LITERAL_super :
10168: case COMMA:
10169: case LITERAL_void:
10170: case LITERAL_boolean:
10171: case LITERAL_byte:
10172: case LITERAL_char:
10173: case LITERAL_short:
10174: case LITERAL_int:
10175: case LITERAL_float:
10176: case LITERAL_long:
10177: case LITERAL_double:
10178: case LITERAL_any:
10179: case RPAREN:
10180: case ASSIGN:
10181: case BAND:
10182: case LCURLY:
10183: case RCURLY:
10184: case SEMI:
10185: case NLS:
10186: case LITERAL_default:
10187: case LITERAL_this :
10188: case STRING_LITERAL:
10189: case CLOSABLE_BLOCK_OP:
10190: case COLON:
10191: case LITERAL_else:
10192: case PLUS:
10193: case MINUS:
10194: case LITERAL_case:
10195: case PLUS_ASSIGN:
10196: case MINUS_ASSIGN:
10197: case STAR_ASSIGN:
10198: case DIV_ASSIGN:
10199: case MOD_ASSIGN:
10200: case SR_ASSIGN:
10201: case BSR_ASSIGN:
10202: case SL_ASSIGN:
10203: case BAND_ASSIGN:
10204: case BXOR_ASSIGN:
10205: case BOR_ASSIGN:
10206: case STAR_STAR_ASSIGN:
10207: case LOR:
10208: case LAND:
10209: case BOR:
10210: case BXOR:
10211: case REGEX_FIND:
10212: case REGEX_MATCH:
10213: case NOT_EQUAL:
10214: case EQUAL:
10215: case COMPARE_TO:
10216: case INC:
10217: case DEC:
10218: case BNOT:
10219: case LNOT:
10220: case DOLLAR:
10221: case STRING_CTOR_START:
10222: case LITERAL_new:
10223: case LITERAL_true:
10224: case LITERAL_false:
10225: case LITERAL_null:
10226: case NUM_INT:
10227: case NUM_FLOAT:
10228: case NUM_LONG:
10229: case NUM_DOUBLE:
10230: case NUM_BIG_INT:
10231: case NUM_BIG_DECIMAL: {
10232: break;
10233: }
10234: default: {
10235: throw new NoViableAltException(LT(1),
10236: getFilename());
10237: }
10238: }
10239: }
10240: break;
10241: }
10242: case LITERAL_instanceof : {
10243: AST tmp256_AST = null;
10244: tmp256_AST = astFactory.create(LT(1));
10245: astFactory.makeASTRoot(currentAST, tmp256_AST);
10246: match(LITERAL_instanceof );
10247: nls();
10248: typeSpec(true);
10249: astFactory.addASTChild(currentAST, returnAST);
10250: break;
10251: }
10252: case LITERAL_as: {
10253: AST tmp257_AST = null;
10254: tmp257_AST = astFactory.create(LT(1));
10255: astFactory.makeASTRoot(currentAST, tmp257_AST);
10256: match(LITERAL_as);
10257: nls();
10258: typeSpec(true);
10259: astFactory.addASTChild(currentAST, returnAST);
10260: break;
10261: }
10262: default: {
10263: throw new NoViableAltException(LT(1), getFilename());
10264: }
10265: }
10266: }
10267: relationalExpression_AST = (AST) currentAST.root;
10268: returnAST = relationalExpression_AST;
10269: }
10270:
10271: public final void additiveExpression(int lc_stmt)
10272: throws RecognitionException, TokenStreamException {
10273:
10274: returnAST = null;
10275: ASTPair currentAST = new ASTPair();
10276: AST additiveExpression_AST = null;
10277:
10278: multiplicativeExpression(lc_stmt);
10279: astFactory.addASTChild(currentAST, returnAST);
10280: {
10281: _loop384: do {
10282: if ((LA(1) == PLUS || LA(1) == MINUS)
10283: && (_tokenSet_103.member(LA(2)))
10284: && (_tokenSet_95.member(LA(3)))) {
10285: {
10286: switch (LA(1)) {
10287: case PLUS: {
10288: AST tmp258_AST = null;
10289: tmp258_AST = astFactory.create(LT(1));
10290: astFactory.makeASTRoot(currentAST,
10291: tmp258_AST);
10292: match(PLUS);
10293: break;
10294: }
10295: case MINUS: {
10296: AST tmp259_AST = null;
10297: tmp259_AST = astFactory.create(LT(1));
10298: astFactory.makeASTRoot(currentAST,
10299: tmp259_AST);
10300: match(MINUS);
10301: break;
10302: }
10303: default: {
10304: throw new NoViableAltException(LT(1),
10305: getFilename());
10306: }
10307: }
10308: }
10309: nls();
10310: multiplicativeExpression(0);
10311: astFactory.addASTChild(currentAST, returnAST);
10312: } else {
10313: break _loop384;
10314: }
10315:
10316: } while (true);
10317: }
10318: additiveExpression_AST = (AST) currentAST.root;
10319: returnAST = additiveExpression_AST;
10320: }
10321:
10322: public final void multiplicativeExpression(int lc_stmt)
10323: throws RecognitionException, TokenStreamException {
10324:
10325: returnAST = null;
10326: ASTPair currentAST = new ASTPair();
10327: AST multiplicativeExpression_AST = null;
10328:
10329: switch (LA(1)) {
10330: case INC: {
10331: {
10332: AST tmp260_AST = null;
10333: tmp260_AST = astFactory.create(LT(1));
10334: astFactory.makeASTRoot(currentAST, tmp260_AST);
10335: match(INC);
10336: nls();
10337: powerExpressionNotPlusMinus(0);
10338: astFactory.addASTChild(currentAST, returnAST);
10339: {
10340: _loop389: do {
10341: if ((_tokenSet_104.member(LA(1)))) {
10342: {
10343: switch (LA(1)) {
10344: case STAR: {
10345: AST tmp261_AST = null;
10346: tmp261_AST = astFactory
10347: .create(LT(1));
10348: astFactory.makeASTRoot(currentAST,
10349: tmp261_AST);
10350: match(STAR);
10351: break;
10352: }
10353: case DIV: {
10354: AST tmp262_AST = null;
10355: tmp262_AST = astFactory
10356: .create(LT(1));
10357: astFactory.makeASTRoot(currentAST,
10358: tmp262_AST);
10359: match(DIV);
10360: break;
10361: }
10362: case MOD: {
10363: AST tmp263_AST = null;
10364: tmp263_AST = astFactory
10365: .create(LT(1));
10366: astFactory.makeASTRoot(currentAST,
10367: tmp263_AST);
10368: match(MOD);
10369: break;
10370: }
10371: default: {
10372: throw new NoViableAltException(
10373: LT(1), getFilename());
10374: }
10375: }
10376: }
10377: nls();
10378: powerExpression(0);
10379: astFactory.addASTChild(currentAST,
10380: returnAST);
10381: } else {
10382: break _loop389;
10383: }
10384:
10385: } while (true);
10386: }
10387: }
10388: multiplicativeExpression_AST = (AST) currentAST.root;
10389: break;
10390: }
10391: case DEC: {
10392: {
10393: AST tmp264_AST = null;
10394: tmp264_AST = astFactory.create(LT(1));
10395: astFactory.makeASTRoot(currentAST, tmp264_AST);
10396: match(DEC);
10397: nls();
10398: powerExpressionNotPlusMinus(0);
10399: astFactory.addASTChild(currentAST, returnAST);
10400: {
10401: _loop393: do {
10402: if ((_tokenSet_104.member(LA(1)))) {
10403: {
10404: switch (LA(1)) {
10405: case STAR: {
10406: AST tmp265_AST = null;
10407: tmp265_AST = astFactory
10408: .create(LT(1));
10409: astFactory.makeASTRoot(currentAST,
10410: tmp265_AST);
10411: match(STAR);
10412: break;
10413: }
10414: case DIV: {
10415: AST tmp266_AST = null;
10416: tmp266_AST = astFactory
10417: .create(LT(1));
10418: astFactory.makeASTRoot(currentAST,
10419: tmp266_AST);
10420: match(DIV);
10421: break;
10422: }
10423: case MOD: {
10424: AST tmp267_AST = null;
10425: tmp267_AST = astFactory
10426: .create(LT(1));
10427: astFactory.makeASTRoot(currentAST,
10428: tmp267_AST);
10429: match(MOD);
10430: break;
10431: }
10432: default: {
10433: throw new NoViableAltException(
10434: LT(1), getFilename());
10435: }
10436: }
10437: }
10438: nls();
10439: powerExpression(0);
10440: astFactory.addASTChild(currentAST,
10441: returnAST);
10442: } else {
10443: break _loop393;
10444: }
10445:
10446: } while (true);
10447: }
10448: }
10449: multiplicativeExpression_AST = (AST) currentAST.root;
10450: break;
10451: }
10452: case MINUS: {
10453: {
10454: AST tmp268_AST = null;
10455: tmp268_AST = astFactory.create(LT(1));
10456: astFactory.makeASTRoot(currentAST, tmp268_AST);
10457: match(MINUS);
10458: if (inputState.guessing == 0) {
10459: tmp268_AST.setType(UNARY_MINUS);
10460: }
10461: nls();
10462: powerExpressionNotPlusMinus(0);
10463: astFactory.addASTChild(currentAST, returnAST);
10464: {
10465: _loop397: do {
10466: if ((_tokenSet_104.member(LA(1)))) {
10467: {
10468: switch (LA(1)) {
10469: case STAR: {
10470: AST tmp269_AST = null;
10471: tmp269_AST = astFactory
10472: .create(LT(1));
10473: astFactory.makeASTRoot(currentAST,
10474: tmp269_AST);
10475: match(STAR);
10476: break;
10477: }
10478: case DIV: {
10479: AST tmp270_AST = null;
10480: tmp270_AST = astFactory
10481: .create(LT(1));
10482: astFactory.makeASTRoot(currentAST,
10483: tmp270_AST);
10484: match(DIV);
10485: break;
10486: }
10487: case MOD: {
10488: AST tmp271_AST = null;
10489: tmp271_AST = astFactory
10490: .create(LT(1));
10491: astFactory.makeASTRoot(currentAST,
10492: tmp271_AST);
10493: match(MOD);
10494: break;
10495: }
10496: default: {
10497: throw new NoViableAltException(
10498: LT(1), getFilename());
10499: }
10500: }
10501: }
10502: nls();
10503: powerExpression(0);
10504: astFactory.addASTChild(currentAST,
10505: returnAST);
10506: } else {
10507: break _loop397;
10508: }
10509:
10510: } while (true);
10511: }
10512: }
10513: multiplicativeExpression_AST = (AST) currentAST.root;
10514: break;
10515: }
10516: case PLUS: {
10517: {
10518: AST tmp272_AST = null;
10519: tmp272_AST = astFactory.create(LT(1));
10520: astFactory.makeASTRoot(currentAST, tmp272_AST);
10521: match(PLUS);
10522: if (inputState.guessing == 0) {
10523: tmp272_AST.setType(UNARY_PLUS);
10524: }
10525: nls();
10526: powerExpressionNotPlusMinus(0);
10527: astFactory.addASTChild(currentAST, returnAST);
10528: {
10529: _loop401: do {
10530: if ((_tokenSet_104.member(LA(1)))) {
10531: {
10532: switch (LA(1)) {
10533: case STAR: {
10534: AST tmp273_AST = null;
10535: tmp273_AST = astFactory
10536: .create(LT(1));
10537: astFactory.makeASTRoot(currentAST,
10538: tmp273_AST);
10539: match(STAR);
10540: break;
10541: }
10542: case DIV: {
10543: AST tmp274_AST = null;
10544: tmp274_AST = astFactory
10545: .create(LT(1));
10546: astFactory.makeASTRoot(currentAST,
10547: tmp274_AST);
10548: match(DIV);
10549: break;
10550: }
10551: case MOD: {
10552: AST tmp275_AST = null;
10553: tmp275_AST = astFactory
10554: .create(LT(1));
10555: astFactory.makeASTRoot(currentAST,
10556: tmp275_AST);
10557: match(MOD);
10558: break;
10559: }
10560: default: {
10561: throw new NoViableAltException(
10562: LT(1), getFilename());
10563: }
10564: }
10565: }
10566: nls();
10567: powerExpression(0);
10568: astFactory.addASTChild(currentAST,
10569: returnAST);
10570: } else {
10571: break _loop401;
10572: }
10573:
10574: } while (true);
10575: }
10576: }
10577: multiplicativeExpression_AST = (AST) currentAST.root;
10578: break;
10579: }
10580: case IDENT:
10581: case LBRACK:
10582: case LPAREN:
10583: case LITERAL_super :
10584: case LITERAL_void:
10585: case LITERAL_boolean:
10586: case LITERAL_byte:
10587: case LITERAL_char:
10588: case LITERAL_short:
10589: case LITERAL_int:
10590: case LITERAL_float:
10591: case LITERAL_long:
10592: case LITERAL_double:
10593: case LITERAL_any:
10594: case LCURLY:
10595: case LITERAL_this :
10596: case STRING_LITERAL:
10597: case BNOT:
10598: case LNOT:
10599: case DOLLAR:
10600: case STRING_CTOR_START:
10601: case LITERAL_new:
10602: case LITERAL_true:
10603: case LITERAL_false:
10604: case LITERAL_null:
10605: case NUM_INT:
10606: case NUM_FLOAT:
10607: case NUM_LONG:
10608: case NUM_DOUBLE:
10609: case NUM_BIG_INT:
10610: case NUM_BIG_DECIMAL: {
10611: {
10612: powerExpressionNotPlusMinus(lc_stmt);
10613: astFactory.addASTChild(currentAST, returnAST);
10614: {
10615: _loop405: do {
10616: if ((_tokenSet_104.member(LA(1)))) {
10617: {
10618: switch (LA(1)) {
10619: case STAR: {
10620: AST tmp276_AST = null;
10621: tmp276_AST = astFactory
10622: .create(LT(1));
10623: astFactory.makeASTRoot(currentAST,
10624: tmp276_AST);
10625: match(STAR);
10626: break;
10627: }
10628: case DIV: {
10629: AST tmp277_AST = null;
10630: tmp277_AST = astFactory
10631: .create(LT(1));
10632: astFactory.makeASTRoot(currentAST,
10633: tmp277_AST);
10634: match(DIV);
10635: break;
10636: }
10637: case MOD: {
10638: AST tmp278_AST = null;
10639: tmp278_AST = astFactory
10640: .create(LT(1));
10641: astFactory.makeASTRoot(currentAST,
10642: tmp278_AST);
10643: match(MOD);
10644: break;
10645: }
10646: default: {
10647: throw new NoViableAltException(
10648: LT(1), getFilename());
10649: }
10650: }
10651: }
10652: nls();
10653: powerExpression(0);
10654: astFactory.addASTChild(currentAST,
10655: returnAST);
10656: } else {
10657: break _loop405;
10658: }
10659:
10660: } while (true);
10661: }
10662: }
10663: multiplicativeExpression_AST = (AST) currentAST.root;
10664: break;
10665: }
10666: default: {
10667: throw new NoViableAltException(LT(1), getFilename());
10668: }
10669: }
10670: returnAST = multiplicativeExpression_AST;
10671: }
10672:
10673: public final void powerExpressionNotPlusMinus(int lc_stmt)
10674: throws RecognitionException, TokenStreamException {
10675:
10676: returnAST = null;
10677: ASTPair currentAST = new ASTPair();
10678: AST powerExpressionNotPlusMinus_AST = null;
10679:
10680: unaryExpressionNotPlusMinus(lc_stmt);
10681: astFactory.addASTChild(currentAST, returnAST);
10682: {
10683: _loop411: do {
10684: if ((LA(1) == STAR_STAR)) {
10685: AST tmp279_AST = null;
10686: tmp279_AST = astFactory.create(LT(1));
10687: astFactory.makeASTRoot(currentAST, tmp279_AST);
10688: match(STAR_STAR);
10689: nls();
10690: unaryExpression(0);
10691: astFactory.addASTChild(currentAST, returnAST);
10692: } else {
10693: break _loop411;
10694: }
10695:
10696: } while (true);
10697: }
10698: powerExpressionNotPlusMinus_AST = (AST) currentAST.root;
10699: returnAST = powerExpressionNotPlusMinus_AST;
10700: }
10701:
10702: public final void powerExpression(int lc_stmt)
10703: throws RecognitionException, TokenStreamException {
10704:
10705: returnAST = null;
10706: ASTPair currentAST = new ASTPair();
10707: AST powerExpression_AST = null;
10708:
10709: unaryExpression(lc_stmt);
10710: astFactory.addASTChild(currentAST, returnAST);
10711: {
10712: _loop408: do {
10713: if ((LA(1) == STAR_STAR)) {
10714: AST tmp280_AST = null;
10715: tmp280_AST = astFactory.create(LT(1));
10716: astFactory.makeASTRoot(currentAST, tmp280_AST);
10717: match(STAR_STAR);
10718: nls();
10719: unaryExpression(0);
10720: astFactory.addASTChild(currentAST, returnAST);
10721: } else {
10722: break _loop408;
10723: }
10724:
10725: } while (true);
10726: }
10727: powerExpression_AST = (AST) currentAST.root;
10728: returnAST = powerExpression_AST;
10729: }
10730:
10731: public final void unaryExpression(int lc_stmt)
10732: throws RecognitionException, TokenStreamException {
10733:
10734: returnAST = null;
10735: ASTPair currentAST = new ASTPair();
10736: AST unaryExpression_AST = null;
10737:
10738: switch (LA(1)) {
10739: case INC: {
10740: AST tmp281_AST = null;
10741: tmp281_AST = astFactory.create(LT(1));
10742: astFactory.makeASTRoot(currentAST, tmp281_AST);
10743: match(INC);
10744: nls();
10745: unaryExpression(0);
10746: astFactory.addASTChild(currentAST, returnAST);
10747: unaryExpression_AST = (AST) currentAST.root;
10748: break;
10749: }
10750: case DEC: {
10751: AST tmp282_AST = null;
10752: tmp282_AST = astFactory.create(LT(1));
10753: astFactory.makeASTRoot(currentAST, tmp282_AST);
10754: match(DEC);
10755: nls();
10756: unaryExpression(0);
10757: astFactory.addASTChild(currentAST, returnAST);
10758: unaryExpression_AST = (AST) currentAST.root;
10759: break;
10760: }
10761: case MINUS: {
10762: AST tmp283_AST = null;
10763: tmp283_AST = astFactory.create(LT(1));
10764: astFactory.makeASTRoot(currentAST, tmp283_AST);
10765: match(MINUS);
10766: if (inputState.guessing == 0) {
10767: tmp283_AST.setType(UNARY_MINUS);
10768: }
10769: nls();
10770: unaryExpression(0);
10771: astFactory.addASTChild(currentAST, returnAST);
10772: unaryExpression_AST = (AST) currentAST.root;
10773: break;
10774: }
10775: case PLUS: {
10776: AST tmp284_AST = null;
10777: tmp284_AST = astFactory.create(LT(1));
10778: astFactory.makeASTRoot(currentAST, tmp284_AST);
10779: match(PLUS);
10780: if (inputState.guessing == 0) {
10781: tmp284_AST.setType(UNARY_PLUS);
10782: }
10783: nls();
10784: unaryExpression(0);
10785: astFactory.addASTChild(currentAST, returnAST);
10786: unaryExpression_AST = (AST) currentAST.root;
10787: break;
10788: }
10789: case IDENT:
10790: case LBRACK:
10791: case LPAREN:
10792: case LITERAL_super :
10793: case LITERAL_void:
10794: case LITERAL_boolean:
10795: case LITERAL_byte:
10796: case LITERAL_char:
10797: case LITERAL_short:
10798: case LITERAL_int:
10799: case LITERAL_float:
10800: case LITERAL_long:
10801: case LITERAL_double:
10802: case LITERAL_any:
10803: case LCURLY:
10804: case LITERAL_this :
10805: case STRING_LITERAL:
10806: case BNOT:
10807: case LNOT:
10808: case DOLLAR:
10809: case STRING_CTOR_START:
10810: case LITERAL_new:
10811: case LITERAL_true:
10812: case LITERAL_false:
10813: case LITERAL_null:
10814: case NUM_INT:
10815: case NUM_FLOAT:
10816: case NUM_LONG:
10817: case NUM_DOUBLE:
10818: case NUM_BIG_INT:
10819: case NUM_BIG_DECIMAL: {
10820: unaryExpressionNotPlusMinus(lc_stmt);
10821: astFactory.addASTChild(currentAST, returnAST);
10822: unaryExpression_AST = (AST) currentAST.root;
10823: break;
10824: }
10825: default: {
10826: throw new NoViableAltException(LT(1), getFilename());
10827: }
10828: }
10829: returnAST = unaryExpression_AST;
10830: }
10831:
10832: public final void unaryExpressionNotPlusMinus(int lc_stmt)
10833: throws RecognitionException, TokenStreamException {
10834:
10835: returnAST = null;
10836: ASTPair currentAST = new ASTPair();
10837: AST unaryExpressionNotPlusMinus_AST = null;
10838: Token lpb = null;
10839: AST lpb_AST = null;
10840: Token lp = null;
10841: AST lp_AST = null;
10842:
10843: switch (LA(1)) {
10844: case BNOT: {
10845: AST tmp285_AST = null;
10846: tmp285_AST = astFactory.create(LT(1));
10847: astFactory.makeASTRoot(currentAST, tmp285_AST);
10848: match(BNOT);
10849: nls();
10850: unaryExpression(0);
10851: astFactory.addASTChild(currentAST, returnAST);
10852: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
10853: break;
10854: }
10855: case LNOT: {
10856: AST tmp286_AST = null;
10857: tmp286_AST = astFactory.create(LT(1));
10858: astFactory.makeASTRoot(currentAST, tmp286_AST);
10859: match(LNOT);
10860: nls();
10861: unaryExpression(0);
10862: astFactory.addASTChild(currentAST, returnAST);
10863: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
10864: break;
10865: }
10866: case IDENT:
10867: case LBRACK:
10868: case LPAREN:
10869: case LITERAL_super :
10870: case LITERAL_void:
10871: case LITERAL_boolean:
10872: case LITERAL_byte:
10873: case LITERAL_char:
10874: case LITERAL_short:
10875: case LITERAL_int:
10876: case LITERAL_float:
10877: case LITERAL_long:
10878: case LITERAL_double:
10879: case LITERAL_any:
10880: case LCURLY:
10881: case LITERAL_this :
10882: case STRING_LITERAL:
10883: case DOLLAR:
10884: case STRING_CTOR_START:
10885: case LITERAL_new:
10886: case LITERAL_true:
10887: case LITERAL_false:
10888: case LITERAL_null:
10889: case NUM_INT:
10890: case NUM_FLOAT:
10891: case NUM_LONG:
10892: case NUM_DOUBLE:
10893: case NUM_BIG_INT:
10894: case NUM_BIG_DECIMAL: {
10895: {
10896: boolean synPredMatched416 = false;
10897: if (((LA(1) == LPAREN)
10898: && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_any)) && (LA(3) == LBRACK || LA(3) == RPAREN))) {
10899: int _m416 = mark();
10900: synPredMatched416 = true;
10901: inputState.guessing++;
10902: try {
10903: {
10904: match(LPAREN);
10905: builtInTypeSpec(true);
10906: match(RPAREN);
10907: unaryExpression(0);
10908: }
10909: } catch (RecognitionException pe) {
10910: synPredMatched416 = false;
10911: }
10912: rewind(_m416);
10913: inputState.guessing--;
10914: }
10915: if (synPredMatched416) {
10916: lpb = LT(1);
10917: lpb_AST = astFactory.create(lpb);
10918: astFactory.makeASTRoot(currentAST, lpb_AST);
10919: match(LPAREN);
10920: if (inputState.guessing == 0) {
10921: lpb_AST.setType(TYPECAST);
10922: }
10923: builtInTypeSpec(true);
10924: astFactory.addASTChild(currentAST, returnAST);
10925: match(RPAREN);
10926: unaryExpression(0);
10927: astFactory.addASTChild(currentAST, returnAST);
10928: } else {
10929: boolean synPredMatched418 = false;
10930: if (((LA(1) == LPAREN) && (LA(2) == IDENT) && (_tokenSet_105
10931: .member(LA(3))))) {
10932: int _m418 = mark();
10933: synPredMatched418 = true;
10934: inputState.guessing++;
10935: try {
10936: {
10937: match(LPAREN);
10938: classTypeSpec(true);
10939: match(RPAREN);
10940: unaryExpressionNotPlusMinus(0);
10941: }
10942: } catch (RecognitionException pe) {
10943: synPredMatched418 = false;
10944: }
10945: rewind(_m418);
10946: inputState.guessing--;
10947: }
10948: if (synPredMatched418) {
10949: lp = LT(1);
10950: lp_AST = astFactory.create(lp);
10951: astFactory.makeASTRoot(currentAST, lp_AST);
10952: match(LPAREN);
10953: if (inputState.guessing == 0) {
10954: lp_AST.setType(TYPECAST);
10955: }
10956: classTypeSpec(true);
10957: astFactory.addASTChild(currentAST, returnAST);
10958: match(RPAREN);
10959: unaryExpressionNotPlusMinus(0);
10960: astFactory.addASTChild(currentAST, returnAST);
10961: } else if ((_tokenSet_106.member(LA(1)))
10962: && (_tokenSet_95.member(LA(2)))
10963: && (_tokenSet_11.member(LA(3)))) {
10964: postfixExpression(lc_stmt);
10965: astFactory.addASTChild(currentAST, returnAST);
10966: } else {
10967: throw new NoViableAltException(LT(1),
10968: getFilename());
10969: }
10970: }
10971: }
10972: unaryExpressionNotPlusMinus_AST = (AST) currentAST.root;
10973: break;
10974: }
10975: default: {
10976: throw new NoViableAltException(LT(1), getFilename());
10977: }
10978: }
10979: returnAST = unaryExpressionNotPlusMinus_AST;
10980: }
10981:
10982: public final void postfixExpression(int lc_stmt)
10983: throws RecognitionException, TokenStreamException {
10984:
10985: returnAST = null;
10986: ASTPair currentAST = new ASTPair();
10987: AST postfixExpression_AST = null;
10988: Token in = null;
10989: AST in_AST = null;
10990: Token de = null;
10991: AST de_AST = null;
10992:
10993: pathExpression(lc_stmt);
10994: astFactory.addASTChild(currentAST, returnAST);
10995: {
10996: if ((LA(1) == INC) && (_tokenSet_107.member(LA(2)))
10997: && (_tokenSet_11.member(LA(3)))) {
10998: in = LT(1);
10999: in_AST = astFactory.create(in);
11000: astFactory.makeASTRoot(currentAST, in_AST);
11001: match(INC);
11002: if (inputState.guessing == 0) {
11003: in_AST.setType(POST_INC);
11004: }
11005: } else if ((LA(1) == DEC) && (_tokenSet_107.member(LA(2)))
11006: && (_tokenSet_11.member(LA(3)))) {
11007: de = LT(1);
11008: de_AST = astFactory.create(de);
11009: astFactory.makeASTRoot(currentAST, de_AST);
11010: match(DEC);
11011: if (inputState.guessing == 0) {
11012: de_AST.setType(POST_DEC);
11013: }
11014: } else if ((_tokenSet_107.member(LA(1)))
11015: && (_tokenSet_11.member(LA(2)))
11016: && (_tokenSet_11.member(LA(3)))) {
11017: } else {
11018: throw new NoViableAltException(LT(1), getFilename());
11019: }
11020:
11021: }
11022: postfixExpression_AST = (AST) currentAST.root;
11023: returnAST = postfixExpression_AST;
11024: }
11025:
11026: /** Numeric, string, regexp, boolean, or null constant. */
11027: public final void constant() throws RecognitionException,
11028: TokenStreamException {
11029:
11030: returnAST = null;
11031: ASTPair currentAST = new ASTPair();
11032: AST constant_AST = null;
11033:
11034: switch (LA(1)) {
11035: case NUM_INT:
11036: case NUM_FLOAT:
11037: case NUM_LONG:
11038: case NUM_DOUBLE:
11039: case NUM_BIG_INT:
11040: case NUM_BIG_DECIMAL: {
11041: constantNumber();
11042: astFactory.addASTChild(currentAST, returnAST);
11043: constant_AST = (AST) currentAST.root;
11044: break;
11045: }
11046: case STRING_LITERAL: {
11047: AST tmp289_AST = null;
11048: tmp289_AST = astFactory.create(LT(1));
11049: astFactory.addASTChild(currentAST, tmp289_AST);
11050: match(STRING_LITERAL);
11051: constant_AST = (AST) currentAST.root;
11052: break;
11053: }
11054: case LITERAL_true: {
11055: AST tmp290_AST = null;
11056: tmp290_AST = astFactory.create(LT(1));
11057: astFactory.addASTChild(currentAST, tmp290_AST);
11058: match(LITERAL_true);
11059: constant_AST = (AST) currentAST.root;
11060: break;
11061: }
11062: case LITERAL_false: {
11063: AST tmp291_AST = null;
11064: tmp291_AST = astFactory.create(LT(1));
11065: astFactory.addASTChild(currentAST, tmp291_AST);
11066: match(LITERAL_false);
11067: constant_AST = (AST) currentAST.root;
11068: break;
11069: }
11070: case LITERAL_null: {
11071: AST tmp292_AST = null;
11072: tmp292_AST = astFactory.create(LT(1));
11073: astFactory.addASTChild(currentAST, tmp292_AST);
11074: match(LITERAL_null);
11075: constant_AST = (AST) currentAST.root;
11076: break;
11077: }
11078: default: {
11079: throw new NoViableAltException(LT(1), getFilename());
11080: }
11081: }
11082: returnAST = constant_AST;
11083: }
11084:
11085: /** object instantiation.
11086: * Trees are built as illustrated by the following input/tree pairs:
11087: *
11088: * new T()
11089: *
11090: * new
11091: * |
11092: * T -- ELIST
11093: * |
11094: * arg1 -- arg2 -- .. -- argn
11095: *
11096: * new int[]
11097: *
11098: * new
11099: * |
11100: * int -- ARRAY_DECLARATOR
11101: *
11102: * new int[] {1,2}
11103: *
11104: * new
11105: * |
11106: * int -- ARRAY_DECLARATOR -- ARRAY_INIT
11107: * |
11108: * EXPR -- EXPR
11109: * | |
11110: * 1 2
11111: *
11112: * new int[3]
11113: * new
11114: * |
11115: * int -- ARRAY_DECLARATOR
11116: * |
11117: * EXPR
11118: * |
11119: * 3
11120: *
11121: * new int[1][2]
11122: *
11123: * new
11124: * |
11125: * int -- ARRAY_DECLARATOR
11126: * |
11127: * ARRAY_DECLARATOR -- EXPR
11128: * | |
11129: * EXPR 1
11130: * |
11131: * 2
11132: *
11133: */
11134: public final void newExpression() throws RecognitionException,
11135: TokenStreamException {
11136:
11137: returnAST = null;
11138: ASTPair currentAST = new ASTPair();
11139: AST newExpression_AST = null;
11140: AST mca_AST = null;
11141: AST apb1_AST = null;
11142:
11143: AST tmp293_AST = null;
11144: tmp293_AST = astFactory.create(LT(1));
11145: astFactory.makeASTRoot(currentAST, tmp293_AST);
11146: match(LITERAL_new);
11147: nls();
11148: {
11149: switch (LA(1)) {
11150: case LT: {
11151: typeArguments();
11152: astFactory.addASTChild(currentAST, returnAST);
11153: break;
11154: }
11155: case IDENT:
11156: case LITERAL_void:
11157: case LITERAL_boolean:
11158: case LITERAL_byte:
11159: case LITERAL_char:
11160: case LITERAL_short:
11161: case LITERAL_int:
11162: case LITERAL_float:
11163: case LITERAL_long:
11164: case LITERAL_double:
11165: case LITERAL_any: {
11166: break;
11167: }
11168: default: {
11169: throw new NoViableAltException(LT(1), getFilename());
11170: }
11171: }
11172: }
11173: type();
11174: astFactory.addASTChild(currentAST, returnAST);
11175: {
11176: switch (LA(1)) {
11177: case LPAREN:
11178: case NLS: {
11179: nls();
11180: methodCallArgs(null);
11181: mca_AST = (AST) returnAST;
11182: {
11183: if ((LA(1) == LCURLY)
11184: && (_tokenSet_16.member(LA(2)))
11185: && (_tokenSet_95.member(LA(3)))) {
11186: appendedBlock(mca_AST);
11187: apb1_AST = (AST) returnAST;
11188: if (inputState.guessing == 0) {
11189: mca_AST = apb1_AST;
11190: }
11191: } else if ((_tokenSet_108.member(LA(1)))
11192: && (_tokenSet_11.member(LA(2)))
11193: && (_tokenSet_11.member(LA(3)))) {
11194: } else {
11195: throw new NoViableAltException(LT(1),
11196: getFilename());
11197: }
11198:
11199: }
11200: if (inputState.guessing == 0) {
11201: newExpression_AST = (AST) currentAST.root;
11202: newExpression_AST.addChild(mca_AST.getFirstChild());
11203: }
11204: break;
11205: }
11206: case LBRACK: {
11207: newArrayDeclarator();
11208: astFactory.addASTChild(currentAST, returnAST);
11209: break;
11210: }
11211: default: {
11212: throw new NoViableAltException(LT(1), getFilename());
11213: }
11214: }
11215: }
11216: newExpression_AST = (AST) currentAST.root;
11217: returnAST = newExpression_AST;
11218: }
11219:
11220: public final void closableBlockConstructorExpression()
11221: throws RecognitionException, TokenStreamException {
11222:
11223: returnAST = null;
11224: ASTPair currentAST = new ASTPair();
11225: AST closableBlockConstructorExpression_AST = null;
11226:
11227: closableBlock();
11228: astFactory.addASTChild(currentAST, returnAST);
11229: closableBlockConstructorExpression_AST = (AST) currentAST.root;
11230: returnAST = closableBlockConstructorExpression_AST;
11231: }
11232:
11233: /**
11234: * A list constructor is a argument list enclosed in square brackets, without labels.
11235: * Any argument can be decorated with a spread operator (*x), but not a label (a:x).
11236: * Examples: [], [1], [1,2], [1,*l1,2], [*l1,*l2].
11237: * (The l1, l2 must be a sequence or null.)
11238: * <p>
11239: * A map constructor is an argument list enclosed in square brackets, with labels everywhere,
11240: * except on spread arguments, which stand for whole maps spliced in.
11241: * A colon alone between the brackets also forces the expression to be an empty map constructor.
11242: * Examples: [:], [a:1], [a:1,b:2], [a:1,*:m1,b:2], [*:m1,*:m2]
11243: * (The m1, m2 must be a map or null.)
11244: * Values associated with identical keys overwrite from left to right:
11245: * [a:1,a:2] === [a:2]
11246: * <p>
11247: * Some malformed constructor expressions are not detected in the parser, but in a post-pass.
11248: * Bad examples: [1,b:2], [a:1,2], [:1].
11249: * (Note that method call arguments, by contrast, can be a mix of keyworded and non-keyworded arguments.)
11250: */
11251: public final void listOrMapConstructorExpression()
11252: throws RecognitionException, TokenStreamException {
11253:
11254: returnAST = null;
11255: ASTPair currentAST = new ASTPair();
11256: AST listOrMapConstructorExpression_AST = null;
11257: Token lcon = null;
11258: AST lcon_AST = null;
11259: Token emcon = null;
11260: AST emcon_AST = null;
11261: boolean hasLabels = false;
11262:
11263: if ((LA(1) == LBRACK) && (_tokenSet_109.member(LA(2)))) {
11264: lcon = LT(1);
11265: lcon_AST = astFactory.create(lcon);
11266: astFactory.makeASTRoot(currentAST, lcon_AST);
11267: match(LBRACK);
11268: argList();
11269: astFactory.addASTChild(currentAST, returnAST);
11270: if (inputState.guessing == 0) {
11271: hasLabels |= argListHasLabels;
11272: }
11273: match(RBRACK);
11274: if (inputState.guessing == 0) {
11275: lcon_AST.setType(hasLabels ? MAP_CONSTRUCTOR
11276: : LIST_CONSTRUCTOR);
11277: }
11278: listOrMapConstructorExpression_AST = (AST) currentAST.root;
11279: } else if ((LA(1) == LBRACK) && (LA(2) == COLON)) {
11280: emcon = LT(1);
11281: emcon_AST = astFactory.create(emcon);
11282: astFactory.makeASTRoot(currentAST, emcon_AST);
11283: match(LBRACK);
11284: match(COLON);
11285: match(RBRACK);
11286: if (inputState.guessing == 0) {
11287: emcon_AST.setType(MAP_CONSTRUCTOR);
11288: }
11289: listOrMapConstructorExpression_AST = (AST) currentAST.root;
11290: } else {
11291: throw new NoViableAltException(LT(1), getFilename());
11292: }
11293:
11294: returnAST = listOrMapConstructorExpression_AST;
11295: }
11296:
11297: public final void scopeEscapeExpression()
11298: throws RecognitionException, TokenStreamException {
11299:
11300: returnAST = null;
11301: ASTPair currentAST = new ASTPair();
11302: AST scopeEscapeExpression_AST = null;
11303:
11304: AST tmp297_AST = null;
11305: tmp297_AST = astFactory.create(LT(1));
11306: astFactory.makeASTRoot(currentAST, tmp297_AST);
11307: match(DOLLAR);
11308: if (inputState.guessing == 0) {
11309: tmp297_AST.setType(SCOPE_ESCAPE);
11310: }
11311: {
11312: switch (LA(1)) {
11313: case IDENT: {
11314: AST tmp298_AST = null;
11315: tmp298_AST = astFactory.create(LT(1));
11316: astFactory.addASTChild(currentAST, tmp298_AST);
11317: match(IDENT);
11318: break;
11319: }
11320: case DOLLAR: {
11321: scopeEscapeExpression();
11322: astFactory.addASTChild(currentAST, returnAST);
11323: break;
11324: }
11325: default: {
11326: throw new NoViableAltException(LT(1), getFilename());
11327: }
11328: }
11329: }
11330: scopeEscapeExpression_AST = (AST) currentAST.root;
11331: returnAST = scopeEscapeExpression_AST;
11332: }
11333:
11334: public final void stringConstructorValuePart()
11335: throws RecognitionException, TokenStreamException {
11336:
11337: returnAST = null;
11338: ASTPair currentAST = new ASTPair();
11339: AST stringConstructorValuePart_AST = null;
11340: Token sp = null;
11341: AST sp_AST = null;
11342:
11343: {
11344: switch (LA(1)) {
11345: case STAR: {
11346: sp = LT(1);
11347: sp_AST = astFactory.create(sp);
11348: astFactory.makeASTRoot(currentAST, sp_AST);
11349: match(STAR);
11350: if (inputState.guessing == 0) {
11351: sp_AST.setType(SPREAD_ARG);
11352: }
11353: break;
11354: }
11355: case IDENT:
11356: case LCURLY: {
11357: break;
11358: }
11359: default: {
11360: throw new NoViableAltException(LT(1), getFilename());
11361: }
11362: }
11363: }
11364: {
11365: switch (LA(1)) {
11366: case IDENT: {
11367: identifier();
11368: astFactory.addASTChild(currentAST, returnAST);
11369: break;
11370: }
11371: case LCURLY: {
11372: openOrClosableBlock();
11373: astFactory.addASTChild(currentAST, returnAST);
11374: break;
11375: }
11376: default: {
11377: throw new NoViableAltException(LT(1), getFilename());
11378: }
11379: }
11380: }
11381: stringConstructorValuePart_AST = (AST) currentAST.root;
11382: returnAST = stringConstructorValuePart_AST;
11383: }
11384:
11385: public final void newArrayDeclarator() throws RecognitionException,
11386: TokenStreamException {
11387:
11388: returnAST = null;
11389: ASTPair currentAST = new ASTPair();
11390: AST newArrayDeclarator_AST = null;
11391: Token lb = null;
11392: AST lb_AST = null;
11393:
11394: {
11395: int _cnt465 = 0;
11396: _loop465: do {
11397: if ((LA(1) == LBRACK) && (_tokenSet_110.member(LA(2)))
11398: && (_tokenSet_95.member(LA(3)))) {
11399: lb = LT(1);
11400: lb_AST = astFactory.create(lb);
11401: astFactory.makeASTRoot(currentAST, lb_AST);
11402: match(LBRACK);
11403: if (inputState.guessing == 0) {
11404: lb_AST.setType(ARRAY_DECLARATOR);
11405: }
11406: {
11407: switch (LA(1)) {
11408: case IDENT:
11409: case LBRACK:
11410: case LPAREN:
11411: case LITERAL_super :
11412: case LITERAL_void:
11413: case LITERAL_boolean:
11414: case LITERAL_byte:
11415: case LITERAL_char:
11416: case LITERAL_short:
11417: case LITERAL_int:
11418: case LITERAL_float:
11419: case LITERAL_long:
11420: case LITERAL_double:
11421: case LITERAL_any:
11422: case LCURLY:
11423: case LITERAL_this :
11424: case STRING_LITERAL:
11425: case PLUS:
11426: case MINUS:
11427: case INC:
11428: case DEC:
11429: case BNOT:
11430: case LNOT:
11431: case DOLLAR:
11432: case STRING_CTOR_START:
11433: case LITERAL_new:
11434: case LITERAL_true:
11435: case LITERAL_false:
11436: case LITERAL_null:
11437: case NUM_INT:
11438: case NUM_FLOAT:
11439: case NUM_LONG:
11440: case NUM_DOUBLE:
11441: case NUM_BIG_INT:
11442: case NUM_BIG_DECIMAL: {
11443: expression(0);
11444: astFactory.addASTChild(currentAST,
11445: returnAST);
11446: break;
11447: }
11448: case RBRACK: {
11449: break;
11450: }
11451: default: {
11452: throw new NoViableAltException(LT(1),
11453: getFilename());
11454: }
11455: }
11456: }
11457: match(RBRACK);
11458: } else {
11459: if (_cnt465 >= 1) {
11460: break _loop465;
11461: } else {
11462: throw new NoViableAltException(LT(1),
11463: getFilename());
11464: }
11465: }
11466:
11467: _cnt465++;
11468: } while (true);
11469: }
11470: newArrayDeclarator_AST = (AST) currentAST.root;
11471: returnAST = newArrayDeclarator_AST;
11472: }
11473:
11474: /** A single argument in (...) or [...]. Corresponds to to a method or closure parameter.
11475: * May be labeled. May be modified by the spread operator '*' ('*:' for keywords).
11476: */
11477: public final boolean argument() throws RecognitionException,
11478: TokenStreamException {
11479: boolean hasLabel = false;
11480:
11481: returnAST = null;
11482: ASTPair currentAST = new ASTPair();
11483: AST argument_AST = null;
11484: Token c = null;
11485: AST c_AST = null;
11486: Token sp = null;
11487: AST sp_AST = null;
11488:
11489: {
11490: boolean synPredMatched451 = false;
11491: if (((_tokenSet_111.member(LA(1)))
11492: && (_tokenSet_112.member(LA(2))) && (_tokenSet_86
11493: .member(LA(3))))) {
11494: int _m451 = mark();
11495: synPredMatched451 = true;
11496: inputState.guessing++;
11497: try {
11498: {
11499: argumentLabelStart();
11500: }
11501: } catch (RecognitionException pe) {
11502: synPredMatched451 = false;
11503: }
11504: rewind(_m451);
11505: inputState.guessing--;
11506: }
11507: if (synPredMatched451) {
11508: argumentLabel();
11509: astFactory.addASTChild(currentAST, returnAST);
11510: c = LT(1);
11511: c_AST = astFactory.create(c);
11512: astFactory.makeASTRoot(currentAST, c_AST);
11513: match(COLON);
11514: if (inputState.guessing == 0) {
11515: c_AST.setType(LABELED_ARG);
11516: }
11517: if (inputState.guessing == 0) {
11518: hasLabel = true;
11519: }
11520: } else if ((LA(1) == STAR)) {
11521: sp = LT(1);
11522: sp_AST = astFactory.create(sp);
11523: astFactory.makeASTRoot(currentAST, sp_AST);
11524: match(STAR);
11525: if (inputState.guessing == 0) {
11526: sp_AST.setType(SPREAD_ARG);
11527: }
11528: {
11529: switch (LA(1)) {
11530: case COLON: {
11531: match(COLON);
11532: if (inputState.guessing == 0) {
11533: sp_AST.setType(SPREAD_MAP_ARG);
11534: }
11535: if (inputState.guessing == 0) {
11536: hasLabel = true;
11537: }
11538: break;
11539: }
11540: case FINAL:
11541: case ABSTRACT:
11542: case STRICTFP:
11543: case LITERAL_static:
11544: case LITERAL_def:
11545: case AT:
11546: case IDENT:
11547: case LBRACK:
11548: case LPAREN:
11549: case LITERAL_super :
11550: case LITERAL_void:
11551: case LITERAL_boolean:
11552: case LITERAL_byte:
11553: case LITERAL_char:
11554: case LITERAL_short:
11555: case LITERAL_int:
11556: case LITERAL_float:
11557: case LITERAL_long:
11558: case LITERAL_double:
11559: case LITERAL_any:
11560: case LITERAL_private:
11561: case LITERAL_public:
11562: case LITERAL_protected:
11563: case LITERAL_transient:
11564: case LITERAL_native:
11565: case LITERAL_threadsafe:
11566: case LITERAL_synchronized:
11567: case LITERAL_volatile:
11568: case LCURLY:
11569: case LITERAL_this :
11570: case STRING_LITERAL:
11571: case LITERAL_return:
11572: case LITERAL_break:
11573: case LITERAL_continue:
11574: case LITERAL_throw:
11575: case LITERAL_assert:
11576: case PLUS:
11577: case MINUS:
11578: case INC:
11579: case DEC:
11580: case BNOT:
11581: case LNOT:
11582: case DOLLAR:
11583: case STRING_CTOR_START:
11584: case LITERAL_new:
11585: case LITERAL_true:
11586: case LITERAL_false:
11587: case LITERAL_null:
11588: case NUM_INT:
11589: case NUM_FLOAT:
11590: case NUM_LONG:
11591: case NUM_DOUBLE:
11592: case NUM_BIG_INT:
11593: case NUM_BIG_DECIMAL: {
11594: break;
11595: }
11596: default: {
11597: throw new NoViableAltException(LT(1),
11598: getFilename());
11599: }
11600: }
11601: }
11602: } else if ((_tokenSet_113.member(LA(1)))
11603: && (_tokenSet_68.member(LA(2)))
11604: && (_tokenSet_20.member(LA(3)))) {
11605: } else {
11606: throw new NoViableAltException(LT(1), getFilename());
11607: }
11608:
11609: }
11610: strictContextExpression();
11611: astFactory.addASTChild(currentAST, returnAST);
11612: if (inputState.guessing == 0) {
11613:
11614: require(LA(1) != COLON,
11615: "illegal colon after argument expression",
11616: "a complex label expression before a colon must be parenthesized");
11617:
11618: }
11619: argument_AST = (AST) currentAST.root;
11620: returnAST = argument_AST;
11621: return hasLabel;
11622: }
11623:
11624: /** For lookahead only. Fast approximate parse of an argumentLabel followed by a colon. */
11625: public final void argumentLabelStart() throws RecognitionException,
11626: TokenStreamException {
11627:
11628: returnAST = null;
11629: ASTPair currentAST = new ASTPair();
11630: AST argumentLabelStart_AST = null;
11631:
11632: {
11633: switch (LA(1)) {
11634: case IDENT: {
11635: AST tmp301_AST = null;
11636: tmp301_AST = astFactory.create(LT(1));
11637: match(IDENT);
11638: break;
11639: }
11640: case UNUSED_DO:
11641: case LITERAL_def:
11642: case LITERAL_class:
11643: case LITERAL_void:
11644: case LITERAL_boolean:
11645: case LITERAL_byte:
11646: case LITERAL_char:
11647: case LITERAL_short:
11648: case LITERAL_int:
11649: case LITERAL_float:
11650: case LITERAL_long:
11651: case LITERAL_double:
11652: case LITERAL_any:
11653: case LITERAL_as:
11654: case LITERAL_if:
11655: case LITERAL_else:
11656: case LITERAL_while:
11657: case LITERAL_switch:
11658: case LITERAL_for:
11659: case LITERAL_in:
11660: case LITERAL_try:
11661: case LITERAL_finally:
11662: case LITERAL_catch: {
11663: keywordPropertyNames();
11664: break;
11665: }
11666: case NUM_INT:
11667: case NUM_FLOAT:
11668: case NUM_LONG:
11669: case NUM_DOUBLE:
11670: case NUM_BIG_INT:
11671: case NUM_BIG_DECIMAL: {
11672: constantNumber();
11673: break;
11674: }
11675: case STRING_LITERAL: {
11676: AST tmp302_AST = null;
11677: tmp302_AST = astFactory.create(LT(1));
11678: match(STRING_LITERAL);
11679: break;
11680: }
11681: case LBRACK:
11682: case LPAREN:
11683: case LCURLY:
11684: case STRING_CTOR_START: {
11685: balancedBrackets();
11686: break;
11687: }
11688: default: {
11689: throw new NoViableAltException(LT(1), getFilename());
11690: }
11691: }
11692: }
11693: AST tmp303_AST = null;
11694: tmp303_AST = astFactory.create(LT(1));
11695: match(COLON);
11696: returnAST = argumentLabelStart_AST;
11697: }
11698:
11699: /** A label for an argument is of the form a:b, 'a':b, "a":b, (a):b, etc..
11700: * The labels in (a:b), ('a':b), and ("a":b) are in all ways equivalent,
11701: * except that the quotes allow more spellings.
11702: * Equivalent dynamically computed labels are (('a'):b) and ("${'a'}":b)
11703: * but not ((a):b) or "$a":b, since the latter cases evaluate (a) as a normal identifier.
11704: * Bottom line: If you want a truly variable label, use parens and say ((a):b).
11705: */
11706: public final void argumentLabel() throws RecognitionException,
11707: TokenStreamException {
11708:
11709: returnAST = null;
11710: ASTPair currentAST = new ASTPair();
11711: AST argumentLabel_AST = null;
11712: Token id = null;
11713: AST id_AST = null;
11714: AST kw_AST = null;
11715:
11716: boolean synPredMatched455 = false;
11717: if (((LA(1) == IDENT) && (LA(2) == COLON) && (_tokenSet_113
11718: .member(LA(3))))) {
11719: int _m455 = mark();
11720: synPredMatched455 = true;
11721: inputState.guessing++;
11722: try {
11723: {
11724: match(IDENT);
11725: }
11726: } catch (RecognitionException pe) {
11727: synPredMatched455 = false;
11728: }
11729: rewind(_m455);
11730: inputState.guessing--;
11731: }
11732: if (synPredMatched455) {
11733: id = LT(1);
11734: id_AST = astFactory.create(id);
11735: astFactory.addASTChild(currentAST, id_AST);
11736: match(IDENT);
11737: if (inputState.guessing == 0) {
11738: id_AST.setType(STRING_LITERAL);
11739: }
11740: argumentLabel_AST = (AST) currentAST.root;
11741: } else {
11742: boolean synPredMatched457 = false;
11743: if (((_tokenSet_114.member(LA(1))) && (LA(2) == COLON) && (_tokenSet_113
11744: .member(LA(3))))) {
11745: int _m457 = mark();
11746: synPredMatched457 = true;
11747: inputState.guessing++;
11748: try {
11749: {
11750: keywordPropertyNames();
11751: }
11752: } catch (RecognitionException pe) {
11753: synPredMatched457 = false;
11754: }
11755: rewind(_m457);
11756: inputState.guessing--;
11757: }
11758: if (synPredMatched457) {
11759: keywordPropertyNames();
11760: kw_AST = (AST) returnAST;
11761: astFactory.addASTChild(currentAST, returnAST);
11762: if (inputState.guessing == 0) {
11763: kw_AST.setType(STRING_LITERAL);
11764: }
11765: argumentLabel_AST = (AST) currentAST.root;
11766: } else if ((_tokenSet_106.member(LA(1)))
11767: && (_tokenSet_112.member(LA(2)))
11768: && (_tokenSet_86.member(LA(3)))) {
11769: primaryExpression();
11770: astFactory.addASTChild(currentAST, returnAST);
11771: argumentLabel_AST = (AST) currentAST.root;
11772: } else {
11773: throw new NoViableAltException(LT(1), getFilename());
11774: }
11775: }
11776: returnAST = argumentLabel_AST;
11777: }
11778:
11779: /** Numeric constant. */
11780: public final void constantNumber() throws RecognitionException,
11781: TokenStreamException {
11782:
11783: returnAST = null;
11784: ASTPair currentAST = new ASTPair();
11785: AST constantNumber_AST = null;
11786:
11787: switch (LA(1)) {
11788: case NUM_INT: {
11789: AST tmp304_AST = null;
11790: tmp304_AST = astFactory.create(LT(1));
11791: astFactory.addASTChild(currentAST, tmp304_AST);
11792: match(NUM_INT);
11793: constantNumber_AST = (AST) currentAST.root;
11794: break;
11795: }
11796: case NUM_FLOAT: {
11797: AST tmp305_AST = null;
11798: tmp305_AST = astFactory.create(LT(1));
11799: astFactory.addASTChild(currentAST, tmp305_AST);
11800: match(NUM_FLOAT);
11801: constantNumber_AST = (AST) currentAST.root;
11802: break;
11803: }
11804: case NUM_LONG: {
11805: AST tmp306_AST = null;
11806: tmp306_AST = astFactory.create(LT(1));
11807: astFactory.addASTChild(currentAST, tmp306_AST);
11808: match(NUM_LONG);
11809: constantNumber_AST = (AST) currentAST.root;
11810: break;
11811: }
11812: case NUM_DOUBLE: {
11813: AST tmp307_AST = null;
11814: tmp307_AST = astFactory.create(LT(1));
11815: astFactory.addASTChild(currentAST, tmp307_AST);
11816: match(NUM_DOUBLE);
11817: constantNumber_AST = (AST) currentAST.root;
11818: break;
11819: }
11820: case NUM_BIG_INT: {
11821: AST tmp308_AST = null;
11822: tmp308_AST = astFactory.create(LT(1));
11823: astFactory.addASTChild(currentAST, tmp308_AST);
11824: match(NUM_BIG_INT);
11825: constantNumber_AST = (AST) currentAST.root;
11826: break;
11827: }
11828: case NUM_BIG_DECIMAL: {
11829: AST tmp309_AST = null;
11830: tmp309_AST = astFactory.create(LT(1));
11831: astFactory.addASTChild(currentAST, tmp309_AST);
11832: match(NUM_BIG_DECIMAL);
11833: constantNumber_AST = (AST) currentAST.root;
11834: break;
11835: }
11836: default: {
11837: throw new NoViableAltException(LT(1), getFilename());
11838: }
11839: }
11840: returnAST = constantNumber_AST;
11841: }
11842:
11843: /** Fast lookahead across balanced brackets of all sorts. */
11844: public final void balancedBrackets() throws RecognitionException,
11845: TokenStreamException {
11846:
11847: returnAST = null;
11848: ASTPair currentAST = new ASTPair();
11849: AST balancedBrackets_AST = null;
11850:
11851: switch (LA(1)) {
11852: case LPAREN: {
11853: AST tmp310_AST = null;
11854: tmp310_AST = astFactory.create(LT(1));
11855: match(LPAREN);
11856: balancedTokens();
11857: AST tmp311_AST = null;
11858: tmp311_AST = astFactory.create(LT(1));
11859: match(RPAREN);
11860: break;
11861: }
11862: case LBRACK: {
11863: AST tmp312_AST = null;
11864: tmp312_AST = astFactory.create(LT(1));
11865: match(LBRACK);
11866: balancedTokens();
11867: AST tmp313_AST = null;
11868: tmp313_AST = astFactory.create(LT(1));
11869: match(RBRACK);
11870: break;
11871: }
11872: case LCURLY: {
11873: AST tmp314_AST = null;
11874: tmp314_AST = astFactory.create(LT(1));
11875: match(LCURLY);
11876: balancedTokens();
11877: AST tmp315_AST = null;
11878: tmp315_AST = astFactory.create(LT(1));
11879: match(RCURLY);
11880: break;
11881: }
11882: case STRING_CTOR_START: {
11883: AST tmp316_AST = null;
11884: tmp316_AST = astFactory.create(LT(1));
11885: match(STRING_CTOR_START);
11886: balancedTokens();
11887: AST tmp317_AST = null;
11888: tmp317_AST = astFactory.create(LT(1));
11889: match(STRING_CTOR_END);
11890: break;
11891: }
11892: default: {
11893: throw new NoViableAltException(LT(1), getFilename());
11894: }
11895: }
11896: returnAST = balancedBrackets_AST;
11897: }
11898:
11899: public static final String[] _tokenNames = { "<0>", "EOF", "<2>",
11900: "NULL_TREE_LOOKAHEAD", "BLOCK", "MODIFIERS", "OBJBLOCK",
11901: "SLIST", "METHOD_DEF", "VARIABLE_DEF", "INSTANCE_INIT",
11902: "STATIC_INIT", "TYPE", "CLASS_DEF", "INTERFACE_DEF",
11903: "PACKAGE_DEF", "ARRAY_DECLARATOR", "EXTENDS_CLAUSE",
11904: "IMPLEMENTS_CLAUSE", "PARAMETERS", "PARAMETER_DEF",
11905: "LABELED_STAT", "TYPECAST", "INDEX_OP", "POST_INC",
11906: "POST_DEC", "METHOD_CALL", "EXPR", "IMPORT", "UNARY_MINUS",
11907: "UNARY_PLUS", "CASE_GROUP", "ELIST", "FOR_INIT",
11908: "FOR_CONDITION", "FOR_ITERATOR", "EMPTY_STAT", "\"final\"",
11909: "\"abstract\"", "\"goto\"", "\"const\"", "\"do\"",
11910: "\"strictfp\"", "SUPER_CTOR_CALL", "CTOR_CALL",
11911: "CTOR_IDENT", "VARIABLE_PARAMETER_DEF",
11912: "STRING_CONSTRUCTOR", "STRING_CTOR_MIDDLE",
11913: "CLOSABLE_BLOCK", "IMPLICIT_PARAMETERS", "SELECT_SLOT",
11914: "DYNAMIC_MEMBER", "LABELED_ARG", "SPREAD_ARG",
11915: "SPREAD_MAP_ARG", "SCOPE_ESCAPE", "LIST_CONSTRUCTOR",
11916: "MAP_CONSTRUCTOR", "FOR_IN_ITERABLE", "STATIC_IMPORT",
11917: "ENUM_DEF", "ENUM_CONSTANT_DEF", "FOR_EACH_CLAUSE",
11918: "ANNOTATION_DEF", "ANNOTATIONS", "ANNOTATION",
11919: "ANNOTATION_MEMBER_VALUE_PAIR", "ANNOTATION_FIELD_DEF",
11920: "ANNOTATION_ARRAY_INIT", "TYPE_ARGUMENTS", "TYPE_ARGUMENT",
11921: "TYPE_PARAMETERS", "TYPE_PARAMETER", "WILDCARD_TYPE",
11922: "TYPE_UPPER_BOUNDS", "TYPE_LOWER_BOUNDS",
11923: "a script header", "\"package\"", "\"import\"",
11924: "\"static\"", "\"def\"", "'@'", "an identifier", "'['",
11925: "']'", "'.'", "'('", "\"class\"", "\"interface\"",
11926: "\"enum\"", "'?'", "\"extends\"", "\"super\"", "'<'",
11927: "','", "'>'", "'>>'", "'>>>'", "\"void\"", "\"boolean\"",
11928: "\"byte\"", "\"char\"", "\"short\"", "\"int\"",
11929: "\"float\"", "\"long\"", "\"double\"", "\"any\"", "'*'",
11930: "\"as\"", "\"private\"", "\"public\"", "\"protected\"",
11931: "\"transient\"", "\"native\"", "\"threadsafe\"",
11932: "\"synchronized\"", "\"volatile\"", "')'", "'='", "'&'",
11933: "'{'", "'}'", "';'",
11934: "some newlines, whitespace or comments", "\"default\"",
11935: "\"throws\"", "\"implements\"", "\"this\"",
11936: "a string literal", "'...'", "'->'", "':'", "\"if\"",
11937: "\"else\"", "\"while\"", "\"with\"", "\"switch\"",
11938: "\"for\"", "\"in\"", "\"return\"", "\"break\"",
11939: "\"continue\"", "\"throw\"", "\"assert\"", "'+'", "'-'",
11940: "\"case\"", "\"try\"", "\"finally\"", "\"catch\"", "'*.'",
11941: "'?.'", "'.&'", "'+='", "'-='", "'*='", "'/='", "'%='",
11942: "'>>='", "'>>>='", "'<<='", "'&='", "'^='", "'|='",
11943: "'**='", "'||'", "'&&'", "'|'", "'^'", "'=~'", "'==~'",
11944: "'!='", "'=='", "'<=>'", "'<='", "'>='", "\"instanceof\"",
11945: "'<<'", "'..'", "'..<'", "'++'", "'/'", "'%'", "'--'",
11946: "'**'", "'~'", "'!'", "'$'", "STRING_CTOR_START",
11947: "a string literal end", "\"new\"", "\"true\"", "\"false\"",
11948: "\"null\"", "a numeric literal", "NUM_FLOAT", "NUM_LONG",
11949: "NUM_DOUBLE", "NUM_BIG_INT", "NUM_BIG_DECIMAL",
11950: "whitespace", "a newline", "a single line comment",
11951: "a comment", "a string character",
11952: "a regular expression literal",
11953: "a regular expression literal end",
11954: "a regular expression character", "an escape sequence",
11955: "a newline inside a string", "a hexadecimal digit",
11956: "a character", "a letter", "a digit", "an exponent",
11957: "a float or double suffix", "a big decimal suffix" };
11958:
11959: protected void buildTokenTypeASTClassMap() {
11960: tokenTypeToASTClassMap = null;
11961: };
11962:
11963: private static final long[] mk_tokenSet_0() {
11964: long[] data = { 2L, 3458764513833402368L, 0L, 0L };
11965: return data;
11966: }
11967:
11968: public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
11969:
11970: private static final long[] mk_tokenSet_1() {
11971: long[] data = new long[8];
11972: data[0] = 4810363371522L;
11973: data[1] = 3782953284552065024L;
11974: data[2] = 8809040871139831622L;
11975: data[3] = 1023L;
11976: return data;
11977: }
11978:
11979: public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
11980:
11981: private static final long[] mk_tokenSet_2() {
11982: long[] data = new long[8];
11983: data[0] = 7009386627074L;
11984: data[1] = 4575657221139955712L;
11985: data[2] = 9223372036853727230L;
11986: data[3] = 1023L;
11987: return data;
11988: }
11989:
11990: public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
11991:
11992: private static final long[] mk_tokenSet_3() {
11993: long[] data = new long[8];
11994: data[0] = 288484363337730L;
11995: data[1] = 4611686018427355136L;
11996: data[2] = -1048577L;
11997: data[3] = 1023L;
11998: return data;
11999: }
12000:
12001: public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
12002:
12003: private static final long[] mk_tokenSet_4() {
12004: long[] data = new long[8];
12005: data[0] = 7009386627074L;
12006: data[1] = -16384L;
12007: data[2] = 8809322346113400831L;
12008: data[3] = 1023L;
12009: return data;
12010: }
12011:
12012: public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
12013:
12014: private static final long[] mk_tokenSet_5() {
12015: long[] data = new long[8];
12016: data[0] = 288484363337730L;
12017: data[1] = -16384L;
12018: data[2] = -1L;
12019: data[3] = 1023L;
12020: return data;
12021: }
12022:
12023: public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
12024:
12025: private static final long[] mk_tokenSet_6() {
12026: long[] data = { 0L, 3458764513820540928L, 128L, 0L, 0L, 0L };
12027: return data;
12028: }
12029:
12030: public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
12031:
12032: private static final long[] mk_tokenSet_7() {
12033: long[] data = new long[8];
12034: data[0] = 4810363371520L;
12035: data[1] = 3782953284552065024L;
12036: data[2] = 8809040871139831750L;
12037: data[3] = 1023L;
12038: return data;
12039: }
12040:
12041: public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
12042:
12043: private static final long[] mk_tokenSet_8() {
12044: long[] data = new long[8];
12045: data[0] = 7009386627074L;
12046: data[1] = 9187343239567343616L;
12047: data[2] = 9223372036854775806L;
12048: data[3] = 1023L;
12049: return data;
12050: }
12051:
12052: public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
12053:
12054: private static final long[] mk_tokenSet_9() {
12055: long[] data = { 2L, 8646911284551352320L, 1048704L, 0L, 0L, 0L };
12056: return data;
12057: }
12058:
12059: public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
12060:
12061: private static final long[] mk_tokenSet_10() {
12062: long[] data = new long[8];
12063: data[0] = 286285340082178L;
12064: data[1] = 9223372036586307584L;
12065: data[2] = -10L;
12066: data[3] = 1023L;
12067: return data;
12068: }
12069:
12070: public static final BitSet _tokenSet_10 = new BitSet(
12071: mk_tokenSet_10());
12072:
12073: private static final long[] mk_tokenSet_11() {
12074: long[] data = new long[8];
12075: data[0] = 288484363337730L;
12076: data[1] = -268451840L;
12077: data[2] = -2L;
12078: data[3] = 1023L;
12079: return data;
12080: }
12081:
12082: public static final BitSet _tokenSet_11 = new BitSet(
12083: mk_tokenSet_11());
12084:
12085: private static final long[] mk_tokenSet_12() {
12086: long[] data = { 4810363371520L, 35923209543942144L, 0L, 0L };
12087: return data;
12088: }
12089:
12090: public static final BitSet _tokenSet_12 = new BitSet(
12091: mk_tokenSet_12());
12092:
12093: private static final long[] mk_tokenSet_13() {
12094: long[] data = { 4810363371520L, 2341766219836620800L, 4L, 0L,
12095: 0L, 0L };
12096: return data;
12097: }
12098:
12099: public static final BitSet _tokenSet_13 = new BitSet(
12100: mk_tokenSet_13());
12101:
12102: private static final long[] mk_tokenSet_14() {
12103: long[] data = { 4810363371522L, 8754892091504394240L, 1048708L,
12104: 0L, 0L, 0L };
12105: return data;
12106: }
12107:
12108: public static final BitSet _tokenSet_14 = new BitSet(
12109: mk_tokenSet_14());
12110:
12111: private static final long[] mk_tokenSet_15() {
12112: long[] data = new long[8];
12113: data[0] = 4810363371520L;
12114: data[1] = 2630031779945218048L;
12115: data[2] = 8809040871139831622L;
12116: data[3] = 1023L;
12117: return data;
12118: }
12119:
12120: public static final BitSet _tokenSet_15 = new BitSet(
12121: mk_tokenSet_15());
12122:
12123: private static final long[] mk_tokenSet_16() {
12124: long[] data = new long[8];
12125: data[0] = 4810363371520L;
12126: data[1] = 4359414036855488512L;
12127: data[2] = 8809040871139831646L;
12128: data[3] = 1023L;
12129: return data;
12130: }
12131:
12132: public static final BitSet _tokenSet_16 = new BitSet(
12133: mk_tokenSet_16());
12134:
12135: private static final long[] mk_tokenSet_17() {
12136: long[] data = new long[8];
12137: data[0] = 4810363371520L;
12138: data[1] = 324188770731524096L;
12139: data[2] = 8809040871139831622L;
12140: data[3] = 1023L;
12141: return data;
12142: }
12143:
12144: public static final BitSet _tokenSet_17 = new BitSet(
12145: mk_tokenSet_17());
12146:
12147: private static final long[] mk_tokenSet_18() {
12148: long[] data = new long[8];
12149: data[0] = 288484363337730L;
12150: data[1] = 9223372036854743040L;
12151: data[2] = -1L;
12152: data[3] = 1023L;
12153: return data;
12154: }
12155:
12156: public static final BitSet _tokenSet_18 = new BitSet(
12157: mk_tokenSet_18());
12158:
12159: private static final long[] mk_tokenSet_19() {
12160: long[] data = new long[8];
12161: data[1] = 288265526710894592L;
12162: data[2] = 8809040871137476614L;
12163: data[3] = 1023L;
12164: return data;
12165: }
12166:
12167: public static final BitSet _tokenSet_19 = new BitSet(
12168: mk_tokenSet_19());
12169:
12170: private static final long[] mk_tokenSet_20() {
12171: long[] data = new long[8];
12172: data[0] = 288484363337730L;
12173: data[1] = 9223372036586307584L;
12174: data[2] = -2L;
12175: data[3] = 1023L;
12176: return data;
12177: }
12178:
12179: public static final BitSet _tokenSet_20 = new BitSet(
12180: mk_tokenSet_20());
12181:
12182: private static final long[] mk_tokenSet_21() {
12183: long[] data = { 4810363371520L, 35888059648507904L, 0L, 0L };
12184: return data;
12185: }
12186:
12187: public static final BitSet _tokenSet_21 = new BitSet(
12188: mk_tokenSet_21());
12189:
12190: private static final long[] mk_tokenSet_22() {
12191: long[] data = { 4810363371520L, 2341731068862726144L, 0L, 0L };
12192: return data;
12193: }
12194:
12195: public static final BitSet _tokenSet_22 = new BitSet(
12196: mk_tokenSet_22());
12197:
12198: private static final long[] mk_tokenSet_23() {
12199: long[] data = { 4810363371520L, 2629961446369198080L, 1L, 0L,
12200: 0L, 0L };
12201: return data;
12202: }
12203:
12204: public static final BitSet _tokenSet_23 = new BitSet(
12205: mk_tokenSet_23());
12206:
12207: private static final long[] mk_tokenSet_24() {
12208: long[] data = new long[8];
12209: data[0] = 4810363371522L;
12210: data[1] = 8971100056356618240L;
12211: data[2] = 8809040871140880326L;
12212: data[3] = 1023L;
12213: return data;
12214: }
12215:
12216: public static final BitSet _tokenSet_24 = new BitSet(
12217: mk_tokenSet_24());
12218:
12219: private static final long[] mk_tokenSet_25() {
12220: long[] data = { 2L, 8646981653300248576L, 1048704L, 0L, 0L, 0L };
12221: return data;
12222: }
12223:
12224: public static final BitSet _tokenSet_25 = new BitSet(
12225: mk_tokenSet_25());
12226:
12227: private static final long[] mk_tokenSet_26() {
12228: long[] data = { 0L, 35150012874752L, 0L, 0L };
12229: return data;
12230: }
12231:
12232: public static final BitSet _tokenSet_26 = new BitSet(
12233: mk_tokenSet_26());
12234:
12235: private static final long[] mk_tokenSet_27() {
12236: long[] data = { 0L, 1079508992L, 4L, 0L, 0L, 0L };
12237: return data;
12238: }
12239:
12240: public static final BitSet _tokenSet_27 = new BitSet(
12241: mk_tokenSet_27());
12242:
12243: private static final long[] mk_tokenSet_28() {
12244: long[] data = { 2L, 8718968880745152512L, 1048704L, 0L, 0L, 0L };
12245: return data;
12246: }
12247:
12248: public static final BitSet _tokenSet_28 = new BitSet(
12249: mk_tokenSet_28());
12250:
12251: private static final long[] mk_tokenSet_29() {
12252: long[] data = { 2L, 8718968880736763904L, 1048704L, 0L, 0L, 0L };
12253: return data;
12254: }
12255:
12256: public static final BitSet _tokenSet_29 = new BitSet(
12257: mk_tokenSet_29());
12258:
12259: private static final long[] mk_tokenSet_30() {
12260: long[] data = { 0L, -6917529027640557568L, 0L, 0L };
12261: return data;
12262: }
12263:
12264: public static final BitSet _tokenSet_30 = new BitSet(
12265: mk_tokenSet_30());
12266:
12267: private static final long[] mk_tokenSet_31() {
12268: long[] data = { 2L, 8935141662855266304L, 1048704L, 0L, 0L, 0L };
12269: return data;
12270: }
12271:
12272: public static final BitSet _tokenSet_31 = new BitSet(
12273: mk_tokenSet_31());
12274:
12275: private static final long[] mk_tokenSet_32() {
12276: long[] data = { 2L, 8935141660703064064L, 1048704L, 0L, 0L, 0L };
12277: return data;
12278: }
12279:
12280: public static final BitSet _tokenSet_32 = new BitSet(
12281: mk_tokenSet_32());
12282:
12283: private static final long[] mk_tokenSet_33() {
12284: long[] data = new long[8];
12285: data[0] = 4810363371520L;
12286: data[1] = 4359414036855488512L;
12287: data[2] = 8809040871139831622L;
12288: data[3] = 1023L;
12289: return data;
12290: }
12291:
12292: public static final BitSet _tokenSet_33 = new BitSet(
12293: mk_tokenSet_33());
12294:
12295: private static final long[] mk_tokenSet_34() {
12296: long[] data = { 0L, 1079508992L, 0L, 0L };
12297: return data;
12298: }
12299:
12300: public static final BitSet _tokenSet_34 = new BitSet(
12301: mk_tokenSet_34());
12302:
12303: private static final long[] mk_tokenSet_35() {
12304: long[] data = { 0L, 1261007897813319680L, 4128L, 0L, 0L, 0L };
12305: return data;
12306: }
12307:
12308: public static final BitSet _tokenSet_35 = new BitSet(
12309: mk_tokenSet_35());
12310:
12311: private static final long[] mk_tokenSet_36() {
12312: long[] data = { 0L, 288230376161148928L, 4611686018427387904L,
12313: 0L, 0L, 0L };
12314: return data;
12315: }
12316:
12317: public static final BitSet _tokenSet_36 = new BitSet(
12318: mk_tokenSet_36());
12319:
12320: private static final long[] mk_tokenSet_37() {
12321: long[] data = new long[12];
12322: data[0] = -16L;
12323: data[1] = -900719925485633537L;
12324: data[2] = 4611686018427387903L;
12325: data[3] = 134217727L;
12326: return data;
12327: }
12328:
12329: public static final BitSet _tokenSet_37 = new BitSet(
12330: mk_tokenSet_37());
12331:
12332: private static final long[] mk_tokenSet_38() {
12333: long[] data = { 4810363371520L, 35888059531067392L, 0L, 0L };
12334: return data;
12335: }
12336:
12337: public static final BitSet _tokenSet_38 = new BitSet(
12338: mk_tokenSet_38());
12339:
12340: private static final long[] mk_tokenSet_39() {
12341: long[] data = { 4810363371520L, 2341766219948818432L, 0L, 0L };
12342: return data;
12343: }
12344:
12345: public static final BitSet _tokenSet_39 = new BitSet(
12346: mk_tokenSet_39());
12347:
12348: private static final long[] mk_tokenSet_40() {
12349: long[] data = { 4810363371522L, 2341766219962449920L, 4L, 0L,
12350: 0L, 0L };
12351: return data;
12352: }
12353:
12354: public static final BitSet _tokenSet_40 = new BitSet(
12355: mk_tokenSet_40());
12356:
12357: private static final long[] mk_tokenSet_41() {
12358: long[] data = { 0L, 35151204319232L, 0L, 0L };
12359: return data;
12360: }
12361:
12362: public static final BitSet _tokenSet_41 = new BitSet(
12363: mk_tokenSet_41());
12364:
12365: private static final long[] mk_tokenSet_42() {
12366: long[] data = { 2L, 2305843010335145984L, 4L, 0L, 0L, 0L };
12367: return data;
12368: }
12369:
12370: public static final BitSet _tokenSet_42 = new BitSet(
12371: mk_tokenSet_42());
12372:
12373: private static final long[] mk_tokenSet_43() {
12374: long[] data = { 137438953474L, 4431577217044971520L, 9L, 0L,
12375: 0L, 0L };
12376: return data;
12377: }
12378:
12379: public static final BitSet _tokenSet_43 = new BitSet(
12380: mk_tokenSet_43());
12381:
12382: private static final long[] mk_tokenSet_44() {
12383: long[] data = new long[8];
12384: data[0] = 2199023255554L;
12385: data[1] = 9187448792851283968L;
12386: data[2] = 8809322345995705855L;
12387: data[3] = 1023L;
12388: return data;
12389: }
12390:
12391: public static final BitSet _tokenSet_44 = new BitSet(
12392: mk_tokenSet_44());
12393:
12394: private static final long[] mk_tokenSet_45() {
12395: long[] data = new long[8];
12396: data[0] = 2199023255554L;
12397: data[1] = 9187448791777542144L;
12398: data[2] = 8809322345995705855L;
12399: data[3] = 1023L;
12400: return data;
12401: }
12402:
12403: public static final BitSet _tokenSet_45 = new BitSet(
12404: mk_tokenSet_45());
12405:
12406: private static final long[] mk_tokenSet_46() {
12407: long[] data = { 0L, 2305878159360786432L, 0L, 0L };
12408: return data;
12409: }
12410:
12411: public static final BitSet _tokenSet_46 = new BitSet(
12412: mk_tokenSet_46());
12413:
12414: private static final long[] mk_tokenSet_47() {
12415: long[] data = { 4810363371520L, 35888059530674176L, 0L, 0L };
12416: return data;
12417: }
12418:
12419: public static final BitSet _tokenSet_47 = new BitSet(
12420: mk_tokenSet_47());
12421:
12422: private static final long[] mk_tokenSet_48() {
12423: long[] data = { 4810363371520L, 2341766219961401344L, 4L, 0L,
12424: 0L, 0L };
12425: return data;
12426: }
12427:
12428: public static final BitSet _tokenSet_48 = new BitSet(
12429: mk_tokenSet_48());
12430:
12431: private static final long[] mk_tokenSet_49() {
12432: long[] data = new long[8];
12433: data[1] = 288265526711156736L;
12434: data[2] = 8809040871137476614L;
12435: data[3] = 1023L;
12436: return data;
12437: }
12438:
12439: public static final BitSet _tokenSet_49 = new BitSet(
12440: mk_tokenSet_49());
12441:
12442: private static final long[] mk_tokenSet_50() {
12443: long[] data = new long[8];
12444: data[0] = 7009386627072L;
12445: data[1] = 4539628424120991744L;
12446: data[2] = 9223371487232131070L;
12447: data[3] = 1023L;
12448: return data;
12449: }
12450:
12451: public static final BitSet _tokenSet_50 = new BitSet(
12452: mk_tokenSet_50());
12453:
12454: private static final long[] mk_tokenSet_51() {
12455: long[] data = { 0L, 4323455644432072704L, 0L, 0L };
12456: return data;
12457: }
12458:
12459: public static final BitSet _tokenSet_51 = new BitSet(
12460: mk_tokenSet_51());
12461:
12462: private static final long[] mk_tokenSet_52() {
12463: long[] data = new long[8];
12464: data[0] = 7009386627074L;
12465: data[1] = 9007199224271405056L;
12466: data[2] = 8809040871153466822L;
12467: data[3] = 1023L;
12468: return data;
12469: }
12470:
12471: public static final BitSet _tokenSet_52 = new BitSet(
12472: mk_tokenSet_52());
12473:
12474: private static final long[] mk_tokenSet_53() {
12475: long[] data = { 4810363371520L, 4359378851937058816L, 0L, 0L };
12476: return data;
12477: }
12478:
12479: public static final BitSet _tokenSet_53 = new BitSet(
12480: mk_tokenSet_53());
12481:
12482: private static final long[] mk_tokenSet_54() {
12483: long[] data = new long[8];
12484: data[0] = 4810363371522L;
12485: data[1] = 8971100056360812544L;
12486: data[2] = 8809040871140880326L;
12487: data[3] = 1023L;
12488: return data;
12489: }
12490:
12491: public static final BitSet _tokenSet_54 = new BitSet(
12492: mk_tokenSet_54());
12493:
12494: private static final long[] mk_tokenSet_55() {
12495: long[] data = { 0L, 2738223757012762624L, 1L, 0L, 0L, 0L };
12496: return data;
12497: }
12498:
12499: public static final BitSet _tokenSet_55 = new BitSet(
12500: mk_tokenSet_55());
12501:
12502: private static final long[] mk_tokenSet_56() {
12503: long[] data = { 0L, 2594108567858970624L, 1L, 0L, 0L, 0L };
12504: return data;
12505: }
12506:
12507: public static final BitSet _tokenSet_56 = new BitSet(
12508: mk_tokenSet_56());
12509:
12510: private static final long[] mk_tokenSet_57() {
12511: long[] data = { 4810363371520L, 4359378883349250048L, 5L, 0L,
12512: 0L, 0L };
12513: return data;
12514: }
12515:
12516: public static final BitSet _tokenSet_57 = new BitSet(
12517: mk_tokenSet_57());
12518:
12519: private static final long[] mk_tokenSet_58() {
12520: long[] data = new long[8];
12521: data[0] = 4810363371522L;
12522: data[1] = 9043157683015745536L;
12523: data[2] = 8809040871140880327L;
12524: data[3] = 1023L;
12525: return data;
12526: }
12527:
12528: public static final BitSet _tokenSet_58 = new BitSet(
12529: mk_tokenSet_58());
12530:
12531: private static final long[] mk_tokenSet_59() {
12532: long[] data = { 4810363371520L, 35888059531591680L, 0L, 0L };
12533: return data;
12534: }
12535:
12536: public static final BitSet _tokenSet_59 = new BitSet(
12537: mk_tokenSet_59());
12538:
12539: private static final long[] mk_tokenSet_60() {
12540: long[] data = { 4810363371520L, 2341731068753674240L, 0L, 0L };
12541: return data;
12542: }
12543:
12544: public static final BitSet _tokenSet_60 = new BitSet(
12545: mk_tokenSet_60());
12546:
12547: private static final long[] mk_tokenSet_61() {
12548: long[] data = { 4810363371520L, 2377795015789182976L, 8L, 0L,
12549: 0L, 0L };
12550: return data;
12551: }
12552:
12553: public static final BitSet _tokenSet_61 = new BitSet(
12554: mk_tokenSet_61());
12555:
12556: private static final long[] mk_tokenSet_62() {
12557: long[] data = { 4810363371520L, 4143206073077006336L, 4L, 0L,
12558: 0L, 0L };
12559: return data;
12560: }
12561:
12562: public static final BitSet _tokenSet_62 = new BitSet(
12563: mk_tokenSet_62());
12564:
12565: private static final long[] mk_tokenSet_63() {
12566: long[] data = { 0L, 4107282862317764608L, 0L, 0L };
12567: return data;
12568: }
12569:
12570: public static final BitSet _tokenSet_63 = new BitSet(
12571: mk_tokenSet_63());
12572:
12573: private static final long[] mk_tokenSet_64() {
12574: long[] data = new long[8];
12575: data[0] = 4810363371522L;
12576: data[1] = 9007093667929718784L;
12577: data[2] = 8809040871138525326L;
12578: data[3] = 1023L;
12579: return data;
12580: }
12581:
12582: public static final BitSet _tokenSet_64 = new BitSet(
12583: mk_tokenSet_64());
12584:
12585: private static final long[] mk_tokenSet_65() {
12586: long[] data = { 0L, 2305843009214480384L, 0L, 0L };
12587: return data;
12588: }
12589:
12590: public static final BitSet _tokenSet_65 = new BitSet(
12591: mk_tokenSet_65());
12592:
12593: private static final long[] mk_tokenSet_66() {
12594: long[] data = { 0L, 4323455644432334848L, 0L, 0L };
12595: return data;
12596: }
12597:
12598: public static final BitSet _tokenSet_66 = new BitSet(
12599: mk_tokenSet_66());
12600:
12601: private static final long[] mk_tokenSet_67() {
12602: long[] data = new long[8];
12603: data[0] = 7009386627072L;
12604: data[1] = 324259139375005696L;
12605: data[2] = 8809040871152418246L;
12606: data[3] = 1023L;
12607: return data;
12608: }
12609:
12610: public static final BitSet _tokenSet_67 = new BitSet(
12611: mk_tokenSet_67());
12612:
12613: private static final long[] mk_tokenSet_68() {
12614: long[] data = new long[8];
12615: data[0] = 7009386627072L;
12616: data[1] = 4611686018158919680L;
12617: data[2] = 9223372036853727230L;
12618: data[3] = 1023L;
12619: return data;
12620: }
12621:
12622: public static final BitSet _tokenSet_68 = new BitSet(
12623: mk_tokenSet_68());
12624:
12625: private static final long[] mk_tokenSet_69() {
12626: long[] data = { 137438953472L, 36063947032231936L, 8L, 0L, 0L,
12627: 0L };
12628: return data;
12629: }
12630:
12631: public static final BitSet _tokenSet_69 = new BitSet(
12632: mk_tokenSet_69());
12633:
12634: private static final long[] mk_tokenSet_70() {
12635: long[] data = { 0L, 4323455644427878400L, 0L, 0L };
12636: return data;
12637: }
12638:
12639: public static final BitSet _tokenSet_70 = new BitSet(
12640: mk_tokenSet_70());
12641:
12642: private static final long[] mk_tokenSet_71() {
12643: long[] data = new long[8];
12644: data[0] = 4810363371520L;
12645: data[1] = 4359414040076713984L;
12646: data[2] = 8809040871139831622L;
12647: data[3] = 1023L;
12648: return data;
12649: }
12650:
12651: public static final BitSet _tokenSet_71 = new BitSet(
12652: mk_tokenSet_71());
12653:
12654: private static final long[] mk_tokenSet_72() {
12655: long[] data = new long[8];
12656: data[0] = 4810363371520L;
12657: data[1] = 4395407652723556352L;
12658: data[2] = 8809040871137476622L;
12659: data[3] = 1023L;
12660: return data;
12661: }
12662:
12663: public static final BitSet _tokenSet_72 = new BitSet(
12664: mk_tokenSet_72());
12665:
12666: private static final long[] mk_tokenSet_73() {
12667: long[] data = { 0L, 2594073387517607936L, 0L, 0L };
12668: return data;
12669: }
12670:
12671: public static final BitSet _tokenSet_73 = new BitSet(
12672: mk_tokenSet_73());
12673:
12674: private static final long[] mk_tokenSet_74() {
12675: long[] data = new long[8];
12676: data[0] = 4810363371520L;
12677: data[1] = 4359414037929230336L;
12678: data[2] = 8809040871139831622L;
12679: data[3] = 1023L;
12680: return data;
12681: }
12682:
12683: public static final BitSet _tokenSet_74 = new BitSet(
12684: mk_tokenSet_74());
12685:
12686: private static final long[] mk_tokenSet_75() {
12687: long[] data = new long[8];
12688: data[0] = 7009386627072L;
12689: data[1] = 4575657221139955712L;
12690: data[2] = 9223372036853727230L;
12691: data[3] = 1023L;
12692: return data;
12693: }
12694:
12695: public static final BitSet _tokenSet_75 = new BitSet(
12696: mk_tokenSet_75());
12697:
12698: private static final long[] mk_tokenSet_76() {
12699: long[] data = { 0L, 1610612736L, 2L, 0L, 0L, 0L };
12700: return data;
12701: }
12702:
12703: public static final BitSet _tokenSet_76 = new BitSet(
12704: mk_tokenSet_76());
12705:
12706: private static final long[] mk_tokenSet_77() {
12707: long[] data = { 0L, 2305878159369175040L, 0L, 0L };
12708: return data;
12709: }
12710:
12711: public static final BitSet _tokenSet_77 = new BitSet(
12712: mk_tokenSet_77());
12713:
12714: private static final long[] mk_tokenSet_78() {
12715: long[] data = new long[8];
12716: data[0] = 7009386627072L;
12717: data[1] = 2666130979300507648L;
12718: data[2] = 8809040871152418246L;
12719: data[3] = 1023L;
12720: return data;
12721: }
12722:
12723: public static final BitSet _tokenSet_78 = new BitSet(
12724: mk_tokenSet_78());
12725:
12726: private static final long[] mk_tokenSet_79() {
12727: long[] data = { 0L, 1079508992L, 8L, 0L, 0L, 0L };
12728: return data;
12729: }
12730:
12731: public static final BitSet _tokenSet_79 = new BitSet(
12732: mk_tokenSet_79());
12733:
12734: private static final long[] mk_tokenSet_80() {
12735: long[] data = { 0L, 2413964552567259136L, 16L, 0L, 0L, 0L };
12736: return data;
12737: }
12738:
12739: public static final BitSet _tokenSet_80 = new BitSet(
12740: mk_tokenSet_80());
12741:
12742: private static final long[] mk_tokenSet_81() {
12743: long[] data = { 0L, 2413929402418593792L, 16L, 0L, 0L, 0L };
12744: return data;
12745: }
12746:
12747: public static final BitSet _tokenSet_81 = new BitSet(
12748: mk_tokenSet_81());
12749:
12750: private static final long[] mk_tokenSet_82() {
12751: long[] data = new long[8];
12752: data[0] = 4810363371522L;
12753: data[1] = -144185588367523840L;
12754: data[2] = 8809040871140880350L;
12755: data[3] = 1023L;
12756: return data;
12757: }
12758:
12759: public static final BitSet _tokenSet_82 = new BitSet(
12760: mk_tokenSet_82());
12761:
12762: private static final long[] mk_tokenSet_83() {
12763: long[] data = { 137438953472L, 2305878159226961920L, 24L, 0L,
12764: 0L, 0L };
12765: return data;
12766: }
12767:
12768: public static final BitSet _tokenSet_83 = new BitSet(
12769: mk_tokenSet_83());
12770:
12771: private static final long[] mk_tokenSet_84() {
12772: long[] data = new long[8];
12773: data[0] = 4810363371520L;
12774: data[1] = 4431471634118836224L;
12775: data[2] = 8809040871139831646L;
12776: data[3] = 1023L;
12777: return data;
12778: }
12779:
12780: public static final BitSet _tokenSet_84 = new BitSet(
12781: mk_tokenSet_84());
12782:
12783: private static final long[] mk_tokenSet_85() {
12784: long[] data = new long[8];
12785: data[0] = 4810363371520L;
12786: data[1] = 1477075090848808960L;
12787: data[2] = 8809040871137730566L;
12788: data[3] = 1023L;
12789: return data;
12790: }
12791:
12792: public static final BitSet _tokenSet_85 = new BitSet(
12793: mk_tokenSet_85());
12794:
12795: private static final long[] mk_tokenSet_86() {
12796: long[] data = new long[8];
12797: data[0] = 288484363337728L;
12798: data[1] = 4611686018158919680L;
12799: data[2] = -1048578L;
12800: data[3] = 1023L;
12801: return data;
12802: }
12803:
12804: public static final BitSet _tokenSet_86 = new BitSet(
12805: mk_tokenSet_86());
12806:
12807: private static final long[] mk_tokenSet_87() {
12808: long[] data = { 4810363371520L, 2341766219836620800L, 4128L,
12809: 0L, 0L, 0L };
12810: return data;
12811: }
12812:
12813: public static final BitSet _tokenSet_87 = new BitSet(
12814: mk_tokenSet_87());
12815:
12816: private static final long[] mk_tokenSet_88() {
12817: long[] data = new long[8];
12818: data[0] = 4810363371520L;
12819: data[1] = 2629996596669906944L;
12820: data[2] = 8809040871137480742L;
12821: data[3] = 1023L;
12822: return data;
12823: }
12824:
12825: public static final BitSet _tokenSet_88 = new BitSet(
12826: mk_tokenSet_88());
12827:
12828: private static final long[] mk_tokenSet_89() {
12829: long[] data = { 4810363371520L, 2341766219836620800L, 0L, 0L };
12830: return data;
12831: }
12832:
12833: public static final BitSet _tokenSet_89 = new BitSet(
12834: mk_tokenSet_89());
12835:
12836: private static final long[] mk_tokenSet_90() {
12837: long[] data = { 4810363371520L, 3602774117792546816L, 0L, 0L };
12838: return data;
12839: }
12840:
12841: public static final BitSet _tokenSet_90 = new BitSet(
12842: mk_tokenSet_90());
12843:
12844: private static final long[] mk_tokenSet_91() {
12845: long[] data = { 0L, 1188950303787974656L, 0L, 0L };
12846: return data;
12847: }
12848:
12849: public static final BitSet _tokenSet_91 = new BitSet(
12850: mk_tokenSet_91());
12851:
12852: private static final long[] mk_tokenSet_92() {
12853: long[] data = { 137438953472L, 35150021656576L, 8L, 0L, 0L, 0L };
12854: return data;
12855: }
12856:
12857: public static final BitSet _tokenSet_92 = new BitSet(
12858: mk_tokenSet_92());
12859:
12860: private static final long[] mk_tokenSet_93() {
12861: long[] data = { 0L, 2594073385365405696L, 4194304L, 0L, 0L, 0L };
12862: return data;
12863: }
12864:
12865: public static final BitSet _tokenSet_93 = new BitSet(
12866: mk_tokenSet_93());
12867:
12868: private static final long[] mk_tokenSet_94() {
12869: long[] data = new long[8];
12870: data[0] = 2L;
12871: data[1] = 8971205610430791680L;
12872: data[2] = 8809040871138525318L;
12873: data[3] = 1023L;
12874: return data;
12875: }
12876:
12877: public static final BitSet _tokenSet_94 = new BitSet(
12878: mk_tokenSet_94());
12879:
12880: private static final long[] mk_tokenSet_95() {
12881: long[] data = new long[8];
12882: data[0] = 7009386627074L;
12883: data[1] = 9223372036586307584L;
12884: data[2] = 9223372036854775806L;
12885: data[3] = 1023L;
12886: return data;
12887: }
12888:
12889: public static final BitSet _tokenSet_95 = new BitSet(
12890: mk_tokenSet_95());
12891:
12892: private static final long[] mk_tokenSet_96() {
12893: long[] data = { 2L, 8682940083719897088L, 1048704L, 0L, 0L, 0L };
12894: return data;
12895: }
12896:
12897: public static final BitSet _tokenSet_96 = new BitSet(
12898: mk_tokenSet_96());
12899:
12900: private static final long[] mk_tokenSet_97() {
12901: long[] data = new long[8];
12902: data[0] = 288484363337730L;
12903: data[1] = 9223372036586307584L;
12904: data[2] = -10L;
12905: data[3] = 1023L;
12906: return data;
12907: }
12908:
12909: public static final BitSet _tokenSet_97 = new BitSet(
12910: mk_tokenSet_97());
12911:
12912: private static final long[] mk_tokenSet_98() {
12913: long[] data = { 4810363371520L, 3566745320773582848L, 4L, 0L,
12914: 0L, 0L };
12915: return data;
12916: }
12917:
12918: public static final BitSet _tokenSet_98 = new BitSet(
12919: mk_tokenSet_98());
12920:
12921: private static final long[] mk_tokenSet_99() {
12922: long[] data = { 0L, 25769803776L, 15762598695796736L, 0L, 0L,
12923: 0L };
12924: return data;
12925: }
12926:
12927: public static final BitSet _tokenSet_99 = new BitSet(
12928: mk_tokenSet_99());
12929:
12930: private static final long[] mk_tokenSet_100() {
12931: long[] data = new long[8];
12932: data[0] = -16L;
12933: data[1] = -288230376151711745L;
12934: data[2] = -1L;
12935: data[3] = 134217727L;
12936: return data;
12937: }
12938:
12939: public static final BitSet _tokenSet_100 = new BitSet(
12940: mk_tokenSet_100());
12941:
12942: private static final long[] mk_tokenSet_101() {
12943: long[] data = { 0L, 2594073385379037184L, 117440512L, 0L, 0L,
12944: 0L };
12945: return data;
12946: }
12947:
12948: public static final BitSet _tokenSet_101 = new BitSet(
12949: mk_tokenSet_101());
12950:
12951: private static final long[] mk_tokenSet_102() {
12952: long[] data = new long[8];
12953: data[0] = 7009386627072L;
12954: data[1] = 4395513205846147072L;
12955: data[2] = 8809040871269859294L;
12956: data[3] = 1023L;
12957: return data;
12958: }
12959:
12960: public static final BitSet _tokenSet_102 = new BitSet(
12961: mk_tokenSet_102());
12962:
12963: private static final long[] mk_tokenSet_103() {
12964: long[] data = new long[8];
12965: data[1] = 2594108535924588544L;
12966: data[2] = 8809040871137476614L;
12967: data[3] = 1023L;
12968: return data;
12969: }
12970:
12971: public static final BitSet _tokenSet_103 = new BitSet(
12972: mk_tokenSet_103());
12973:
12974: private static final long[] mk_tokenSet_104() {
12975: long[] data = { 0L, 35184372088832L, 108086391056891904L, 0L,
12976: 0L, 0L };
12977: return data;
12978: }
12979:
12980: public static final BitSet _tokenSet_104 = new BitSet(
12981: mk_tokenSet_104());
12982:
12983: private static final long[] mk_tokenSet_105() {
12984: long[] data = { 0L, 36028798097948672L, 0L, 0L };
12985: return data;
12986: }
12987:
12988: public static final BitSet _tokenSet_105 = new BitSet(
12989: mk_tokenSet_105());
12990:
12991: private static final long[] mk_tokenSet_106() {
12992: long[] data = new long[8];
12993: data[1] = 288265526710894592L;
12994: data[2] = 6917529027641081862L;
12995: data[3] = 1023L;
12996: return data;
12997: }
12998:
12999: public static final BitSet _tokenSet_106 = new BitSet(
13000: mk_tokenSet_106());
13001:
13002: private static final long[] mk_tokenSet_107() {
13003: long[] data = new long[8];
13004: data[0] = 2L;
13005: data[1] = 9187483976933572608L;
13006: data[2] = 9223372036722397366L;
13007: data[3] = 1023L;
13008: return data;
13009: }
13010:
13011: public static final BitSet _tokenSet_107 = new BitSet(
13012: mk_tokenSet_107());
13013:
13014: private static final long[] mk_tokenSet_108() {
13015: long[] data = new long[8];
13016: data[0] = 2L;
13017: data[1] = 9187483976937766912L;
13018: data[2] = 9223372036839837878L;
13019: data[3] = 1023L;
13020: return data;
13021: }
13022:
13023: public static final BitSet _tokenSet_108 = new BitSet(
13024: mk_tokenSet_108());
13025:
13026: private static final long[] mk_tokenSet_109() {
13027: long[] data = new long[8];
13028: data[0] = 7009386627072L;
13029: data[1] = 324259141524586496L;
13030: data[2] = 8809040871152418246L;
13031: data[3] = 1023L;
13032: return data;
13033: }
13034:
13035: public static final BitSet _tokenSet_109 = new BitSet(
13036: mk_tokenSet_109());
13037:
13038: private static final long[] mk_tokenSet_110() {
13039: long[] data = new long[8];
13040: data[1] = 288265526712991744L;
13041: data[2] = 8809040871137476614L;
13042: data[3] = 1023L;
13043: return data;
13044: }
13045:
13046: public static final BitSet _tokenSet_110 = new BitSet(
13047: mk_tokenSet_110());
13048:
13049: private static final long[] mk_tokenSet_111() {
13050: long[] data = new long[8];
13051: data[0] = 2199023255552L;
13052: data[1] = 288335895471980544L;
13053: data[2] = 6917529027655769542L;
13054: data[3] = 1023L;
13055: return data;
13056: }
13057:
13058: public static final BitSet _tokenSet_111 = new BitSet(
13059: mk_tokenSet_111());
13060:
13061: private static final long[] mk_tokenSet_112() {
13062: long[] data = new long[8];
13063: data[0] = 7009386627072L;
13064: data[1] = 4359484408822988800L;
13065: data[2] = 8809040871152418814L;
13066: data[3] = 1023L;
13067: return data;
13068: }
13069:
13070: public static final BitSet _tokenSet_112 = new BitSet(
13071: mk_tokenSet_112());
13072:
13073: private static final long[] mk_tokenSet_113() {
13074: long[] data = new long[8];
13075: data[0] = 4810363371520L;
13076: data[1] = 324153586241961984L;
13077: data[2] = 8809040871137730566L;
13078: data[3] = 1023L;
13079: return data;
13080: }
13081:
13082: public static final BitSet _tokenSet_113 = new BitSet(
13083: mk_tokenSet_113());
13084:
13085: private static final long[] mk_tokenSet_114() {
13086: long[] data = { 2199023255552L, 105518773436416L, 14687680L,
13087: 0L, 0L, 0L };
13088: return data;
13089: }
13090:
13091: public static final BitSet _tokenSet_114 = new BitSet(
13092: mk_tokenSet_114());
13093:
13094: }
|