diff --git a/.classpath b/.classpath
index 17791a799..3ee1187b6 100644
--- a/.classpath
+++ b/.classpath
@@ -1,6 +1,11 @@
-
+
+
+
+
+
+
diff --git a/app/src/antlr/java/JavaLexer.java b/app/src/antlr/java/JavaLexer.java
new file mode 100644
index 000000000..a34daaadc
--- /dev/null
+++ b/app/src/antlr/java/JavaLexer.java
@@ -0,0 +1,1899 @@
+// $ANTLR 2.7.7 (2006-11-01): "java.g" -> "JavaLexer.java"$
+
+package antlr.java;
+
+import java.io.InputStream;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.TokenStreamRecognitionException;
+import antlr.CharStreamException;
+import antlr.CharStreamIOException;
+import antlr.ANTLRException;
+import java.io.Reader;
+import java.util.Hashtable;
+import antlr.CharScanner;
+import antlr.InputBuffer;
+import antlr.ByteBuffer;
+import antlr.CharBuffer;
+import antlr.Token;
+import antlr.CommonToken;
+import antlr.RecognitionException;
+import antlr.NoViableAltForCharException;
+import antlr.MismatchedCharException;
+import antlr.TokenStream;
+import antlr.ANTLRHashString;
+import antlr.LexerSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.SemanticException;
+
+public class JavaLexer extends antlr.CharScanner implements JavaTokenTypes, TokenStream
+ {
+public JavaLexer(InputStream in) {
+ this(new ByteBuffer(in));
+}
+public JavaLexer(Reader in) {
+ this(new CharBuffer(in));
+}
+public JavaLexer(InputBuffer ib) {
+ this(new LexerSharedInputState(ib));
+}
+public JavaLexer(LexerSharedInputState state) {
+ super(state);
+ caseSensitiveLiterals = true;
+ setCaseSensitive(true);
+ literals = new Hashtable();
+ literals.put(new ANTLRHashString("byte", this), new Integer(51));
+ literals.put(new ANTLRHashString("public", this), new Integer(62));
+ literals.put(new ANTLRHashString("case", this), new Integer(95));
+ literals.put(new ANTLRHashString("short", this), new Integer(53));
+ literals.put(new ANTLRHashString("break", this), new Integer(89));
+ literals.put(new ANTLRHashString("while", this), new Integer(87));
+ literals.put(new ANTLRHashString("new", this), new Integer(138));
+ literals.put(new ANTLRHashString("instanceof", this), new Integer(123));
+ literals.put(new ANTLRHashString("implements", this), new Integer(76));
+ literals.put(new ANTLRHashString("synchronized", this), new Integer(68));
+ literals.put(new ANTLRHashString("float", this), new Integer(55));
+ literals.put(new ANTLRHashString("package", this), new Integer(44));
+ literals.put(new ANTLRHashString("return", this), new Integer(91));
+ literals.put(new ANTLRHashString("throw", this), new Integer(93));
+ literals.put(new ANTLRHashString("null", this), new Integer(137));
+ literals.put(new ANTLRHashString("threadsafe", this), new Integer(67));
+ literals.put(new ANTLRHashString("protected", this), new Integer(63));
+ literals.put(new ANTLRHashString("class", this), new Integer(70));
+ literals.put(new ANTLRHashString("throws", this), new Integer(82));
+ literals.put(new ANTLRHashString("do", this), new Integer(88));
+ literals.put(new ANTLRHashString("strictfp", this), new Integer(41));
+ literals.put(new ANTLRHashString("super", this), new Integer(80));
+ literals.put(new ANTLRHashString("transient", this), new Integer(65));
+ literals.put(new ANTLRHashString("native", this), new Integer(66));
+ literals.put(new ANTLRHashString("interface", this), new Integer(72));
+ literals.put(new ANTLRHashString("final", this), new Integer(39));
+ literals.put(new ANTLRHashString("if", this), new Integer(84));
+ literals.put(new ANTLRHashString("double", this), new Integer(57));
+ literals.put(new ANTLRHashString("volatile", this), new Integer(69));
+ literals.put(new ANTLRHashString("assert", this), new Integer(94));
+ literals.put(new ANTLRHashString("catch", this), new Integer(99));
+ literals.put(new ANTLRHashString("try", this), new Integer(97));
+ literals.put(new ANTLRHashString("int", this), new Integer(54));
+ literals.put(new ANTLRHashString("for", this), new Integer(86));
+ literals.put(new ANTLRHashString("extends", this), new Integer(71));
+ literals.put(new ANTLRHashString("boolean", this), new Integer(50));
+ literals.put(new ANTLRHashString("char", this), new Integer(52));
+ literals.put(new ANTLRHashString("private", this), new Integer(61));
+ literals.put(new ANTLRHashString("default", this), new Integer(96));
+ literals.put(new ANTLRHashString("false", this), new Integer(136));
+ literals.put(new ANTLRHashString("this", this), new Integer(79));
+ literals.put(new ANTLRHashString("static", this), new Integer(64));
+ literals.put(new ANTLRHashString("abstract", this), new Integer(40));
+ literals.put(new ANTLRHashString("continue", this), new Integer(90));
+ literals.put(new ANTLRHashString("finally", this), new Integer(98));
+ literals.put(new ANTLRHashString("else", this), new Integer(85));
+ literals.put(new ANTLRHashString("import", this), new Integer(46));
+ literals.put(new ANTLRHashString("void", this), new Integer(49));
+ literals.put(new ANTLRHashString("switch", this), new Integer(92));
+ literals.put(new ANTLRHashString("true", this), new Integer(135));
+ literals.put(new ANTLRHashString("long", this), new Integer(56));
+}
+
+public Token nextToken() throws TokenStreamException {
+ Token theRetToken=null;
+tryAgain:
+ for (;;) {
+ Token _token = null;
+ int _ttype = Token.INVALID_TYPE;
+ resetText();
+ try { // for char stream error handling
+ try { // for lexical error handling
+ switch ( LA(1)) {
+ case '?':
+ {
+ mQUESTION(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '(':
+ {
+ mLPAREN(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case ')':
+ {
+ mRPAREN(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '[':
+ {
+ mLBRACK(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case ']':
+ {
+ mRBRACK(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '{':
+ {
+ mLCURLY(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '}':
+ {
+ mRCURLY(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case ':':
+ {
+ mCOLON(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case ',':
+ {
+ mCOMMA(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '~':
+ {
+ mBNOT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case ';':
+ {
+ mSEMI(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '\t': case '\n': case '\u000c': case '\r':
+ case ' ':
+ {
+ mWS(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '\'':
+ {
+ mCHAR_LITERAL(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '"':
+ {
+ mSTRING_LITERAL(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '$': case 'A': case 'B': case 'C':
+ case 'D': case 'E': case 'F': case 'G':
+ case 'H': case 'I': case 'J': case 'K':
+ case 'L': case 'M': case 'N': case 'O':
+ case 'P': case 'Q': case 'R': case 'S':
+ case 'T': case 'U': case 'V': case 'W':
+ case 'X': case 'Y': case 'Z': case '_':
+ case 'a': case 'b': case 'c': case 'd':
+ case 'e': case 'f': case 'g': case 'h':
+ case 'i': case 'j': case 'k': case 'l':
+ case 'm': case 'n': case 'o': case 'p':
+ case 'q': case 'r': case 's': case 't':
+ case 'u': case 'v': case 'w': case 'x':
+ case 'y': case 'z':
+ {
+ mIDENT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case '.': case '0': case '1': case '2':
+ case '3': case '4': case '5': case '6':
+ case '7': case '8': case '9':
+ {
+ mNUM_INT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ default:
+ if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (LA(4)=='=')) {
+ mBSR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='=')) {
+ mSR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='>') && (LA(2)=='>') && (LA(3)=='>') && (true)) {
+ mBSR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='<') && (LA(2)=='<') && (LA(3)=='=')) {
+ mSL_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='=') && (LA(2)=='=')) {
+ mEQUAL(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='!') && (LA(2)=='=')) {
+ mNOT_EQUAL(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='/') && (LA(2)=='=')) {
+ mDIV_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='+') && (LA(2)=='=')) {
+ mPLUS_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='+') && (LA(2)=='+')) {
+ mINC(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='-') && (LA(2)=='=')) {
+ mMINUS_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='-') && (LA(2)=='-')) {
+ mDEC(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='*') && (LA(2)=='=')) {
+ mSTAR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='%') && (LA(2)=='=')) {
+ mMOD_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='>') && (LA(2)=='>') && (true)) {
+ mSR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='>') && (LA(2)=='=')) {
+ mGE(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='<') && (LA(2)=='<') && (true)) {
+ mSL(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='<') && (LA(2)=='=')) {
+ mLE(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='^') && (LA(2)=='=')) {
+ mBXOR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='|') && (LA(2)=='=')) {
+ mBOR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='|') && (LA(2)=='|')) {
+ mLOR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='&') && (LA(2)=='=')) {
+ mBAND_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='&') && (LA(2)=='&')) {
+ mLAND(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='/') && (LA(2)=='/')) {
+ mSL_COMMENT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='/') && (LA(2)=='*')) {
+ mML_COMMENT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='=') && (true)) {
+ mASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='!') && (true)) {
+ mLNOT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='/') && (true)) {
+ mDIV(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='+') && (true)) {
+ mPLUS(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='-') && (true)) {
+ mMINUS(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='*') && (true)) {
+ mSTAR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='%') && (true)) {
+ mMOD(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='>') && (true)) {
+ mGT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='<') && (true)) {
+ mLT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='^') && (true)) {
+ mBXOR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='|') && (true)) {
+ mBOR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1)=='&') && (true)) {
+ mBAND(true);
+ theRetToken=_returnToken;
+ }
+ else {
+ if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(Token.EOF_TYPE);}
+ else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+ }
+ if ( _returnToken==null ) continue tryAgain; // found SKIP token
+ _ttype = _returnToken.getType();
+ _returnToken.setType(_ttype);
+ return _returnToken;
+ }
+ catch (RecognitionException e) {
+ throw new TokenStreamRecognitionException(e);
+ }
+ }
+ catch (CharStreamException cse) {
+ if ( cse instanceof CharStreamIOException ) {
+ throw new TokenStreamIOException(((CharStreamIOException)cse).io);
+ }
+ else {
+ throw new TokenStreamException(cse.getMessage());
+ }
+ }
+ }
+}
+
+ public final void mQUESTION(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = QUESTION;
+ int _saveIndex;
+
+ match('?');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LPAREN;
+ int _saveIndex;
+
+ match('(');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRPAREN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = RPAREN;
+ int _saveIndex;
+
+ match(')');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LBRACK;
+ int _saveIndex;
+
+ match('[');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRBRACK(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = RBRACK;
+ int _saveIndex;
+
+ match(']');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LCURLY;
+ int _saveIndex;
+
+ match('{');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mRCURLY(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = RCURLY;
+ int _saveIndex;
+
+ match('}');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCOLON(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = COLON;
+ int _saveIndex;
+
+ match(':');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCOMMA(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = COMMA;
+ int _saveIndex;
+
+ match(',');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = ASSIGN;
+ int _saveIndex;
+
+ match('=');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mEQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = EQUAL;
+ int _saveIndex;
+
+ match("==");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LNOT;
+ int _saveIndex;
+
+ match('!');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBNOT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BNOT;
+ int _saveIndex;
+
+ match('~');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mNOT_EQUAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = NOT_EQUAL;
+ int _saveIndex;
+
+ match("!=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mDIV(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = DIV;
+ int _saveIndex;
+
+ match('/');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mDIV_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = DIV_ASSIGN;
+ int _saveIndex;
+
+ match("/=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mPLUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = PLUS;
+ int _saveIndex;
+
+ match('+');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mPLUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = PLUS_ASSIGN;
+ int _saveIndex;
+
+ match("+=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mINC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = INC;
+ int _saveIndex;
+
+ match("++");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mMINUS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = MINUS;
+ int _saveIndex;
+
+ match('-');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mMINUS_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = MINUS_ASSIGN;
+ int _saveIndex;
+
+ match("-=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mDEC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = DEC;
+ int _saveIndex;
+
+ match("--");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSTAR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = STAR;
+ int _saveIndex;
+
+ match('*');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSTAR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = STAR_ASSIGN;
+ int _saveIndex;
+
+ match("*=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mMOD(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = MOD;
+ int _saveIndex;
+
+ match('%');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mMOD_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = MOD_ASSIGN;
+ int _saveIndex;
+
+ match("%=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SR;
+ int _saveIndex;
+
+ match(">>");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SR_ASSIGN;
+ int _saveIndex;
+
+ match(">>=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBSR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BSR;
+ int _saveIndex;
+
+ match(">>>");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBSR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BSR_ASSIGN;
+ int _saveIndex;
+
+ match(">>>=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mGE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = GE;
+ int _saveIndex;
+
+ match(">=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mGT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = GT;
+ int _saveIndex;
+
+ match(">");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SL;
+ int _saveIndex;
+
+ match("<<");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSL_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SL_ASSIGN;
+ int _saveIndex;
+
+ match("<<=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLE(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LE;
+ int _saveIndex;
+
+ match("<=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LT;
+ int _saveIndex;
+
+ match('<');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBXOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BXOR;
+ int _saveIndex;
+
+ match('^');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBXOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BXOR_ASSIGN;
+ int _saveIndex;
+
+ match("^=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BOR;
+ int _saveIndex;
+
+ match('|');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBOR_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BOR_ASSIGN;
+ int _saveIndex;
+
+ match("|=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLOR(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LOR;
+ int _saveIndex;
+
+ match("||");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BAND;
+ int _saveIndex;
+
+ match('&');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mBAND_ASSIGN(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = BAND_ASSIGN;
+ int _saveIndex;
+
+ match("&=");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mLAND(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = LAND;
+ int _saveIndex;
+
+ match("&&");
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSEMI(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SEMI;
+ int _saveIndex;
+
+ match(';');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mWS(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = WS;
+ int _saveIndex;
+
+ {
+ int _cnt246=0;
+ _loop246:
+ do {
+ switch ( LA(1)) {
+ case ' ':
+ {
+ match(' ');
+ break;
+ }
+ case '\t':
+ {
+ match('\t');
+ break;
+ }
+ case '\u000c':
+ {
+ match('\f');
+ break;
+ }
+ case '\n': case '\r':
+ {
+ {
+ if ((LA(1)=='\r') && (LA(2)=='\n') && (true) && (true)) {
+ match("\r\n");
+ }
+ else if ((LA(1)=='\r') && (true) && (true) && (true)) {
+ match('\r');
+ }
+ else if ((LA(1)=='\n')) {
+ match('\n');
+ }
+ else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ newline();
+ break;
+ }
+ default:
+ {
+ if ( _cnt246>=1 ) { break _loop246; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+ }
+ _cnt246++;
+ } while (true);
+ }
+ _ttype = Token.SKIP;
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSL_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SL_COMMENT;
+ int _saveIndex;
+
+ match("//");
+ {
+ _loop250:
+ do {
+ if ((_tokenSet_0.member(LA(1)))) {
+ {
+ match(_tokenSet_0);
+ }
+ }
+ else {
+ break _loop250;
+ }
+
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case '\n':
+ {
+ match('\n');
+ break;
+ }
+ case '\r':
+ {
+ match('\r');
+ {
+ if ((LA(1)=='\n')) {
+ match('\n');
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ _ttype = Token.SKIP; newline();
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mML_COMMENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = ML_COMMENT;
+ int _saveIndex;
+
+ match("/*");
+ {
+ _loop256:
+ do {
+ if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && ((LA(4) >= '\u0003' && LA(4) <= '\uffff'))) {
+ match('\r');
+ match('\n');
+ newline();
+ }
+ else if (((LA(1)=='*') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')))&&( LA(2)!='/' )) {
+ match('*');
+ }
+ else if ((LA(1)=='\r') && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && (true)) {
+ match('\r');
+ newline();
+ }
+ else if ((LA(1)=='\n')) {
+ match('\n');
+ newline();
+ }
+ else if ((_tokenSet_1.member(LA(1)))) {
+ {
+ match(_tokenSet_1);
+ }
+ }
+ else {
+ break _loop256;
+ }
+
+ } while (true);
+ }
+ match("*/");
+ _ttype = Token.SKIP;
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mCHAR_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = CHAR_LITERAL;
+ int _saveIndex;
+
+ match('\'');
+ {
+ if ((LA(1)=='\\')) {
+ mESC(false);
+ }
+ else if ((_tokenSet_2.member(LA(1)))) {
+ matchNot('\'');
+ }
+ else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ match('\'');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mESC(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = ESC;
+ int _saveIndex;
+
+ match('\\');
+ {
+ switch ( LA(1)) {
+ case 'n':
+ {
+ match('n');
+ break;
+ }
+ case 'r':
+ {
+ match('r');
+ break;
+ }
+ case 't':
+ {
+ match('t');
+ break;
+ }
+ case 'b':
+ {
+ match('b');
+ break;
+ }
+ case 'f':
+ {
+ match('f');
+ break;
+ }
+ case '"':
+ {
+ match('"');
+ break;
+ }
+ case '\'':
+ {
+ match('\'');
+ break;
+ }
+ case '\\':
+ {
+ match('\\');
+ break;
+ }
+ case 'u':
+ {
+ {
+ int _cnt266=0;
+ _loop266:
+ do {
+ if ((LA(1)=='u')) {
+ match('u');
+ }
+ else {
+ if ( _cnt266>=1 ) { break _loop266; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt266++;
+ } while (true);
+ }
+ mHEX_DIGIT(false);
+ mHEX_DIGIT(false);
+ mHEX_DIGIT(false);
+ mHEX_DIGIT(false);
+ break;
+ }
+ case '0': case '1': case '2': case '3':
+ {
+ matchRange('0','3');
+ {
+ if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && (true) && (true)) {
+ matchRange('0','7');
+ {
+ if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && (true) && (true)) {
+ matchRange('0','7');
+ }
+ else if (((LA(1) >= '\u0003' && LA(1) <= '\uffff')) && (true) && (true) && (true)) {
+ }
+ else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ }
+ else if (((LA(1) >= '\u0003' && LA(1) <= '\uffff')) && (true) && (true) && (true)) {
+ }
+ else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ break;
+ }
+ case '4': case '5': case '6': case '7':
+ {
+ matchRange('4','7');
+ {
+ if (((LA(1) >= '0' && LA(1) <= '7')) && ((LA(2) >= '\u0003' && LA(2) <= '\uffff')) && (true) && (true)) {
+ matchRange('0','7');
+ }
+ else if (((LA(1) >= '\u0003' && LA(1) <= '\uffff')) && (true) && (true) && (true)) {
+ }
+ else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mSTRING_LITERAL(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = STRING_LITERAL;
+ int _saveIndex;
+
+ match('"');
+ {
+ _loop262:
+ do {
+ if ((LA(1)=='\\')) {
+ mESC(false);
+ }
+ else if ((_tokenSet_3.member(LA(1)))) {
+ {
+ match(_tokenSet_3);
+ }
+ }
+ else {
+ break _loop262;
+ }
+
+ } while (true);
+ }
+ match('"');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mHEX_DIGIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = HEX_DIGIT;
+ int _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ case '8': case '9':
+ {
+ matchRange('0','9');
+ break;
+ }
+ case 'A': case 'B': case 'C': case 'D':
+ case 'E': case 'F':
+ {
+ matchRange('A','F');
+ break;
+ }
+ case 'a': case 'b': case 'c': case 'd':
+ case 'e': case 'f':
+ {
+ matchRange('a','f');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mVOCAB(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = VOCAB;
+ int _saveIndex;
+
+ matchRange('\3','\377');
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mIDENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = IDENT;
+ int _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ case 'a': case 'b': case 'c': case 'd':
+ case 'e': case 'f': case 'g': case 'h':
+ case 'i': case 'j': case 'k': case 'l':
+ case 'm': case 'n': case 'o': case 'p':
+ case 'q': case 'r': case 's': case 't':
+ case 'u': case 'v': case 'w': case 'x':
+ case 'y': case 'z':
+ {
+ matchRange('a','z');
+ break;
+ }
+ case 'A': case 'B': case 'C': case 'D':
+ case 'E': case 'F': case 'G': case 'H':
+ case 'I': case 'J': case 'K': case 'L':
+ case 'M': case 'N': case 'O': case 'P':
+ case 'Q': case 'R': case 'S': case 'T':
+ case 'U': case 'V': case 'W': case 'X':
+ case 'Y': case 'Z':
+ {
+ matchRange('A','Z');
+ break;
+ }
+ case '_':
+ {
+ match('_');
+ break;
+ }
+ case '$':
+ {
+ match('$');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ _loop276:
+ do {
+ switch ( LA(1)) {
+ case 'a': case 'b': case 'c': case 'd':
+ case 'e': case 'f': case 'g': case 'h':
+ case 'i': case 'j': case 'k': case 'l':
+ case 'm': case 'n': case 'o': case 'p':
+ case 'q': case 'r': case 's': case 't':
+ case 'u': case 'v': case 'w': case 'x':
+ case 'y': case 'z':
+ {
+ matchRange('a','z');
+ break;
+ }
+ case 'A': case 'B': case 'C': case 'D':
+ case 'E': case 'F': case 'G': case 'H':
+ case 'I': case 'J': case 'K': case 'L':
+ case 'M': case 'N': case 'O': case 'P':
+ case 'Q': case 'R': case 'S': case 'T':
+ case 'U': case 'V': case 'W': case 'X':
+ case 'Y': case 'Z':
+ {
+ matchRange('A','Z');
+ break;
+ }
+ case '_':
+ {
+ match('_');
+ break;
+ }
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ case '8': case '9':
+ {
+ matchRange('0','9');
+ break;
+ }
+ case '$':
+ {
+ match('$');
+ break;
+ }
+ default:
+ {
+ break _loop276;
+ }
+ }
+ } while (true);
+ }
+ _ttype = testLiteralsTable(_ttype);
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ public final void mNUM_INT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = NUM_INT;
+ int _saveIndex;
+ Token f1=null;
+ Token f2=null;
+ Token f3=null;
+ Token f4=null;
+ boolean isDecimal=false; Token t=null;
+
+ switch ( LA(1)) {
+ case '.':
+ {
+ match('.');
+ _ttype = DOT;
+ {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ {
+ int _cnt280=0;
+ _loop280:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt280>=1 ) { break _loop280; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt280++;
+ } while (true);
+ }
+ {
+ if ((LA(1)=='E'||LA(1)=='e')) {
+ mEXPONENT(false);
+ }
+ else {
+ }
+
+ }
+ {
+ if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
+ mFLOAT_SUFFIX(true);
+ f1=_returnToken;
+ t=f1;
+ }
+ else {
+ }
+
+ }
+
+ if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
+ _ttype = NUM_FLOAT;
+ }
+ else {
+ _ttype = NUM_DOUBLE; // assume double
+ }
+
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ case '8': case '9':
+ {
+ {
+ switch ( LA(1)) {
+ case '0':
+ {
+ match('0');
+ isDecimal = true;
+ {
+ switch ( LA(1)) {
+ case 'X': case 'x':
+ {
+ {
+ switch ( LA(1)) {
+ case 'x':
+ {
+ match('x');
+ break;
+ }
+ case 'X':
+ {
+ match('X');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ int _cnt287=0;
+ _loop287:
+ do {
+ if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
+ mHEX_DIGIT(false);
+ }
+ else {
+ if ( _cnt287>=1 ) { break _loop287; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt287++;
+ } while (true);
+ }
+ break;
+ }
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ {
+ {
+ int _cnt289=0;
+ _loop289:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '7'))) {
+ matchRange('0','7');
+ }
+ else {
+ if ( _cnt289>=1 ) { break _loop289; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt289++;
+ } while (true);
+ }
+ break;
+ }
+ default:
+ {
+ }
+ }
+ }
+ break;
+ }
+ case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8':
+ case '9':
+ {
+ {
+ matchRange('1','9');
+ }
+ {
+ _loop292:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ break _loop292;
+ }
+
+ } while (true);
+ }
+ isDecimal=true;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ if ((LA(1)=='L'||LA(1)=='l')) {
+ {
+ switch ( LA(1)) {
+ case 'l':
+ {
+ match('l');
+ break;
+ }
+ case 'L':
+ {
+ match('L');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ _ttype = NUM_LONG;
+ }
+ else if (((LA(1)=='.'||LA(1)=='D'||LA(1)=='E'||LA(1)=='F'||LA(1)=='d'||LA(1)=='e'||LA(1)=='f'))&&(isDecimal)) {
+ {
+ switch ( LA(1)) {
+ case '.':
+ {
+ match('.');
+ {
+ _loop297:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ break _loop297;
+ }
+
+ } while (true);
+ }
+ {
+ if ((LA(1)=='E'||LA(1)=='e')) {
+ mEXPONENT(false);
+ }
+ else {
+ }
+
+ }
+ {
+ if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
+ mFLOAT_SUFFIX(true);
+ f2=_returnToken;
+ t=f2;
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 'E': case 'e':
+ {
+ mEXPONENT(false);
+ {
+ if ((LA(1)=='D'||LA(1)=='F'||LA(1)=='d'||LA(1)=='f')) {
+ mFLOAT_SUFFIX(true);
+ f3=_returnToken;
+ t=f3;
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 'D': case 'F': case 'd': case 'f':
+ {
+ mFLOAT_SUFFIX(true);
+ f4=_returnToken;
+ t=f4;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+
+ if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
+ _ttype = NUM_FLOAT;
+ }
+ else {
+ _ttype = NUM_DOUBLE; // assume double
+ }
+
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mEXPONENT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = EXPONENT;
+ int _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ case 'e':
+ {
+ match('e');
+ break;
+ }
+ case 'E':
+ {
+ match('E');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case '+':
+ {
+ match('+');
+ break;
+ }
+ case '-':
+ {
+ match('-');
+ break;
+ }
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7':
+ case '8': case '9':
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ int _cnt305=0;
+ _loop305:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt305>=1 ) { break _loop305; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt305++;
+ } while (true);
+ }
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+ protected final void mFLOAT_SUFFIX(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = FLOAT_SUFFIX;
+ int _saveIndex;
+
+ switch ( LA(1)) {
+ case 'f':
+ {
+ match('f');
+ break;
+ }
+ case 'F':
+ {
+ match('F');
+ break;
+ }
+ case 'd':
+ {
+ match('d');
+ break;
+ }
+ case 'D':
+ {
+ match('D');
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ if ( _createToken && _token==null && _ttype!=Token.SKIP ) {
+ _token = makeToken(_ttype);
+ _token.setText(new String(text.getBuffer(), _begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ }
+
+
+ private static final long[] mk_tokenSet_0() {
+ long[] data = new long[2048];
+ data[0]=-9224L;
+ for (int i = 1; i<=1023; i++) { data[i]=-1L; }
+ return data;
+ }
+ public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
+ private static final long[] mk_tokenSet_1() {
+ long[] data = new long[2048];
+ data[0]=-4398046520328L;
+ for (int i = 1; i<=1023; i++) { data[i]=-1L; }
+ return data;
+ }
+ public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
+ private static final long[] mk_tokenSet_2() {
+ long[] data = new long[2048];
+ data[0]=-549755813896L;
+ data[1]=-268435457L;
+ for (int i = 2; i<=1023; i++) { data[i]=-1L; }
+ return data;
+ }
+ public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
+ private static final long[] mk_tokenSet_3() {
+ long[] data = new long[2048];
+ data[0]=-17179869192L;
+ data[1]=-268435457L;
+ for (int i = 2; i<=1023; i++) { data[i]=-1L; }
+ return data;
+ }
+ public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
+ private static final long[] mk_tokenSet_4() {
+ long[] data = new long[1025];
+ data[0]=287948901175001088L;
+ data[1]=541165879422L;
+ return data;
+ }
+ public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
+
+ }
diff --git a/app/src/antlr/java/JavaRecognizer.java b/app/src/antlr/java/JavaRecognizer.java
new file mode 100644
index 000000000..8ace4853c
--- /dev/null
+++ b/app/src/antlr/java/JavaRecognizer.java
@@ -0,0 +1,5048 @@
+// $ANTLR 2.7.7 (2006-11-01): "java.g" -> "JavaRecognizer.java"$
+
+package antlr.java;
+
+import antlr.TokenBuffer;
+import antlr.TokenStreamException;
+import antlr.TokenStreamIOException;
+import antlr.ANTLRException;
+import antlr.LLkParser;
+import antlr.Token;
+import antlr.TokenStream;
+import antlr.RecognitionException;
+import antlr.NoViableAltException;
+import antlr.MismatchedTokenException;
+import antlr.SemanticException;
+import antlr.ParserSharedInputState;
+import antlr.collections.impl.BitSet;
+import antlr.collections.AST;
+import java.util.Hashtable;
+import antlr.ASTFactory;
+import antlr.ASTPair;
+import antlr.collections.impl.ASTArray;
+
+/** Java 1.3 Recognizer
+ *
+ * Run 'java Main [-showtree] directory-full-of-java-files'
+ *
+ * [The -showtree option pops up a Swing frame that shows
+ * the AST constructed from the parser.]
+ *
+ * Run 'java Main '
+ *
+ * Contributing authors:
+ * John Mitchell johnm@non.net
+ * Terence Parr parrt@magelang.com
+ * John Lilley jlilley@empathy.com
+ * Scott Stanchfield thetick@magelang.com
+ * Markus Mohnen mohnen@informatik.rwth-aachen.de
+ * Peter Williams pete.williams@sun.com
+ * Allan Jacobs Allan.Jacobs@eng.sun.com
+ * Steve Messick messick@redhills.com
+ * John Pybus john@pybus.org
+ *
+ * Version 1.00 December 9, 1997 -- initial release
+ * Version 1.01 December 10, 1997
+ * fixed bug in octal def (0..7 not 0..8)
+ * Version 1.10 August 1998 (parrt)
+ * added tree construction
+ * fixed definition of WS,comments for mac,pc,unix newlines
+ * added unary plus
+ * Version 1.11 (Nov 20, 1998)
+ * Added "shutup" option to turn off last ambig warning.
+ * Fixed inner class def to allow named class defs as statements
+ * synchronized requires compound not simple statement
+ * add [] after builtInType DOT class in primaryExpression
+ * "const" is reserved but not valid..removed from modifiers
+ * Version 1.12 (Feb 2, 1999)
+ * Changed LITERAL_xxx to xxx in tree grammar.
+ * Updated java.g to use tokens {...} now for 2.6.0 (new feature).
+ *
+ * Version 1.13 (Apr 23, 1999)
+ * Didn't have (stat)? for else clause in tree parser.
+ * Didn't gen ASTs for interface extends. Updated tree parser too.
+ * Updated to 2.6.0.
+ * Version 1.14 (Jun 20, 1999)
+ * Allowed final/abstract on local classes.
+ * Removed local interfaces from methods
+ * Put instanceof precedence where it belongs...in relationalExpr
+ * It also had expr not type as arg; fixed it.
+ * Missing ! on SEMI in classBlock
+ * fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
+ * fixed: didn't like Object[].class in parser or tree parser
+ * Version 1.15 (Jun 26, 1999)
+ * Screwed up rule with instanceof in it. :( Fixed.
+ * Tree parser didn't like (expr).something; fixed.
+ * Allowed multiple inheritance in tree grammar. oops.
+ * Version 1.16 (August 22, 1999)
+ * Extending an interface built a wacky tree: had extra EXTENDS.
+ * Tree grammar didn't allow multiple superinterfaces.
+ * Tree grammar didn't allow empty var initializer: {}
+ * Version 1.17 (October 12, 1999)
+ * ESC lexer rule allowed 399 max not 377 max.
+ * java.tree.g didn't handle the expression of synchronized
+ * statements.
+ * Version 1.18 (August 12, 2001)
+ * Terence updated to Java 2 Version 1.3 by
+ * observing/combining work of Allan Jacobs and Steve
+ * Messick. Handles 1.3 src. Summary:
+ * o primary didn't include boolean.class kind of thing
+ * o constructor calls parsed explicitly now:
+ * see explicitConstructorInvocation
+ * o add strictfp modifier
+ * o missing objBlock after new expression in tree grammar
+ * o merged local class definition alternatives, moved after declaration
+ * o fixed problem with ClassName.super.field
+ * o reordered some alternatives to make things more efficient
+ * o long and double constants were not differentiated from int/float
+ * o whitespace rule was inefficient: matched only one char
+ * o add an examples directory with some nasty 1.3 cases
+ * o made Main.java use buffered IO and a Reader for Unicode support
+ * o supports UNICODE?
+ * Using Unicode charVocabulay makes code file big, but only
+ * in the bitsets at the end. I need to make ANTLR generate
+ * unicode bitsets more efficiently.
+ * Version 1.19 (April 25, 2002)
+ * Terence added in nice fixes by John Pybus concerning floating
+ * constants and problems with super() calls. John did a nice
+ * reorg of the primary/postfix expression stuff to read better
+ * and makes f.g.super() parse properly (it was METHOD_CALL not
+ * a SUPER_CTOR_CALL). Also:
+ *
+ * o "finally" clause was a root...made it a child of "try"
+ * o Added stuff for asserts too for Java 1.4, but *commented out*
+ * as it is not backward compatible.
+ *
+ * Version 1.20 (October 27, 2002)
+ *
+ * Terence ended up reorging John Pybus' stuff to
+ * remove some nondeterminisms and some syntactic predicates.
+ * Note that the grammar is stricter now; e.g., this(...) must
+ * be the first statement.
+ *
+ * Trinary ?: operator wasn't working as array name:
+ * (isBig ? bigDigits : digits)[i];
+ *
+ * Checked parser/tree parser on source for
+ * Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
+ * and the 110k-line jGuru server source.
+ *
+ * This grammar is in the PUBLIC DOMAIN
+ *
+ */
+public class JavaRecognizer extends antlr.LLkParser implements JavaTokenTypes
+ {
+
+protected JavaRecognizer(TokenBuffer tokenBuf, int k) {
+ super(tokenBuf,k);
+ tokenNames = _tokenNames;
+ buildTokenTypeASTClassMap();
+ astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+public JavaRecognizer(TokenBuffer tokenBuf) {
+ this(tokenBuf,2);
+}
+
+protected JavaRecognizer(TokenStream lexer, int k) {
+ super(lexer,k);
+ tokenNames = _tokenNames;
+ buildTokenTypeASTClassMap();
+ astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+public JavaRecognizer(TokenStream lexer) {
+ this(lexer,2);
+}
+
+public JavaRecognizer(ParserSharedInputState state) {
+ super(state,2);
+ tokenNames = _tokenNames;
+ buildTokenTypeASTClassMap();
+ astFactory = new ASTFactory(getTokenTypeToASTClassMap());
+}
+
+ public final void compilationUnit() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST compilationUnit_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_package:
+ {
+ packageDefinition();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case EOF:
+ case FINAL:
+ case ABSTRACT:
+ case STRICTFP:
+ case SEMI:
+ case LITERAL_import:
+ case LITERAL_private:
+ case LITERAL_public:
+ case LITERAL_protected:
+ case LITERAL_static:
+ case LITERAL_transient:
+ case LITERAL_native:
+ case LITERAL_threadsafe:
+ case LITERAL_synchronized:
+ case LITERAL_volatile:
+ case LITERAL_class:
+ case LITERAL_interface:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ _loop4:
+ do {
+ if ((LA(1)==LITERAL_import)) {
+ importDefinition();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop4;
+ }
+
+ } while (true);
+ }
+ {
+ _loop6:
+ do {
+ if ((_tokenSet_0.member(LA(1)))) {
+ typeDefinition();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop6;
+ }
+
+ } while (true);
+ }
+ match(Token.EOF_TYPE);
+ compilationUnit_AST = (AST)currentAST.root;
+ returnAST = compilationUnit_AST;
+ }
+
+ public final void packageDefinition() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST packageDefinition_AST = null;
+ Token p = null;
+ AST p_AST = null;
+
+ try { // for error handling
+ p = LT(1);
+ p_AST = astFactory.create(p);
+ astFactory.makeASTRoot(currentAST, p_AST);
+ match(LITERAL_package);
+ if ( inputState.guessing==0 ) {
+ p_AST.setType(PACKAGE_DEF);
+ }
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ packageDefinition_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_1);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = packageDefinition_AST;
+ }
+
+ public final void importDefinition() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST importDefinition_AST = null;
+ Token i = null;
+ AST i_AST = null;
+
+ try { // for error handling
+ i = LT(1);
+ i_AST = astFactory.create(i);
+ astFactory.makeASTRoot(currentAST, i_AST);
+ match(LITERAL_import);
+ if ( inputState.guessing==0 ) {
+ i_AST.setType(IMPORT);
+ }
+ identifierStar();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ importDefinition_AST = (AST)currentAST.root;
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_1);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = importDefinition_AST;
+ }
+
+ public final void typeDefinition() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST typeDefinition_AST = null;
+ AST m_AST = null;
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case FINAL:
+ case ABSTRACT:
+ case STRICTFP:
+ case LITERAL_private:
+ case LITERAL_public:
+ case LITERAL_protected:
+ case LITERAL_static:
+ case LITERAL_transient:
+ case LITERAL_native:
+ case LITERAL_threadsafe:
+ case LITERAL_synchronized:
+ case LITERAL_volatile:
+ case LITERAL_class:
+ case LITERAL_interface:
+ {
+ modifiers();
+ m_AST = (AST)returnAST;
+ {
+ switch ( LA(1)) {
+ case LITERAL_class:
+ {
+ classDefinition(m_AST);
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LITERAL_interface:
+ {
+ interfaceDefinition(m_AST);
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ typeDefinition_AST = (AST)currentAST.root;
+ break;
+ }
+ case SEMI:
+ {
+ match(SEMI);
+ typeDefinition_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (RecognitionException ex) {
+ if (inputState.guessing==0) {
+ reportError(ex);
+ recover(ex,_tokenSet_2);
+ } else {
+ throw ex;
+ }
+ }
+ returnAST = typeDefinition_AST;
+ }
+
+ public final void identifier() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST identifier_AST = null;
+
+ AST tmp5_AST = null;
+ tmp5_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp5_AST);
+ match(IDENT);
+ {
+ _loop23:
+ do {
+ if ((LA(1)==DOT)) {
+ AST tmp6_AST = null;
+ tmp6_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp6_AST);
+ match(DOT);
+ AST tmp7_AST = null;
+ tmp7_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp7_AST);
+ match(IDENT);
+ }
+ else {
+ break _loop23;
+ }
+
+ } while (true);
+ }
+ identifier_AST = (AST)currentAST.root;
+ returnAST = identifier_AST;
+ }
+
+ public final void identifierStar() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST identifierStar_AST = null;
+
+ AST tmp8_AST = null;
+ tmp8_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp8_AST);
+ match(IDENT);
+ {
+ _loop26:
+ do {
+ if ((LA(1)==DOT) && (LA(2)==IDENT)) {
+ AST tmp9_AST = null;
+ tmp9_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp9_AST);
+ match(DOT);
+ AST tmp10_AST = null;
+ tmp10_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp10_AST);
+ match(IDENT);
+ }
+ else {
+ break _loop26;
+ }
+
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ AST tmp11_AST = null;
+ tmp11_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp11_AST);
+ match(DOT);
+ AST tmp12_AST = null;
+ tmp12_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp12_AST);
+ match(STAR);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ identifierStar_AST = (AST)currentAST.root;
+ returnAST = identifierStar_AST;
+ }
+
+ public final void modifiers() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST modifiers_AST = null;
+
+ {
+ _loop30:
+ do {
+ if ((_tokenSet_3.member(LA(1)))) {
+ modifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop30;
+ }
+
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ modifiers_AST = (AST)currentAST.root;
+ modifiers_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(modifiers_AST));
+ currentAST.root = modifiers_AST;
+ currentAST.child = modifiers_AST!=null &&modifiers_AST.getFirstChild()!=null ?
+ modifiers_AST.getFirstChild() : modifiers_AST;
+ currentAST.advanceChildToEnd();
+ }
+ modifiers_AST = (AST)currentAST.root;
+ returnAST = modifiers_AST;
+ }
+
+ public final void classDefinition(
+ AST modifiers
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST classDefinition_AST = null;
+ AST sc_AST = null;
+ AST ic_AST = null;
+ AST cb_AST = null;
+
+ match(LITERAL_class);
+ AST tmp14_AST = null;
+ tmp14_AST = astFactory.create(LT(1));
+ match(IDENT);
+ superClassClause();
+ sc_AST = (AST)returnAST;
+ implementsClause();
+ ic_AST = (AST)returnAST;
+ classBlock();
+ cb_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ classDefinition_AST = (AST)currentAST.root;
+ classDefinition_AST = (AST)astFactory.make( (new ASTArray(6)).add(astFactory.create(CLASS_DEF,"CLASS_DEF")).add(modifiers).add(tmp14_AST).add(sc_AST).add(ic_AST).add(cb_AST));
+ currentAST.root = classDefinition_AST;
+ currentAST.child = classDefinition_AST!=null &&classDefinition_AST.getFirstChild()!=null ?
+ classDefinition_AST.getFirstChild() : classDefinition_AST;
+ currentAST.advanceChildToEnd();
+ }
+ returnAST = classDefinition_AST;
+ }
+
+ public final void interfaceDefinition(
+ AST modifiers
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST interfaceDefinition_AST = null;
+ AST ie_AST = null;
+ AST cb_AST = null;
+
+ match(LITERAL_interface);
+ AST tmp16_AST = null;
+ tmp16_AST = astFactory.create(LT(1));
+ match(IDENT);
+ interfaceExtends();
+ ie_AST = (AST)returnAST;
+ classBlock();
+ cb_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ interfaceDefinition_AST = (AST)currentAST.root;
+ interfaceDefinition_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(INTERFACE_DEF,"INTERFACE_DEF")).add(modifiers).add(tmp16_AST).add(ie_AST).add(cb_AST));
+ currentAST.root = interfaceDefinition_AST;
+ currentAST.child = interfaceDefinition_AST!=null &&interfaceDefinition_AST.getFirstChild()!=null ?
+ interfaceDefinition_AST.getFirstChild() : interfaceDefinition_AST;
+ currentAST.advanceChildToEnd();
+ }
+ returnAST = interfaceDefinition_AST;
+ }
+
+/** A declaration is the creation of a reference or primitive-type variable
+ * Create a separate Type/Var tree for each var in the var list.
+ */
+ public final void declaration() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST declaration_AST = null;
+ AST m_AST = null;
+ AST t_AST = null;
+ AST v_AST = null;
+
+ modifiers();
+ m_AST = (AST)returnAST;
+ typeSpec(false);
+ t_AST = (AST)returnAST;
+ variableDefinitions(m_AST,t_AST);
+ v_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ declaration_AST = (AST)currentAST.root;
+ declaration_AST = v_AST;
+ currentAST.root = declaration_AST;
+ currentAST.child = declaration_AST!=null &&declaration_AST.getFirstChild()!=null ?
+ declaration_AST.getFirstChild() : declaration_AST;
+ currentAST.advanceChildToEnd();
+ }
+ returnAST = declaration_AST;
+ }
+
+ public final void typeSpec(
+ boolean addImagNode
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST typeSpec_AST = null;
+
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ classTypeSpec(addImagNode);
+ astFactory.addASTChild(currentAST, returnAST);
+ typeSpec_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ {
+ builtInTypeSpec(addImagNode);
+ astFactory.addASTChild(currentAST, returnAST);
+ typeSpec_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = typeSpec_AST;
+ }
+
+ public final void variableDefinitions(
+ AST mods, AST t
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST variableDefinitions_AST = null;
+
+ variableDeclarator(getASTFactory().dupTree(mods),
+ getASTFactory().dupTree(t));
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop59:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ variableDeclarator(getASTFactory().dupTree(mods),
+ getASTFactory().dupTree(t));
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop59;
+ }
+
+ } while (true);
+ }
+ variableDefinitions_AST = (AST)currentAST.root;
+ returnAST = variableDefinitions_AST;
+ }
+
+ public final void classTypeSpec(
+ boolean addImagNode
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST classTypeSpec_AST = null;
+ Token lb = null;
+ AST lb_AST = null;
+
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop15:
+ do {
+ if ((LA(1)==LBRACK)) {
+ lb = LT(1);
+ lb_AST = astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lb_AST.setType(ARRAY_DECLARATOR);
+ }
+ match(RBRACK);
+ }
+ else {
+ break _loop15;
+ }
+
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ classTypeSpec_AST = (AST)currentAST.root;
+
+ if ( addImagNode ) {
+ classTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(classTypeSpec_AST));
+ }
+
+ currentAST.root = classTypeSpec_AST;
+ currentAST.child = classTypeSpec_AST!=null &&classTypeSpec_AST.getFirstChild()!=null ?
+ classTypeSpec_AST.getFirstChild() : classTypeSpec_AST;
+ currentAST.advanceChildToEnd();
+ }
+ classTypeSpec_AST = (AST)currentAST.root;
+ returnAST = classTypeSpec_AST;
+ }
+
+ public final void builtInTypeSpec(
+ boolean addImagNode
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST builtInTypeSpec_AST = null;
+ Token lb = null;
+ AST lb_AST = null;
+
+ builtInType();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop18:
+ do {
+ if ((LA(1)==LBRACK)) {
+ lb = LT(1);
+ lb_AST = astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lb_AST.setType(ARRAY_DECLARATOR);
+ }
+ match(RBRACK);
+ }
+ else {
+ break _loop18;
+ }
+
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ builtInTypeSpec_AST = (AST)currentAST.root;
+
+ if ( addImagNode ) {
+ builtInTypeSpec_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(builtInTypeSpec_AST));
+ }
+
+ currentAST.root = builtInTypeSpec_AST;
+ currentAST.child = builtInTypeSpec_AST!=null &&builtInTypeSpec_AST.getFirstChild()!=null ?
+ builtInTypeSpec_AST.getFirstChild() : builtInTypeSpec_AST;
+ currentAST.advanceChildToEnd();
+ }
+ builtInTypeSpec_AST = (AST)currentAST.root;
+ returnAST = builtInTypeSpec_AST;
+ }
+
+ public final void builtInType() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST builtInType_AST = null;
+
+ switch ( LA(1)) {
+ case LITERAL_void:
+ {
+ AST tmp20_AST = null;
+ tmp20_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp20_AST);
+ match(LITERAL_void);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_boolean:
+ {
+ AST tmp21_AST = null;
+ tmp21_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp21_AST);
+ match(LITERAL_boolean);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_byte:
+ {
+ AST tmp22_AST = null;
+ tmp22_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp22_AST);
+ match(LITERAL_byte);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_char:
+ {
+ AST tmp23_AST = null;
+ tmp23_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp23_AST);
+ match(LITERAL_char);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_short:
+ {
+ AST tmp24_AST = null;
+ tmp24_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp24_AST);
+ match(LITERAL_short);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_int:
+ {
+ AST tmp25_AST = null;
+ tmp25_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp25_AST);
+ match(LITERAL_int);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_float:
+ {
+ AST tmp26_AST = null;
+ tmp26_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp26_AST);
+ match(LITERAL_float);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_long:
+ {
+ AST tmp27_AST = null;
+ tmp27_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp27_AST);
+ match(LITERAL_long);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_double:
+ {
+ AST tmp28_AST = null;
+ tmp28_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp28_AST);
+ match(LITERAL_double);
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = builtInType_AST;
+ }
+
+ public final void type() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST type_AST = null;
+
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ type_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ {
+ builtInType();
+ astFactory.addASTChild(currentAST, returnAST);
+ type_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = type_AST;
+ }
+
+ public final void modifier() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST modifier_AST = null;
+
+ switch ( LA(1)) {
+ case LITERAL_private:
+ {
+ AST tmp29_AST = null;
+ tmp29_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp29_AST);
+ match(LITERAL_private);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_public:
+ {
+ AST tmp30_AST = null;
+ tmp30_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp30_AST);
+ match(LITERAL_public);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_protected:
+ {
+ AST tmp31_AST = null;
+ tmp31_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp31_AST);
+ match(LITERAL_protected);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_static:
+ {
+ AST tmp32_AST = null;
+ tmp32_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp32_AST);
+ match(LITERAL_static);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_transient:
+ {
+ AST tmp33_AST = null;
+ tmp33_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp33_AST);
+ match(LITERAL_transient);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case FINAL:
+ {
+ AST tmp34_AST = null;
+ tmp34_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp34_AST);
+ match(FINAL);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case ABSTRACT:
+ {
+ AST tmp35_AST = null;
+ tmp35_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp35_AST);
+ match(ABSTRACT);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_native:
+ {
+ AST tmp36_AST = null;
+ tmp36_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp36_AST);
+ match(LITERAL_native);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_threadsafe:
+ {
+ AST tmp37_AST = null;
+ tmp37_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp37_AST);
+ match(LITERAL_threadsafe);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_synchronized:
+ {
+ AST tmp38_AST = null;
+ tmp38_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp38_AST);
+ match(LITERAL_synchronized);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_volatile:
+ {
+ AST tmp39_AST = null;
+ tmp39_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp39_AST);
+ match(LITERAL_volatile);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ case STRICTFP:
+ {
+ AST tmp40_AST = null;
+ tmp40_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp40_AST);
+ match(STRICTFP);
+ modifier_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = modifier_AST;
+ }
+
+ public final void superClassClause() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST superClassClause_AST = null;
+ AST id_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_extends:
+ {
+ match(LITERAL_extends);
+ identifier();
+ id_AST = (AST)returnAST;
+ break;
+ }
+ case LCURLY:
+ case LITERAL_implements:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ superClassClause_AST = (AST)currentAST.root;
+ superClassClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE")).add(id_AST));
+ currentAST.root = superClassClause_AST;
+ currentAST.child = superClassClause_AST!=null &&superClassClause_AST.getFirstChild()!=null ?
+ superClassClause_AST.getFirstChild() : superClassClause_AST;
+ currentAST.advanceChildToEnd();
+ }
+ returnAST = superClassClause_AST;
+ }
+
+ public final void implementsClause() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST implementsClause_AST = null;
+ Token i = null;
+ AST i_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_implements:
+ {
+ i = LT(1);
+ i_AST = astFactory.create(i);
+ match(LITERAL_implements);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop46:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop46;
+ }
+
+ } while (true);
+ }
+ break;
+ }
+ case LCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ implementsClause_AST = (AST)currentAST.root;
+ implementsClause_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE")).add(implementsClause_AST));
+ currentAST.root = implementsClause_AST;
+ currentAST.child = implementsClause_AST!=null &&implementsClause_AST.getFirstChild()!=null ?
+ implementsClause_AST.getFirstChild() : implementsClause_AST;
+ currentAST.advanceChildToEnd();
+ }
+ implementsClause_AST = (AST)currentAST.root;
+ returnAST = implementsClause_AST;
+ }
+
+ public final void classBlock() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST classBlock_AST = null;
+
+ match(LCURLY);
+ {
+ _loop38:
+ do {
+ switch ( LA(1)) {
+ case FINAL:
+ case ABSTRACT:
+ case STRICTFP:
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LITERAL_private:
+ case LITERAL_public:
+ case LITERAL_protected:
+ case LITERAL_static:
+ case LITERAL_transient:
+ case LITERAL_native:
+ case LITERAL_threadsafe:
+ case LITERAL_synchronized:
+ case LITERAL_volatile:
+ case LITERAL_class:
+ case LITERAL_interface:
+ case LCURLY:
+ {
+ field();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ match(SEMI);
+ break;
+ }
+ default:
+ {
+ break _loop38;
+ }
+ }
+ } while (true);
+ }
+ match(RCURLY);
+ if ( inputState.guessing==0 ) {
+ classBlock_AST = (AST)currentAST.root;
+ classBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJBLOCK,"OBJBLOCK")).add(classBlock_AST));
+ currentAST.root = classBlock_AST;
+ currentAST.child = classBlock_AST!=null &&classBlock_AST.getFirstChild()!=null ?
+ classBlock_AST.getFirstChild() : classBlock_AST;
+ currentAST.advanceChildToEnd();
+ }
+ classBlock_AST = (AST)currentAST.root;
+ returnAST = classBlock_AST;
+ }
+
+ public final void interfaceExtends() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST interfaceExtends_AST = null;
+ Token e = null;
+ AST e_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_extends:
+ {
+ e = LT(1);
+ e_AST = astFactory.create(e);
+ match(LITERAL_extends);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop42:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop42;
+ }
+
+ } while (true);
+ }
+ break;
+ }
+ case LCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ interfaceExtends_AST = (AST)currentAST.root;
+ interfaceExtends_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXTENDS_CLAUSE,"EXTENDS_CLAUSE")).add(interfaceExtends_AST));
+ currentAST.root = interfaceExtends_AST;
+ currentAST.child = interfaceExtends_AST!=null &&interfaceExtends_AST.getFirstChild()!=null ?
+ interfaceExtends_AST.getFirstChild() : interfaceExtends_AST;
+ currentAST.advanceChildToEnd();
+ }
+ interfaceExtends_AST = (AST)currentAST.root;
+ returnAST = interfaceExtends_AST;
+ }
+
+ public final void field() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST field_AST = null;
+ AST mods_AST = null;
+ AST h_AST = null;
+ AST s_AST = null;
+ AST cd_AST = null;
+ AST id_AST = null;
+ AST t_AST = null;
+ AST param_AST = null;
+ AST rt_AST = null;
+ AST tc_AST = null;
+ AST s2_AST = null;
+ AST v_AST = null;
+ AST s3_AST = null;
+ AST s4_AST = null;
+
+ if ((_tokenSet_4.member(LA(1))) && (_tokenSet_5.member(LA(2)))) {
+ modifiers();
+ mods_AST = (AST)returnAST;
+ {
+ switch ( LA(1)) {
+ case LITERAL_class:
+ {
+ classDefinition(mods_AST);
+ cd_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = cd_AST;
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ break;
+ }
+ case LITERAL_interface:
+ {
+ interfaceDefinition(mods_AST);
+ id_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = id_AST;
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ break;
+ }
+ default:
+ if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
+ ctorHead();
+ h_AST = (AST)returnAST;
+ constructorBody();
+ s_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(CTOR_DEF,"CTOR_DEF")).add(mods_AST).add(h_AST).add(s_AST));
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else if (((LA(1) >= LITERAL_void && LA(1) <= IDENT)) && (_tokenSet_6.member(LA(2)))) {
+ typeSpec(false);
+ t_AST = (AST)returnAST;
+ {
+ if ((LA(1)==IDENT) && (LA(2)==LPAREN)) {
+ AST tmp47_AST = null;
+ tmp47_AST = astFactory.create(LT(1));
+ match(IDENT);
+ match(LPAREN);
+ parameterDeclarationList();
+ param_AST = (AST)returnAST;
+ match(RPAREN);
+ declaratorBrackets(t_AST);
+ rt_AST = (AST)returnAST;
+ {
+ switch ( LA(1)) {
+ case LITERAL_throws:
+ {
+ throwsClause();
+ tc_AST = (AST)returnAST;
+ break;
+ }
+ case SEMI:
+ case LCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case LCURLY:
+ {
+ compoundStatement();
+ s2_AST = (AST)returnAST;
+ break;
+ }
+ case SEMI:
+ {
+ AST tmp50_AST = null;
+ tmp50_AST = astFactory.create(LT(1));
+ match(SEMI);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = (AST)astFactory.make( (new ASTArray(7)).add(astFactory.create(METHOD_DEF,"METHOD_DEF")).add(mods_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(rt_AST))).add(tmp47_AST).add(param_AST).add(tc_AST).add(s2_AST));
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else if ((LA(1)==IDENT) && (_tokenSet_7.member(LA(2)))) {
+ variableDefinitions(mods_AST,t_AST);
+ v_AST = (AST)returnAST;
+ AST tmp51_AST = null;
+ tmp51_AST = astFactory.create(LT(1));
+ match(SEMI);
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = v_AST;
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else if ((LA(1)==LITERAL_static) && (LA(2)==LCURLY)) {
+ match(LITERAL_static);
+ compoundStatement();
+ s3_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(STATIC_INIT,"STATIC_INIT")).add(s3_AST));
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else if ((LA(1)==LCURLY)) {
+ compoundStatement();
+ s4_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ field_AST = (AST)currentAST.root;
+ field_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,"INSTANCE_INIT")).add(s4_AST));
+ currentAST.root = field_AST;
+ currentAST.child = field_AST!=null &&field_AST.getFirstChild()!=null ?
+ field_AST.getFirstChild() : field_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ returnAST = field_AST;
+ }
+
+ public final void ctorHead() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST ctorHead_AST = null;
+
+ AST tmp53_AST = null;
+ tmp53_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp53_AST);
+ match(IDENT);
+ match(LPAREN);
+ parameterDeclarationList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ {
+ switch ( LA(1)) {
+ case LITERAL_throws:
+ {
+ throwsClause();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ ctorHead_AST = (AST)currentAST.root;
+ returnAST = ctorHead_AST;
+ }
+
+ public final void constructorBody() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST constructorBody_AST = null;
+ Token lc = null;
+ AST lc_AST = null;
+
+ lc = LT(1);
+ lc_AST = astFactory.create(lc);
+ astFactory.makeASTRoot(currentAST, lc_AST);
+ match(LCURLY);
+ if ( inputState.guessing==0 ) {
+ lc_AST.setType(SLIST);
+ }
+ {
+ if ((LA(1)==LITERAL_this||LA(1)==LITERAL_super) && (LA(2)==LPAREN)) {
+ explicitConstructorInvocation();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else if ((_tokenSet_8.member(LA(1))) && (_tokenSet_9.member(LA(2)))) {
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ {
+ _loop55:
+ do {
+ if ((_tokenSet_10.member(LA(1)))) {
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop55;
+ }
+
+ } while (true);
+ }
+ match(RCURLY);
+ constructorBody_AST = (AST)currentAST.root;
+ returnAST = constructorBody_AST;
+ }
+
+ public final void parameterDeclarationList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST parameterDeclarationList_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case FINAL:
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ {
+ parameterDeclaration();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop80:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ parameterDeclaration();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop80;
+ }
+
+ } while (true);
+ }
+ break;
+ }
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ parameterDeclarationList_AST = (AST)currentAST.root;
+ parameterDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PARAMETERS,"PARAMETERS")).add(parameterDeclarationList_AST));
+ currentAST.root = parameterDeclarationList_AST;
+ currentAST.child = parameterDeclarationList_AST!=null &¶meterDeclarationList_AST.getFirstChild()!=null ?
+ parameterDeclarationList_AST.getFirstChild() : parameterDeclarationList_AST;
+ currentAST.advanceChildToEnd();
+ }
+ parameterDeclarationList_AST = (AST)currentAST.root;
+ returnAST = parameterDeclarationList_AST;
+ }
+
+ public final void declaratorBrackets(
+ AST typ
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST declaratorBrackets_AST = null;
+ Token lb = null;
+ AST lb_AST = null;
+
+ if ( inputState.guessing==0 ) {
+ declaratorBrackets_AST = (AST)currentAST.root;
+ declaratorBrackets_AST=typ;
+ currentAST.root = declaratorBrackets_AST;
+ currentAST.child = declaratorBrackets_AST!=null &&declaratorBrackets_AST.getFirstChild()!=null ?
+ declaratorBrackets_AST.getFirstChild() : declaratorBrackets_AST;
+ currentAST.advanceChildToEnd();
+ }
+ {
+ _loop63:
+ do {
+ if ((LA(1)==LBRACK)) {
+ lb = LT(1);
+ lb_AST = astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lb_AST.setType(ARRAY_DECLARATOR);
+ }
+ match(RBRACK);
+ }
+ else {
+ break _loop63;
+ }
+
+ } while (true);
+ }
+ declaratorBrackets_AST = (AST)currentAST.root;
+ returnAST = declaratorBrackets_AST;
+ }
+
+ public final void throwsClause() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST throwsClause_AST = null;
+
+ AST tmp59_AST = null;
+ tmp59_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp59_AST);
+ match(LITERAL_throws);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop76:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop76;
+ }
+
+ } while (true);
+ }
+ throwsClause_AST = (AST)currentAST.root;
+ returnAST = throwsClause_AST;
+ }
+
+ public final void compoundStatement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST compoundStatement_AST = null;
+ Token lc = null;
+ AST lc_AST = null;
+
+ lc = LT(1);
+ lc_AST = astFactory.create(lc);
+ astFactory.makeASTRoot(currentAST, lc_AST);
+ match(LCURLY);
+ if ( inputState.guessing==0 ) {
+ lc_AST.setType(SLIST);
+ }
+ {
+ _loop86:
+ do {
+ if ((_tokenSet_10.member(LA(1)))) {
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop86;
+ }
+
+ } while (true);
+ }
+ match(RCURLY);
+ compoundStatement_AST = (AST)currentAST.root;
+ returnAST = compoundStatement_AST;
+ }
+
+/** Catch obvious constructor calls, but not the expr.super(...) calls */
+ public final void explicitConstructorInvocation() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST explicitConstructorInvocation_AST = null;
+ Token lp1 = null;
+ AST lp1_AST = null;
+ Token lp2 = null;
+ AST lp2_AST = null;
+
+ switch ( LA(1)) {
+ case LITERAL_this:
+ {
+ match(LITERAL_this);
+ lp1 = LT(1);
+ lp1_AST = astFactory.create(lp1);
+ astFactory.makeASTRoot(currentAST, lp1_AST);
+ match(LPAREN);
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ match(SEMI);
+ if ( inputState.guessing==0 ) {
+ lp1_AST.setType(CTOR_CALL);
+ }
+ explicitConstructorInvocation_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_super:
+ {
+ match(LITERAL_super);
+ lp2 = LT(1);
+ lp2_AST = astFactory.create(lp2);
+ astFactory.makeASTRoot(currentAST, lp2_AST);
+ match(LPAREN);
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ match(SEMI);
+ if ( inputState.guessing==0 ) {
+ lp2_AST.setType(SUPER_CTOR_CALL);
+ }
+ explicitConstructorInvocation_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = explicitConstructorInvocation_AST;
+ }
+
+ public final void statement() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST statement_AST = null;
+ AST m_AST = null;
+ Token c = null;
+ AST c_AST = null;
+ Token s = null;
+ AST s_AST = null;
+
+ switch ( LA(1)) {
+ case LCURLY:
+ {
+ compoundStatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_if:
+ {
+ AST tmp68_AST = null;
+ tmp68_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp68_AST);
+ match(LITERAL_if);
+ match(LPAREN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ if ((LA(1)==LITERAL_else) && (_tokenSet_10.member(LA(2)))) {
+ match(LITERAL_else);
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else if ((_tokenSet_11.member(LA(1))) && (_tokenSet_12.member(LA(2)))) {
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_for:
+ {
+ AST tmp72_AST = null;
+ tmp72_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp72_AST);
+ match(LITERAL_for);
+ match(LPAREN);
+ forInit();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ forCond();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ forIter();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_while:
+ {
+ AST tmp77_AST = null;
+ tmp77_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp77_AST);
+ match(LITERAL_while);
+ match(LPAREN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_do:
+ {
+ AST tmp80_AST = null;
+ tmp80_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp80_AST);
+ match(LITERAL_do);
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(LITERAL_while);
+ match(LPAREN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_break:
+ {
+ AST tmp85_AST = null;
+ tmp85_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp85_AST);
+ match(LITERAL_break);
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ AST tmp86_AST = null;
+ tmp86_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp86_AST);
+ match(IDENT);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_continue:
+ {
+ AST tmp88_AST = null;
+ tmp88_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp88_AST);
+ match(LITERAL_continue);
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ AST tmp89_AST = null;
+ tmp89_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp89_AST);
+ match(IDENT);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_return:
+ {
+ AST tmp91_AST = null;
+ tmp91_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp91_AST);
+ match(LITERAL_return);
+ {
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_switch:
+ {
+ AST tmp93_AST = null;
+ tmp93_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp93_AST);
+ match(LITERAL_switch);
+ match(LPAREN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ match(LCURLY);
+ {
+ _loop95:
+ do {
+ if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default)) {
+ casesGroup();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop95;
+ }
+
+ } while (true);
+ }
+ match(RCURLY);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_try:
+ {
+ tryBlock();
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_throw:
+ {
+ AST tmp98_AST = null;
+ tmp98_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp98_AST);
+ match(LITERAL_throw);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_assert:
+ {
+ AST tmp100_AST = null;
+ tmp100_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp100_AST);
+ match(LITERAL_assert);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case COLON:
+ {
+ match(COLON);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ case SEMI:
+ {
+ s = LT(1);
+ s_AST = astFactory.create(s);
+ astFactory.addASTChild(currentAST, s_AST);
+ match(SEMI);
+ if ( inputState.guessing==0 ) {
+ s_AST.setType(EMPTY_STAT);
+ }
+ statement_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ boolean synPredMatched89 = false;
+ if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
+ int _m89 = mark();
+ synPredMatched89 = true;
+ inputState.guessing++;
+ try {
+ {
+ declaration();
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched89 = false;
+ }
+ rewind(_m89);
+inputState.guessing--;
+ }
+ if ( synPredMatched89 ) {
+ declaration();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ }
+ else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(SEMI);
+ statement_AST = (AST)currentAST.root;
+ }
+ else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_18.member(LA(2)))) {
+ modifiers();
+ m_AST = (AST)returnAST;
+ classDefinition(m_AST);
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ }
+ else if ((LA(1)==IDENT) && (LA(2)==COLON)) {
+ AST tmp105_AST = null;
+ tmp105_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp105_AST);
+ match(IDENT);
+ c = LT(1);
+ c_AST = astFactory.create(c);
+ astFactory.makeASTRoot(currentAST, c_AST);
+ match(COLON);
+ if ( inputState.guessing==0 ) {
+ c_AST.setType(LABELED_STAT);
+ }
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ }
+ else if ((LA(1)==LITERAL_synchronized) && (LA(2)==LPAREN)) {
+ AST tmp106_AST = null;
+ tmp106_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp106_AST);
+ match(LITERAL_synchronized);
+ match(LPAREN);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ compoundStatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ statement_AST = (AST)currentAST.root;
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = statement_AST;
+ }
+
+ public final void argList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST argList_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expressionList();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case RPAREN:
+ {
+ if ( inputState.guessing==0 ) {
+ argList_AST = (AST)currentAST.root;
+ argList_AST = astFactory.create(ELIST,"ELIST");
+ currentAST.root = argList_AST;
+ currentAST.child = argList_AST!=null &&argList_AST.getFirstChild()!=null ?
+ argList_AST.getFirstChild() : argList_AST;
+ currentAST.advanceChildToEnd();
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ argList_AST = (AST)currentAST.root;
+ returnAST = argList_AST;
+ }
+
+/** Declaration of a variable. This can be a class/instance variable,
+ * or a local variable in a method
+ * It can also include possible initialization.
+ */
+ public final void variableDeclarator(
+ AST mods, AST t
+ ) throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST variableDeclarator_AST = null;
+ Token id = null;
+ AST id_AST = null;
+ AST d_AST = null;
+ AST v_AST = null;
+
+ id = LT(1);
+ id_AST = astFactory.create(id);
+ match(IDENT);
+ declaratorBrackets(t);
+ d_AST = (AST)returnAST;
+ varInitializer();
+ v_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ variableDeclarator_AST = (AST)currentAST.root;
+ variableDeclarator_AST = (AST)astFactory.make( (new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,"VARIABLE_DEF")).add(mods).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(d_AST))).add(id_AST).add(v_AST));
+ currentAST.root = variableDeclarator_AST;
+ currentAST.child = variableDeclarator_AST!=null &&variableDeclarator_AST.getFirstChild()!=null ?
+ variableDeclarator_AST.getFirstChild() : variableDeclarator_AST;
+ currentAST.advanceChildToEnd();
+ }
+ returnAST = variableDeclarator_AST;
+ }
+
+ public final void varInitializer() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST varInitializer_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ AST tmp109_AST = null;
+ tmp109_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp109_AST);
+ match(ASSIGN);
+ initializer();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case COMMA:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ varInitializer_AST = (AST)currentAST.root;
+ returnAST = varInitializer_AST;
+ }
+
+ public final void initializer() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST initializer_AST = null;
+
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ initializer_AST = (AST)currentAST.root;
+ break;
+ }
+ case LCURLY:
+ {
+ arrayInitializer();
+ astFactory.addASTChild(currentAST, returnAST);
+ initializer_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = initializer_AST;
+ }
+
+ public final void arrayInitializer() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST arrayInitializer_AST = null;
+ Token lc = null;
+ AST lc_AST = null;
+
+ lc = LT(1);
+ lc_AST = astFactory.create(lc);
+ astFactory.makeASTRoot(currentAST, lc_AST);
+ match(LCURLY);
+ if ( inputState.guessing==0 ) {
+ lc_AST.setType(ARRAY_INIT);
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LCURLY:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ initializer();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop69:
+ do {
+ if ((LA(1)==COMMA) && (_tokenSet_19.member(LA(2)))) {
+ match(COMMA);
+ initializer();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop69;
+ }
+
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case COMMA:
+ {
+ match(COMMA);
+ break;
+ }
+ case RCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case RCURLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(RCURLY);
+ arrayInitializer_AST = (AST)currentAST.root;
+ returnAST = arrayInitializer_AST;
+ }
+
+ public final void expression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST expression_AST = null;
+
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ expression_AST = (AST)currentAST.root;
+ expression_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(EXPR,"EXPR")).add(expression_AST));
+ currentAST.root = expression_AST;
+ currentAST.child = expression_AST!=null &&expression_AST.getFirstChild()!=null ?
+ expression_AST.getFirstChild() : expression_AST;
+ currentAST.advanceChildToEnd();
+ }
+ expression_AST = (AST)currentAST.root;
+ returnAST = expression_AST;
+ }
+
+ public final void parameterDeclaration() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST parameterDeclaration_AST = null;
+ AST pm_AST = null;
+ AST t_AST = null;
+ Token id = null;
+ AST id_AST = null;
+ AST pd_AST = null;
+
+ parameterModifier();
+ pm_AST = (AST)returnAST;
+ typeSpec(false);
+ t_AST = (AST)returnAST;
+ id = LT(1);
+ id_AST = astFactory.create(id);
+ match(IDENT);
+ declaratorBrackets(t_AST);
+ pd_AST = (AST)returnAST;
+ if ( inputState.guessing==0 ) {
+ parameterDeclaration_AST = (AST)currentAST.root;
+ parameterDeclaration_AST = (AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,"PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE,"TYPE")).add(pd_AST))).add(id_AST));
+ currentAST.root = parameterDeclaration_AST;
+ currentAST.child = parameterDeclaration_AST!=null &¶meterDeclaration_AST.getFirstChild()!=null ?
+ parameterDeclaration_AST.getFirstChild() : parameterDeclaration_AST;
+ currentAST.advanceChildToEnd();
+ }
+ returnAST = parameterDeclaration_AST;
+ }
+
+ public final void parameterModifier() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST parameterModifier_AST = null;
+ Token f = null;
+ AST f_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case FINAL:
+ {
+ f = LT(1);
+ f_AST = astFactory.create(f);
+ astFactory.addASTChild(currentAST, f_AST);
+ match(FINAL);
+ break;
+ }
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ parameterModifier_AST = (AST)currentAST.root;
+ parameterModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODIFIERS,"MODIFIERS")).add(f_AST));
+ currentAST.root = parameterModifier_AST;
+ currentAST.child = parameterModifier_AST!=null &¶meterModifier_AST.getFirstChild()!=null ?
+ parameterModifier_AST.getFirstChild() : parameterModifier_AST;
+ currentAST.advanceChildToEnd();
+ }
+ parameterModifier_AST = (AST)currentAST.root;
+ returnAST = parameterModifier_AST;
+ }
+
+ public final void forInit() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST forInit_AST = null;
+
+ {
+ boolean synPredMatched108 = false;
+ if (((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2))))) {
+ int _m108 = mark();
+ synPredMatched108 = true;
+ inputState.guessing++;
+ try {
+ {
+ declaration();
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched108 = false;
+ }
+ rewind(_m108);
+inputState.guessing--;
+ }
+ if ( synPredMatched108 ) {
+ declaration();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_20.member(LA(2)))) {
+ expressionList();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else if ((LA(1)==SEMI)) {
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ if ( inputState.guessing==0 ) {
+ forInit_AST = (AST)currentAST.root;
+ forInit_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_INIT,"FOR_INIT")).add(forInit_AST));
+ currentAST.root = forInit_AST;
+ currentAST.child = forInit_AST!=null &&forInit_AST.getFirstChild()!=null ?
+ forInit_AST.getFirstChild() : forInit_AST;
+ currentAST.advanceChildToEnd();
+ }
+ forInit_AST = (AST)currentAST.root;
+ returnAST = forInit_AST;
+ }
+
+ public final void forCond() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST forCond_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ forCond_AST = (AST)currentAST.root;
+ forCond_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_CONDITION,"FOR_CONDITION")).add(forCond_AST));
+ currentAST.root = forCond_AST;
+ currentAST.child = forCond_AST!=null &&forCond_AST.getFirstChild()!=null ?
+ forCond_AST.getFirstChild() : forCond_AST;
+ currentAST.advanceChildToEnd();
+ }
+ forCond_AST = (AST)currentAST.root;
+ returnAST = forCond_AST;
+ }
+
+ public final void forIter() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST forIter_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expressionList();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ forIter_AST = (AST)currentAST.root;
+ forIter_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,"FOR_ITERATOR")).add(forIter_AST));
+ currentAST.root = forIter_AST;
+ currentAST.child = forIter_AST!=null &&forIter_AST.getFirstChild()!=null ?
+ forIter_AST.getFirstChild() : forIter_AST;
+ currentAST.advanceChildToEnd();
+ }
+ forIter_AST = (AST)currentAST.root;
+ returnAST = forIter_AST;
+ }
+
+ public final void casesGroup() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST casesGroup_AST = null;
+
+ {
+ int _cnt99=0;
+ _loop99:
+ do {
+ if ((LA(1)==LITERAL_case||LA(1)==LITERAL_default) && (_tokenSet_21.member(LA(2)))) {
+ aCase();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ if ( _cnt99>=1 ) { break _loop99; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt99++;
+ } while (true);
+ }
+ caseSList();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ casesGroup_AST = (AST)currentAST.root;
+ casesGroup_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CASE_GROUP,"CASE_GROUP")).add(casesGroup_AST));
+ currentAST.root = casesGroup_AST;
+ currentAST.child = casesGroup_AST!=null &&casesGroup_AST.getFirstChild()!=null ?
+ casesGroup_AST.getFirstChild() : casesGroup_AST;
+ currentAST.advanceChildToEnd();
+ }
+ casesGroup_AST = (AST)currentAST.root;
+ returnAST = casesGroup_AST;
+ }
+
+ public final void tryBlock() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST tryBlock_AST = null;
+
+ AST tmp113_AST = null;
+ tmp113_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp113_AST);
+ match(LITERAL_try);
+ compoundStatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop115:
+ do {
+ if ((LA(1)==LITERAL_catch)) {
+ handler();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop115;
+ }
+
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_finally:
+ {
+ finallyClause();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case FINAL:
+ case ABSTRACT:
+ case STRICTFP:
+ case SEMI:
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LITERAL_private:
+ case LITERAL_public:
+ case LITERAL_protected:
+ case LITERAL_static:
+ case LITERAL_transient:
+ case LITERAL_native:
+ case LITERAL_threadsafe:
+ case LITERAL_synchronized:
+ case LITERAL_volatile:
+ case LITERAL_class:
+ case LCURLY:
+ case RCURLY:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case LITERAL_if:
+ case LITERAL_else:
+ case LITERAL_for:
+ case LITERAL_while:
+ case LITERAL_do:
+ case LITERAL_break:
+ case LITERAL_continue:
+ case LITERAL_return:
+ case LITERAL_switch:
+ case LITERAL_throw:
+ case LITERAL_assert:
+ case LITERAL_case:
+ case LITERAL_default:
+ case LITERAL_try:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ tryBlock_AST = (AST)currentAST.root;
+ returnAST = tryBlock_AST;
+ }
+
+ public final void aCase() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST aCase_AST = null;
+
+ {
+ switch ( LA(1)) {
+ case LITERAL_case:
+ {
+ AST tmp114_AST = null;
+ tmp114_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp114_AST);
+ match(LITERAL_case);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case LITERAL_default:
+ {
+ AST tmp115_AST = null;
+ tmp115_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp115_AST);
+ match(LITERAL_default);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(COLON);
+ aCase_AST = (AST)currentAST.root;
+ returnAST = aCase_AST;
+ }
+
+ public final void caseSList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST caseSList_AST = null;
+
+ {
+ _loop104:
+ do {
+ if ((_tokenSet_10.member(LA(1)))) {
+ statement();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop104;
+ }
+
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ caseSList_AST = (AST)currentAST.root;
+ caseSList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(SLIST,"SLIST")).add(caseSList_AST));
+ currentAST.root = caseSList_AST;
+ currentAST.child = caseSList_AST!=null &&caseSList_AST.getFirstChild()!=null ?
+ caseSList_AST.getFirstChild() : caseSList_AST;
+ currentAST.advanceChildToEnd();
+ }
+ caseSList_AST = (AST)currentAST.root;
+ returnAST = caseSList_AST;
+ }
+
+ public final void expressionList() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST expressionList_AST = null;
+
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop122:
+ do {
+ if ((LA(1)==COMMA)) {
+ match(COMMA);
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop122;
+ }
+
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ expressionList_AST = (AST)currentAST.root;
+ expressionList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ELIST,"ELIST")).add(expressionList_AST));
+ currentAST.root = expressionList_AST;
+ currentAST.child = expressionList_AST!=null &&expressionList_AST.getFirstChild()!=null ?
+ expressionList_AST.getFirstChild() : expressionList_AST;
+ currentAST.advanceChildToEnd();
+ }
+ expressionList_AST = (AST)currentAST.root;
+ returnAST = expressionList_AST;
+ }
+
+ public final void handler() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST handler_AST = null;
+
+ AST tmp118_AST = null;
+ tmp118_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp118_AST);
+ match(LITERAL_catch);
+ match(LPAREN);
+ parameterDeclaration();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ compoundStatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ handler_AST = (AST)currentAST.root;
+ returnAST = handler_AST;
+ }
+
+ public final void finallyClause() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST finallyClause_AST = null;
+
+ AST tmp121_AST = null;
+ tmp121_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp121_AST);
+ match(LITERAL_finally);
+ compoundStatement();
+ astFactory.addASTChild(currentAST, returnAST);
+ finallyClause_AST = (AST)currentAST.root;
+ returnAST = finallyClause_AST;
+ }
+
+ public final void assignmentExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST assignmentExpression_AST = null;
+
+ conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ {
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ AST tmp122_AST = null;
+ tmp122_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp122_AST);
+ match(ASSIGN);
+ break;
+ }
+ case PLUS_ASSIGN:
+ {
+ AST tmp123_AST = null;
+ tmp123_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp123_AST);
+ match(PLUS_ASSIGN);
+ break;
+ }
+ case MINUS_ASSIGN:
+ {
+ AST tmp124_AST = null;
+ tmp124_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp124_AST);
+ match(MINUS_ASSIGN);
+ break;
+ }
+ case STAR_ASSIGN:
+ {
+ AST tmp125_AST = null;
+ tmp125_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp125_AST);
+ match(STAR_ASSIGN);
+ break;
+ }
+ case DIV_ASSIGN:
+ {
+ AST tmp126_AST = null;
+ tmp126_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp126_AST);
+ match(DIV_ASSIGN);
+ break;
+ }
+ case MOD_ASSIGN:
+ {
+ AST tmp127_AST = null;
+ tmp127_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp127_AST);
+ match(MOD_ASSIGN);
+ break;
+ }
+ case SR_ASSIGN:
+ {
+ AST tmp128_AST = null;
+ tmp128_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp128_AST);
+ match(SR_ASSIGN);
+ break;
+ }
+ case BSR_ASSIGN:
+ {
+ AST tmp129_AST = null;
+ tmp129_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp129_AST);
+ match(BSR_ASSIGN);
+ break;
+ }
+ case SL_ASSIGN:
+ {
+ AST tmp130_AST = null;
+ tmp130_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp130_AST);
+ match(SL_ASSIGN);
+ break;
+ }
+ case BAND_ASSIGN:
+ {
+ AST tmp131_AST = null;
+ tmp131_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp131_AST);
+ match(BAND_ASSIGN);
+ break;
+ }
+ case BXOR_ASSIGN:
+ {
+ AST tmp132_AST = null;
+ tmp132_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp132_AST);
+ match(BXOR_ASSIGN);
+ break;
+ }
+ case BOR_ASSIGN:
+ {
+ AST tmp133_AST = null;
+ tmp133_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp133_AST);
+ match(BOR_ASSIGN);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case RBRACK:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case COLON:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ assignmentExpression_AST = (AST)currentAST.root;
+ returnAST = assignmentExpression_AST;
+ }
+
+ public final void conditionalExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST conditionalExpression_AST = null;
+
+ logicalOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case QUESTION:
+ {
+ AST tmp134_AST = null;
+ tmp134_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp134_AST);
+ match(QUESTION);
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(COLON);
+ conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case RBRACK:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ conditionalExpression_AST = (AST)currentAST.root;
+ returnAST = conditionalExpression_AST;
+ }
+
+ public final void logicalOrExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST logicalOrExpression_AST = null;
+
+ logicalAndExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop130:
+ do {
+ if ((LA(1)==LOR)) {
+ AST tmp136_AST = null;
+ tmp136_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp136_AST);
+ match(LOR);
+ logicalAndExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop130;
+ }
+
+ } while (true);
+ }
+ logicalOrExpression_AST = (AST)currentAST.root;
+ returnAST = logicalOrExpression_AST;
+ }
+
+ public final void logicalAndExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST logicalAndExpression_AST = null;
+
+ inclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop133:
+ do {
+ if ((LA(1)==LAND)) {
+ AST tmp137_AST = null;
+ tmp137_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp137_AST);
+ match(LAND);
+ inclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop133;
+ }
+
+ } while (true);
+ }
+ logicalAndExpression_AST = (AST)currentAST.root;
+ returnAST = logicalAndExpression_AST;
+ }
+
+ public final void inclusiveOrExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST inclusiveOrExpression_AST = null;
+
+ exclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop136:
+ do {
+ if ((LA(1)==BOR)) {
+ AST tmp138_AST = null;
+ tmp138_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp138_AST);
+ match(BOR);
+ exclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop136;
+ }
+
+ } while (true);
+ }
+ inclusiveOrExpression_AST = (AST)currentAST.root;
+ returnAST = inclusiveOrExpression_AST;
+ }
+
+ public final void exclusiveOrExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST exclusiveOrExpression_AST = null;
+
+ andExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop139:
+ do {
+ if ((LA(1)==BXOR)) {
+ AST tmp139_AST = null;
+ tmp139_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp139_AST);
+ match(BXOR);
+ andExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop139;
+ }
+
+ } while (true);
+ }
+ exclusiveOrExpression_AST = (AST)currentAST.root;
+ returnAST = exclusiveOrExpression_AST;
+ }
+
+ public final void andExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST andExpression_AST = null;
+
+ equalityExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop142:
+ do {
+ if ((LA(1)==BAND)) {
+ AST tmp140_AST = null;
+ tmp140_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp140_AST);
+ match(BAND);
+ equalityExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop142;
+ }
+
+ } while (true);
+ }
+ andExpression_AST = (AST)currentAST.root;
+ returnAST = andExpression_AST;
+ }
+
+ public final void equalityExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST equalityExpression_AST = null;
+
+ relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop146:
+ do {
+ if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
+ {
+ switch ( LA(1)) {
+ case NOT_EQUAL:
+ {
+ AST tmp141_AST = null;
+ tmp141_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp141_AST);
+ match(NOT_EQUAL);
+ break;
+ }
+ case EQUAL:
+ {
+ AST tmp142_AST = null;
+ tmp142_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp142_AST);
+ match(EQUAL);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop146;
+ }
+
+ } while (true);
+ }
+ equalityExpression_AST = (AST)currentAST.root;
+ returnAST = equalityExpression_AST;
+ }
+
+ public final void relationalExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST relationalExpression_AST = null;
+
+ shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case SEMI:
+ case RBRACK:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ case QUESTION:
+ case LOR:
+ case LAND:
+ case BOR:
+ case BXOR:
+ case BAND:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ {
+ {
+ _loop151:
+ do {
+ if (((LA(1) >= LT && LA(1) <= GE))) {
+ {
+ switch ( LA(1)) {
+ case LT:
+ {
+ AST tmp143_AST = null;
+ tmp143_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp143_AST);
+ match(LT);
+ break;
+ }
+ case GT:
+ {
+ AST tmp144_AST = null;
+ tmp144_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp144_AST);
+ match(GT);
+ break;
+ }
+ case LE:
+ {
+ AST tmp145_AST = null;
+ tmp145_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp145_AST);
+ match(LE);
+ break;
+ }
+ case GE:
+ {
+ AST tmp146_AST = null;
+ tmp146_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp146_AST);
+ match(GE);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop151;
+ }
+
+ } while (true);
+ }
+ break;
+ }
+ case LITERAL_instanceof:
+ {
+ AST tmp147_AST = null;
+ tmp147_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp147_AST);
+ match(LITERAL_instanceof);
+ typeSpec(true);
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ relationalExpression_AST = (AST)currentAST.root;
+ returnAST = relationalExpression_AST;
+ }
+
+ public final void shiftExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST shiftExpression_AST = null;
+
+ additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop155:
+ do {
+ if (((LA(1) >= SL && LA(1) <= BSR))) {
+ {
+ switch ( LA(1)) {
+ case SL:
+ {
+ AST tmp148_AST = null;
+ tmp148_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp148_AST);
+ match(SL);
+ break;
+ }
+ case SR:
+ {
+ AST tmp149_AST = null;
+ tmp149_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp149_AST);
+ match(SR);
+ break;
+ }
+ case BSR:
+ {
+ AST tmp150_AST = null;
+ tmp150_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp150_AST);
+ match(BSR);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop155;
+ }
+
+ } while (true);
+ }
+ shiftExpression_AST = (AST)currentAST.root;
+ returnAST = shiftExpression_AST;
+ }
+
+ public final void additiveExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST additiveExpression_AST = null;
+
+ multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop159:
+ do {
+ if ((LA(1)==PLUS||LA(1)==MINUS)) {
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ AST tmp151_AST = null;
+ tmp151_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp151_AST);
+ match(PLUS);
+ break;
+ }
+ case MINUS:
+ {
+ AST tmp152_AST = null;
+ tmp152_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp152_AST);
+ match(MINUS);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop159;
+ }
+
+ } while (true);
+ }
+ additiveExpression_AST = (AST)currentAST.root;
+ returnAST = additiveExpression_AST;
+ }
+
+ public final void multiplicativeExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST multiplicativeExpression_AST = null;
+
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop163:
+ do {
+ if ((_tokenSet_22.member(LA(1)))) {
+ {
+ switch ( LA(1)) {
+ case STAR:
+ {
+ AST tmp153_AST = null;
+ tmp153_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp153_AST);
+ match(STAR);
+ break;
+ }
+ case DIV:
+ {
+ AST tmp154_AST = null;
+ tmp154_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp154_AST);
+ match(DIV);
+ break;
+ }
+ case MOD:
+ {
+ AST tmp155_AST = null;
+ tmp155_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp155_AST);
+ match(MOD);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ break _loop163;
+ }
+
+ } while (true);
+ }
+ multiplicativeExpression_AST = (AST)currentAST.root;
+ returnAST = multiplicativeExpression_AST;
+ }
+
+ public final void unaryExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST unaryExpression_AST = null;
+
+ switch ( LA(1)) {
+ case INC:
+ {
+ AST tmp156_AST = null;
+ tmp156_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp156_AST);
+ match(INC);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case DEC:
+ {
+ AST tmp157_AST = null;
+ tmp157_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp157_AST);
+ match(DEC);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case MINUS:
+ {
+ AST tmp158_AST = null;
+ tmp158_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp158_AST);
+ match(MINUS);
+ if ( inputState.guessing==0 ) {
+ tmp158_AST.setType(UNARY_MINUS);
+ }
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case PLUS:
+ {
+ AST tmp159_AST = null;
+ tmp159_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp159_AST);
+ match(PLUS);
+ if ( inputState.guessing==0 ) {
+ tmp159_AST.setType(UNARY_PLUS);
+ }
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ unaryExpressionNotPlusMinus();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = unaryExpression_AST;
+ }
+
+ public final void unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST unaryExpressionNotPlusMinus_AST = null;
+ Token lpb = null;
+ AST lpb_AST = null;
+ Token lp = null;
+ AST lp_AST = null;
+
+ switch ( LA(1)) {
+ case BNOT:
+ {
+ AST tmp160_AST = null;
+ tmp160_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp160_AST);
+ match(BNOT);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ break;
+ }
+ case LNOT:
+ {
+ AST tmp161_AST = null;
+ tmp161_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp161_AST);
+ match(LNOT);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ {
+ if ((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_double))) {
+ lpb = LT(1);
+ lpb_AST = astFactory.create(lpb);
+ astFactory.makeASTRoot(currentAST, lpb_AST);
+ match(LPAREN);
+ if ( inputState.guessing==0 ) {
+ lpb_AST.setType(TYPECAST);
+ }
+ builtInTypeSpec(true);
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ boolean synPredMatched168 = false;
+ if (((LA(1)==LPAREN) && (LA(2)==IDENT))) {
+ int _m168 = mark();
+ synPredMatched168 = true;
+ inputState.guessing++;
+ try {
+ {
+ match(LPAREN);
+ classTypeSpec(true);
+ match(RPAREN);
+ unaryExpressionNotPlusMinus();
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched168 = false;
+ }
+ rewind(_m168);
+inputState.guessing--;
+ }
+ if ( synPredMatched168 ) {
+ lp = LT(1);
+ lp_AST = astFactory.create(lp);
+ astFactory.makeASTRoot(currentAST, lp_AST);
+ match(LPAREN);
+ if ( inputState.guessing==0 ) {
+ lp_AST.setType(TYPECAST);
+ }
+ classTypeSpec(true);
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ unaryExpressionNotPlusMinus();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else if ((_tokenSet_23.member(LA(1))) && (_tokenSet_24.member(LA(2)))) {
+ postfixExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = unaryExpressionNotPlusMinus_AST;
+ }
+
+ public final void postfixExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST postfixExpression_AST = null;
+ Token lp = null;
+ AST lp_AST = null;
+ Token lp3 = null;
+ AST lp3_AST = null;
+ Token lps = null;
+ AST lps_AST = null;
+ Token lb = null;
+ AST lb_AST = null;
+ Token in = null;
+ AST in_AST = null;
+ Token de = null;
+ AST de_AST = null;
+
+ primaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop174:
+ do {
+ if ((LA(1)==DOT) && (LA(2)==IDENT)) {
+ AST tmp164_AST = null;
+ tmp164_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp164_AST);
+ match(DOT);
+ AST tmp165_AST = null;
+ tmp165_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp165_AST);
+ match(IDENT);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ lp = LT(1);
+ lp_AST = astFactory.create(lp);
+ astFactory.makeASTRoot(currentAST, lp_AST);
+ match(LPAREN);
+ if ( inputState.guessing==0 ) {
+ lp_AST.setType(METHOD_CALL);
+ }
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ break;
+ }
+ case SEMI:
+ case LBRACK:
+ case RBRACK:
+ case DOT:
+ case STAR:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ case QUESTION:
+ case LOR:
+ case LAND:
+ case BOR:
+ case BXOR:
+ case BAND:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case LITERAL_instanceof:
+ case SL:
+ case SR:
+ case BSR:
+ case PLUS:
+ case MINUS:
+ case DIV:
+ case MOD:
+ case INC:
+ case DEC:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else if ((LA(1)==DOT) && (LA(2)==LITERAL_this)) {
+ AST tmp167_AST = null;
+ tmp167_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp167_AST);
+ match(DOT);
+ AST tmp168_AST = null;
+ tmp168_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp168_AST);
+ match(LITERAL_this);
+ }
+ else if ((LA(1)==DOT) && (LA(2)==LITERAL_super)) {
+ AST tmp169_AST = null;
+ tmp169_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp169_AST);
+ match(DOT);
+ AST tmp170_AST = null;
+ tmp170_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp170_AST);
+ match(LITERAL_super);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ lp3 = LT(1);
+ lp3_AST = astFactory.create(lp3);
+ astFactory.makeASTRoot(currentAST, lp3_AST);
+ match(LPAREN);
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ if ( inputState.guessing==0 ) {
+ lp3_AST.setType(SUPER_CTOR_CALL);
+ }
+ break;
+ }
+ case DOT:
+ {
+ AST tmp172_AST = null;
+ tmp172_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp172_AST);
+ match(DOT);
+ AST tmp173_AST = null;
+ tmp173_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp173_AST);
+ match(IDENT);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ lps = LT(1);
+ lps_AST = astFactory.create(lps);
+ astFactory.makeASTRoot(currentAST, lps_AST);
+ match(LPAREN);
+ if ( inputState.guessing==0 ) {
+ lps_AST.setType(METHOD_CALL);
+ }
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ break;
+ }
+ case SEMI:
+ case LBRACK:
+ case RBRACK:
+ case DOT:
+ case STAR:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ case QUESTION:
+ case LOR:
+ case LAND:
+ case BOR:
+ case BXOR:
+ case BAND:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case LITERAL_instanceof:
+ case SL:
+ case SR:
+ case BSR:
+ case PLUS:
+ case MINUS:
+ case DIV:
+ case MOD:
+ case INC:
+ case DEC:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else if ((LA(1)==DOT) && (LA(2)==LITERAL_new)) {
+ AST tmp175_AST = null;
+ tmp175_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp175_AST);
+ match(DOT);
+ newExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ }
+ else if ((LA(1)==LBRACK)) {
+ lb = LT(1);
+ lb_AST = astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lb_AST.setType(INDEX_OP);
+ }
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RBRACK);
+ }
+ else {
+ break _loop174;
+ }
+
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case INC:
+ {
+ in = LT(1);
+ in_AST = astFactory.create(in);
+ astFactory.makeASTRoot(currentAST, in_AST);
+ match(INC);
+ if ( inputState.guessing==0 ) {
+ in_AST.setType(POST_INC);
+ }
+ break;
+ }
+ case DEC:
+ {
+ de = LT(1);
+ de_AST = astFactory.create(de);
+ astFactory.makeASTRoot(currentAST, de_AST);
+ match(DEC);
+ if ( inputState.guessing==0 ) {
+ de_AST.setType(POST_DEC);
+ }
+ break;
+ }
+ case SEMI:
+ case RBRACK:
+ case STAR:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ case QUESTION:
+ case LOR:
+ case LAND:
+ case BOR:
+ case BXOR:
+ case BAND:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case LITERAL_instanceof:
+ case SL:
+ case SR:
+ case BSR:
+ case PLUS:
+ case MINUS:
+ case DIV:
+ case MOD:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ postfixExpression_AST = (AST)currentAST.root;
+ returnAST = postfixExpression_AST;
+ }
+
+ public final void primaryExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST primaryExpression_AST = null;
+ Token lbt = null;
+ AST lbt_AST = null;
+
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ identPrimary();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ if ((LA(1)==DOT) && (LA(2)==LITERAL_class)) {
+ AST tmp177_AST = null;
+ tmp177_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp177_AST);
+ match(DOT);
+ AST tmp178_AST = null;
+ tmp178_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp178_AST);
+ match(LITERAL_class);
+ }
+ else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ constant();
+ astFactory.addASTChild(currentAST, returnAST);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_true:
+ {
+ AST tmp179_AST = null;
+ tmp179_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp179_AST);
+ match(LITERAL_true);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_false:
+ {
+ AST tmp180_AST = null;
+ tmp180_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp180_AST);
+ match(LITERAL_false);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_null:
+ {
+ AST tmp181_AST = null;
+ tmp181_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp181_AST);
+ match(LITERAL_null);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_new:
+ {
+ newExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_this:
+ {
+ AST tmp182_AST = null;
+ tmp182_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp182_AST);
+ match(LITERAL_this);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_super:
+ {
+ AST tmp183_AST = null;
+ tmp183_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp183_AST);
+ match(LITERAL_super);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LPAREN:
+ {
+ match(LPAREN);
+ assignmentExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ {
+ builtInType();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop179:
+ do {
+ if ((LA(1)==LBRACK)) {
+ lbt = LT(1);
+ lbt_AST = astFactory.create(lbt);
+ astFactory.makeASTRoot(currentAST, lbt_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lbt_AST.setType(ARRAY_DECLARATOR);
+ }
+ match(RBRACK);
+ }
+ else {
+ break _loop179;
+ }
+
+ } while (true);
+ }
+ AST tmp187_AST = null;
+ tmp187_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp187_AST);
+ match(DOT);
+ AST tmp188_AST = null;
+ tmp188_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp188_AST);
+ match(LITERAL_class);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = primaryExpression_AST;
+ }
+
+/** object instantiation.
+ * Trees are built as illustrated by the following input/tree pairs:
+ *
+ * new T()
+ *
+ * new
+ * |
+ * T -- ELIST
+ * |
+ * arg1 -- arg2 -- .. -- argn
+ *
+ * new int[]
+ *
+ * new
+ * |
+ * int -- ARRAY_DECLARATOR
+ *
+ * new int[] {1,2}
+ *
+ * new
+ * |
+ * int -- ARRAY_DECLARATOR -- ARRAY_INIT
+ * |
+ * EXPR -- EXPR
+ * | |
+ * 1 2
+ *
+ * new int[3]
+ * new
+ * |
+ * int -- ARRAY_DECLARATOR
+ * |
+ * EXPR
+ * |
+ * 3
+ *
+ * new int[1][2]
+ *
+ * new
+ * |
+ * int -- ARRAY_DECLARATOR
+ * |
+ * ARRAY_DECLARATOR -- EXPR
+ * | |
+ * EXPR 1
+ * |
+ * 2
+ *
+ */
+ public final void newExpression() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST newExpression_AST = null;
+
+ AST tmp189_AST = null;
+ tmp189_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp189_AST);
+ match(LITERAL_new);
+ type();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ {
+ switch ( LA(1)) {
+ case LCURLY:
+ {
+ classBlock();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case LBRACK:
+ case RBRACK:
+ case DOT:
+ case STAR:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ case QUESTION:
+ case LOR:
+ case LAND:
+ case BOR:
+ case BXOR:
+ case BAND:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case LITERAL_instanceof:
+ case SL:
+ case SR:
+ case BSR:
+ case PLUS:
+ case MINUS:
+ case DIV:
+ case MOD:
+ case INC:
+ case DEC:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case LBRACK:
+ {
+ newArrayDeclarator();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case LCURLY:
+ {
+ arrayInitializer();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case SEMI:
+ case LBRACK:
+ case RBRACK:
+ case DOT:
+ case STAR:
+ case RCURLY:
+ case COMMA:
+ case RPAREN:
+ case ASSIGN:
+ case COLON:
+ case PLUS_ASSIGN:
+ case MINUS_ASSIGN:
+ case STAR_ASSIGN:
+ case DIV_ASSIGN:
+ case MOD_ASSIGN:
+ case SR_ASSIGN:
+ case BSR_ASSIGN:
+ case SL_ASSIGN:
+ case BAND_ASSIGN:
+ case BXOR_ASSIGN:
+ case BOR_ASSIGN:
+ case QUESTION:
+ case LOR:
+ case LAND:
+ case BOR:
+ case BXOR:
+ case BAND:
+ case NOT_EQUAL:
+ case EQUAL:
+ case LT:
+ case GT:
+ case LE:
+ case GE:
+ case LITERAL_instanceof:
+ case SL:
+ case SR:
+ case BSR:
+ case PLUS:
+ case MINUS:
+ case DIV:
+ case MOD:
+ case INC:
+ case DEC:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ newExpression_AST = (AST)currentAST.root;
+ returnAST = newExpression_AST;
+ }
+
+/** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
+ * and a.b.c.class refs. Also this(...) and super(...). Match
+ * this or super.
+ */
+ public final void identPrimary() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST identPrimary_AST = null;
+ Token lp = null;
+ AST lp_AST = null;
+ Token lbc = null;
+ AST lbc_AST = null;
+
+ AST tmp192_AST = null;
+ tmp192_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp192_AST);
+ match(IDENT);
+ {
+ _loop182:
+ do {
+ if ((LA(1)==DOT) && (LA(2)==IDENT)) {
+ AST tmp193_AST = null;
+ tmp193_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp193_AST);
+ match(DOT);
+ AST tmp194_AST = null;
+ tmp194_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp194_AST);
+ match(IDENT);
+ }
+ else {
+ break _loop182;
+ }
+
+ } while (true);
+ }
+ {
+ if ((LA(1)==LPAREN)) {
+ {
+ lp = LT(1);
+ lp_AST = astFactory.create(lp);
+ astFactory.makeASTRoot(currentAST, lp_AST);
+ match(LPAREN);
+ if ( inputState.guessing==0 ) {
+ lp_AST.setType(METHOD_CALL);
+ }
+ argList();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ }
+ }
+ else if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
+ {
+ int _cnt186=0;
+ _loop186:
+ do {
+ if ((LA(1)==LBRACK) && (LA(2)==RBRACK)) {
+ lbc = LT(1);
+ lbc_AST = astFactory.create(lbc);
+ astFactory.makeASTRoot(currentAST, lbc_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lbc_AST.setType(ARRAY_DECLARATOR);
+ }
+ match(RBRACK);
+ }
+ else {
+ if ( _cnt186>=1 ) { break _loop186; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt186++;
+ } while (true);
+ }
+ }
+ else if ((_tokenSet_25.member(LA(1))) && (_tokenSet_26.member(LA(2)))) {
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ identPrimary_AST = (AST)currentAST.root;
+ returnAST = identPrimary_AST;
+ }
+
+ public final void constant() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST constant_AST = null;
+
+ switch ( LA(1)) {
+ case NUM_INT:
+ {
+ AST tmp197_AST = null;
+ tmp197_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp197_AST);
+ match(NUM_INT);
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case CHAR_LITERAL:
+ {
+ AST tmp198_AST = null;
+ tmp198_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp198_AST);
+ match(CHAR_LITERAL);
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case STRING_LITERAL:
+ {
+ AST tmp199_AST = null;
+ tmp199_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp199_AST);
+ match(STRING_LITERAL);
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_FLOAT:
+ {
+ AST tmp200_AST = null;
+ tmp200_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp200_AST);
+ match(NUM_FLOAT);
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_LONG:
+ {
+ AST tmp201_AST = null;
+ tmp201_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp201_AST);
+ match(NUM_LONG);
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_DOUBLE:
+ {
+ AST tmp202_AST = null;
+ tmp202_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp202_AST);
+ match(NUM_DOUBLE);
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = constant_AST;
+ }
+
+ public final void newArrayDeclarator() throws RecognitionException, TokenStreamException {
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST newArrayDeclarator_AST = null;
+ Token lb = null;
+ AST lb_AST = null;
+
+ {
+ int _cnt196=0;
+ _loop196:
+ do {
+ if ((LA(1)==LBRACK) && (_tokenSet_27.member(LA(2)))) {
+ lb = LT(1);
+ lb_AST = astFactory.create(lb);
+ astFactory.makeASTRoot(currentAST, lb_AST);
+ match(LBRACK);
+ if ( inputState.guessing==0 ) {
+ lb_AST.setType(ARRAY_DECLARATOR);
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_void:
+ case LITERAL_boolean:
+ case LITERAL_byte:
+ case LITERAL_char:
+ case LITERAL_short:
+ case LITERAL_int:
+ case LITERAL_float:
+ case LITERAL_long:
+ case LITERAL_double:
+ case IDENT:
+ case LPAREN:
+ case LITERAL_this:
+ case LITERAL_super:
+ case PLUS:
+ case MINUS:
+ case INC:
+ case DEC:
+ case BNOT:
+ case LNOT:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case LITERAL_new:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ expression();
+ astFactory.addASTChild(currentAST, returnAST);
+ break;
+ }
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(RBRACK);
+ }
+ else {
+ if ( _cnt196>=1 ) { break _loop196; } else {throw new NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt196++;
+ } while (true);
+ }
+ newArrayDeclarator_AST = (AST)currentAST.root;
+ returnAST = newArrayDeclarator_AST;
+ }
+
+
+ public static final String[] _tokenNames = {
+ "<0>",
+ "EOF",
+ "<2>",
+ "NULL_TREE_LOOKAHEAD",
+ "BLOCK",
+ "MODIFIERS",
+ "OBJBLOCK",
+ "SLIST",
+ "CTOR_DEF",
+ "METHOD_DEF",
+ "VARIABLE_DEF",
+ "INSTANCE_INIT",
+ "STATIC_INIT",
+ "TYPE",
+ "CLASS_DEF",
+ "INTERFACE_DEF",
+ "PACKAGE_DEF",
+ "ARRAY_DECLARATOR",
+ "EXTENDS_CLAUSE",
+ "IMPLEMENTS_CLAUSE",
+ "PARAMETERS",
+ "PARAMETER_DEF",
+ "LABELED_STAT",
+ "TYPECAST",
+ "INDEX_OP",
+ "POST_INC",
+ "POST_DEC",
+ "METHOD_CALL",
+ "EXPR",
+ "ARRAY_INIT",
+ "IMPORT",
+ "UNARY_MINUS",
+ "UNARY_PLUS",
+ "CASE_GROUP",
+ "ELIST",
+ "FOR_INIT",
+ "FOR_CONDITION",
+ "FOR_ITERATOR",
+ "EMPTY_STAT",
+ "\"final\"",
+ "\"abstract\"",
+ "\"strictfp\"",
+ "SUPER_CTOR_CALL",
+ "CTOR_CALL",
+ "\"package\"",
+ "SEMI",
+ "\"import\"",
+ "LBRACK",
+ "RBRACK",
+ "\"void\"",
+ "\"boolean\"",
+ "\"byte\"",
+ "\"char\"",
+ "\"short\"",
+ "\"int\"",
+ "\"float\"",
+ "\"long\"",
+ "\"double\"",
+ "IDENT",
+ "DOT",
+ "STAR",
+ "\"private\"",
+ "\"public\"",
+ "\"protected\"",
+ "\"static\"",
+ "\"transient\"",
+ "\"native\"",
+ "\"threadsafe\"",
+ "\"synchronized\"",
+ "\"volatile\"",
+ "\"class\"",
+ "\"extends\"",
+ "\"interface\"",
+ "LCURLY",
+ "RCURLY",
+ "COMMA",
+ "\"implements\"",
+ "LPAREN",
+ "RPAREN",
+ "\"this\"",
+ "\"super\"",
+ "ASSIGN",
+ "\"throws\"",
+ "COLON",
+ "\"if\"",
+ "\"else\"",
+ "\"for\"",
+ "\"while\"",
+ "\"do\"",
+ "\"break\"",
+ "\"continue\"",
+ "\"return\"",
+ "\"switch\"",
+ "\"throw\"",
+ "\"assert\"",
+ "\"case\"",
+ "\"default\"",
+ "\"try\"",
+ "\"finally\"",
+ "\"catch\"",
+ "PLUS_ASSIGN",
+ "MINUS_ASSIGN",
+ "STAR_ASSIGN",
+ "DIV_ASSIGN",
+ "MOD_ASSIGN",
+ "SR_ASSIGN",
+ "BSR_ASSIGN",
+ "SL_ASSIGN",
+ "BAND_ASSIGN",
+ "BXOR_ASSIGN",
+ "BOR_ASSIGN",
+ "QUESTION",
+ "LOR",
+ "LAND",
+ "BOR",
+ "BXOR",
+ "BAND",
+ "NOT_EQUAL",
+ "EQUAL",
+ "LT",
+ "GT",
+ "LE",
+ "GE",
+ "\"instanceof\"",
+ "SL",
+ "SR",
+ "BSR",
+ "PLUS",
+ "MINUS",
+ "DIV",
+ "MOD",
+ "INC",
+ "DEC",
+ "BNOT",
+ "LNOT",
+ "\"true\"",
+ "\"false\"",
+ "\"null\"",
+ "\"new\"",
+ "NUM_INT",
+ "CHAR_LITERAL",
+ "STRING_LITERAL",
+ "NUM_FLOAT",
+ "NUM_LONG",
+ "NUM_DOUBLE",
+ "WS",
+ "SL_COMMENT",
+ "ML_COMMENT",
+ "ESC",
+ "HEX_DIGIT",
+ "VOCAB",
+ "EXPONENT",
+ "FLOAT_SUFFIX"
+ };
+
+ protected void buildTokenTypeASTClassMap() {
+ tokenTypeToASTClassMap=null;
+ };
+
+ private static final long[] mk_tokenSet_0() {
+ long[] data = { -2305803976550907904L, 383L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
+ private static final long[] mk_tokenSet_1() {
+ long[] data = { -2305733607806730238L, 383L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
+ private static final long[] mk_tokenSet_2() {
+ long[] data = { -2305803976550907902L, 383L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
+ private static final long[] mk_tokenSet_3() {
+ long[] data = { -2305839160922996736L, 63L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
+ private static final long[] mk_tokenSet_4() {
+ long[] data = { -1729941358572994560L, 383L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
+ private static final long[] mk_tokenSet_5() {
+ long[] data = { -1153339868781215744L, 8575L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
+ private static final long[] mk_tokenSet_6() {
+ long[] data = { 864831865943490560L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
+ private static final long[] mk_tokenSet_7() {
+ long[] data = { 175921860444160L, 133120L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
+ private static final long[] mk_tokenSet_8() {
+ long[] data = { -1729906174200905728L, -9223372026120395137L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
+ private static final long[] mk_tokenSet_9() {
+ long[] data = { -383179802279936L, -57984440449L, 131071L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
+ private static final long[] mk_tokenSet_10() {
+ long[] data = { -1729906174200905728L, -9223372026120396161L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
+ private static final long[] mk_tokenSet_11() {
+ long[] data = { -1729906174200905728L, -9223372019675847041L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
+ private static final long[] mk_tokenSet_12() {
+ long[] data = { -383179802279936L, -284801L, 131071L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
+ private static final long[] mk_tokenSet_13() {
+ long[] data = { -1729941358572994560L, 63L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
+ private static final long[] mk_tokenSet_14() {
+ long[] data = { -1153339868781215744L, 63L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
+ private static final long[] mk_tokenSet_15() {
+ long[] data = { 575897802350002176L, -9223372036854669312L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
+ private static final long[] mk_tokenSet_16() {
+ long[] data = { 2305455981120716800L, -68719239168L, 131071L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
+ private static final long[] mk_tokenSet_17() {
+ long[] data = { -2305839160922996736L, 127L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
+ private static final long[] mk_tokenSet_18() {
+ long[] data = { -2017608784771284992L, 127L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
+ private static final long[] mk_tokenSet_19() {
+ long[] data = { 575897802350002176L, -9223372036854668800L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
+ private static final long[] mk_tokenSet_20() {
+ long[] data = { 2305455981120716800L, -68719237120L, 131071L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
+ private static final long[] mk_tokenSet_21() {
+ long[] data = { 575897802350002176L, -9223372036854145024L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
+ private static final long[] mk_tokenSet_22() {
+ long[] data = { 1152921504606846976L, 0L, 6L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
+ private static final long[] mk_tokenSet_23() {
+ long[] data = { 575897802350002176L, 106496L, 130944L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
+ private static final long[] mk_tokenSet_24() {
+ long[] data = { 2305737456097427456L, -68718695424L, 131071L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
+ private static final long[] mk_tokenSet_25() {
+ long[] data = { 1729839653747425280L, -68718801920L, 31L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
+ private static final long[] mk_tokenSet_26() {
+ long[] data = { -101704825569280L, -51539873921L, 131071L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
+ private static final long[] mk_tokenSet_27() {
+ long[] data = { 576179277326712832L, -9223372036854669312L, 131065L, 0L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
+
+ }
diff --git a/app/src/processing/app/Editor.java b/app/src/processing/app/Editor.java
index 62baeb1c5..4c9ddeea5 100644
--- a/app/src/processing/app/Editor.java
+++ b/app/src/processing/app/Editor.java
@@ -1026,7 +1026,7 @@ public class Editor extends JFrame {
/**
* Show the About box.
*/
- static public void handleAbout() {
+ public void handleAbout() {
final Image image = Base.getImage("about.jpg", this);
final Window window = new Window(this) {
public void paint(Graphics g) {
@@ -1046,18 +1046,18 @@ public class Editor extends JFrame {
window.dispose();
}
});
- int w = image.getWidth(window);
- int h = image.getHeight(window);
+ int w = image.getWidth(this);
+ int h = image.getHeight(this);
Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
window.setBounds((screen.width-w)/2, (screen.height-h)/2, w, h);
- window.show();
+ window.setVisible(true);
}
/**
* Show the preferences window.
*/
- static public void handlePrefs() {
+ public void handlePrefs() {
Preferences preferences = new Preferences();
preferences.showFrame(this);