summaryrefslogtreecommitdiff
path: root/libjava/classpath/tools/generated
diff options
context:
space:
mode:
authorupstream source tree <ports@midipix.org>2015-03-15 20:14:05 -0400
committerupstream source tree <ports@midipix.org>2015-03-15 20:14:05 -0400
commit554fd8c5195424bdbcabf5de30fdc183aba391bd (patch)
tree976dc5ab7fddf506dadce60ae936f43f58787092 /libjava/classpath/tools/generated
downloadcbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.bz2
cbb-gcc-4.6.4-554fd8c5195424bdbcabf5de30fdc183aba391bd.tar.xz
obtained gcc-4.6.4.tar.bz2 from upstream website;upstream
verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository.
Diffstat (limited to 'libjava/classpath/tools/generated')
-rw-r--r--libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.java1962
-rw-r--r--libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.smap1280
-rw-r--r--libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java1406
-rw-r--r--libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.smap987
-rw-r--r--libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.java122
-rw-r--r--libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.txt116
6 files changed, 5873 insertions, 0 deletions
diff --git a/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.java b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.java
new file mode 100644
index 000000000..58d7b3f8a
--- /dev/null
+++ b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.java
@@ -0,0 +1,1962 @@
+// $ANTLR 2.7.7 (20080530): "java-expression.g" -> "JavaLexer.java"$
+
+ package gnu.classpath.tools.gjdoc.expr;
+
+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("String", this), new Integer(55));
+ literals.put(new ANTLRHashString("final", this), new Integer(39));
+ literals.put(new ANTLRHashString("false", this), new Integer(84));
+ literals.put(new ANTLRHashString("true", this), new Integer(83));
+ literals.put(new ANTLRHashString("void", this), new Integer(46));
+ literals.put(new ANTLRHashString("float", this), new Integer(52));
+ literals.put(new ANTLRHashString("boolean", this), new Integer(47));
+ literals.put(new ANTLRHashString("long", this), new Integer(53));
+ literals.put(new ANTLRHashString("null", this), new Integer(85));
+ literals.put(new ANTLRHashString("short", this), new Integer(50));
+ literals.put(new ANTLRHashString("char", this), new Integer(49));
+ literals.put(new ANTLRHashString("abstract", this), new Integer(40));
+ literals.put(new ANTLRHashString("byte", this), new Integer(48));
+ literals.put(new ANTLRHashString("int", this), new Integer(51));
+ literals.put(new ANTLRHashString("double", this), new Integer(54));
+ literals.put(new ANTLRHashString("strictfp", this), new Integer(41));
+}
+
+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_COMMIT(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 _cnt105=0;
+ _loop105:
+ 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());
+ }
+
+ }
+ if ( inputState.guessing==0 ) {
+ newline();
+ }
+ break;
+ }
+ default:
+ {
+ if ( _cnt105>=1 ) { break _loop105; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+ }
+ _cnt105++;
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ _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_COMMIT(boolean _createToken) throws RecognitionException, CharStreamException, TokenStreamException {
+ int _ttype; Token _token=null; int _begin=text.length();
+ _ttype = SL_COMMIT;
+ int _saveIndex;
+
+ match("//");
+ {
+ _loop109:
+ do {
+ if ((_tokenSet_0.member(LA(1)))) {
+ {
+ match(_tokenSet_0);
+ }
+ }
+ else {
+ break _loop109;
+ }
+
+ } 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());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ _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("/*");
+ {
+ _loop115:
+ do {
+ if ((LA(1)=='\r') && (LA(2)=='\n') && ((LA(3) >= '\u0003' && LA(3) <= '\uffff')) && ((LA(4) >= '\u0003' && LA(4) <= '\uffff'))) {
+ match('\r');
+ match('\n');
+ if ( inputState.guessing==0 ) {
+ 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');
+ if ( inputState.guessing==0 ) {
+ newline();
+ }
+ }
+ else if ((LA(1)=='\n')) {
+ match('\n');
+ if ( inputState.guessing==0 ) {
+ newline();
+ }
+ }
+ else if ((_tokenSet_1.member(LA(1)))) {
+ {
+ match(_tokenSet_1);
+ }
+ }
+ else {
+ break _loop115;
+ }
+
+ } while (true);
+ }
+ match("*/");
+ if ( inputState.guessing==0 ) {
+ _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)))) {
+ {
+ match(_tokenSet_2);
+ }
+ }
+ 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 _cnt126=0;
+ _loop126:
+ do {
+ if ((LA(1)=='u')) {
+ match('u');
+ }
+ else {
+ if ( _cnt126>=1 ) { break _loop126; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt126++;
+ } 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')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
+ matchRange('0','7');
+ {
+ if (((LA(1) >= '0' && LA(1) <= '7')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
+ matchRange('0','7');
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true)) {
+ }
+ else {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (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')) && (_tokenSet_0.member(LA(2))) && (true) && (true)) {
+ matchRange('0','7');
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (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('"');
+ {
+ _loop122:
+ do {
+ if ((LA(1)=='\\')) {
+ mESC(false);
+ }
+ else if ((_tokenSet_3.member(LA(1)))) {
+ {
+ match(_tokenSet_3);
+ }
+ }
+ else {
+ break _loop122;
+ }
+
+ } 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());
+ }
+ }
+ }
+ {
+ _loop136:
+ 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 _loop136;
+ }
+ }
+ } 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('.');
+ if ( inputState.guessing==0 ) {
+ _ttype = DOT;
+ }
+ {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ {
+ int _cnt140=0;
+ _loop140:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt140>=1 ) { break _loop140; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt140++;
+ } 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;
+ if ( inputState.guessing==0 ) {
+ t=f1;
+ }
+ }
+ else {
+ }
+
+ }
+ if ( inputState.guessing==0 ) {
+
+ 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');
+ if ( inputState.guessing==0 ) {
+ isDecimal = true;
+ }
+ {
+ if ((LA(1)=='X'||LA(1)=='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 _cnt147=0;
+ _loop147:
+ do {
+ if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
+ mHEX_DIGIT(false);
+ }
+ else {
+ if ( _cnt147>=1 ) { break _loop147; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt147++;
+ } while (true);
+ }
+ }
+ else {
+ boolean synPredMatched152 = false;
+ if ((((LA(1) >= '0' && LA(1) <= '9')) && (true) && (true) && (true))) {
+ int _m152 = mark();
+ synPredMatched152 = true;
+ inputState.guessing++;
+ try {
+ {
+ {
+ int _cnt150=0;
+ _loop150:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt150>=1 ) { break _loop150; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt150++;
+ } while (true);
+ }
+ {
+ switch ( LA(1)) {
+ case '.':
+ {
+ match('.');
+ break;
+ }
+ case 'E': case 'e':
+ {
+ mEXPONENT(false);
+ break;
+ }
+ case 'D': case 'F': case 'd': case 'f':
+ {
+ mFLOAT_SUFFIX(false);
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched152 = false;
+ }
+ rewind(_m152);
+inputState.guessing--;
+ }
+ if ( synPredMatched152 ) {
+ {
+ int _cnt154=0;
+ _loop154:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt154>=1 ) { break _loop154; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt154++;
+ } while (true);
+ }
+ }
+ else if (((LA(1) >= '0' && LA(1) <= '7')) && (true) && (true) && (true)) {
+ {
+ int _cnt156=0;
+ _loop156:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '7'))) {
+ matchRange('0','7');
+ }
+ else {
+ if ( _cnt156>=1 ) { break _loop156; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt156++;
+ } while (true);
+ }
+ }
+ else {
+ }
+ }
+ }
+ break;
+ }
+ case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8':
+ case '9':
+ {
+ {
+ matchRange('1','9');
+ }
+ {
+ _loop159:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ break _loop159;
+ }
+
+ } while (true);
+ }
+ if ( inputState.guessing==0 ) {
+ 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());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+ _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('.');
+ {
+ _loop164:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ break _loop164;
+ }
+
+ } 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;
+ if ( inputState.guessing==0 ) {
+ 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;
+ if ( inputState.guessing==0 ) {
+ t=f3;
+ }
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 'D': case 'F': case 'd': case 'f':
+ {
+ mFLOAT_SUFFIX(true);
+ f4=_returnToken;
+ if ( inputState.guessing==0 ) {
+ t=f4;
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ if ( inputState.guessing==0 ) {
+
+ 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 _cnt172=0;
+ _loop172:
+ do {
+ if (((LA(1) >= '0' && LA(1) <= '9'))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt172>=1 ) { break _loop172; } else {throw new NoViableAltForCharException((char)LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt172++;
+ } 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]=-549755823112L;
+ 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]=-17179878408L;
+ 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/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.smap b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.smap
new file mode 100644
index 000000000..045e3e308
--- /dev/null
+++ b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaLexer.smap
@@ -0,0 +1,1280 @@
+SMAP
+JavaLexer.java
+G
+*S G
+*F
++ 0 java-expression.g
+java-expression.g
+*L
+0:75
+0:81
+0:87
+0:93
+0:99
+0:105
+0:111
+0:117
+0:123
+0:129
+0:135
+0:142
+0:148
+0:154
+0:173
+0:181
+0:187
+0:191
+0:195
+0:199
+0:203
+0:207
+0:211
+0:215
+0:219
+0:223
+0:227
+0:231
+0:235
+0:239
+0:243
+0:247
+0:251
+0:255
+0:259
+0:263
+0:267
+0:271
+0:275
+0:279
+0:283
+0:287
+0:291
+0:295
+0:299
+0:303
+0:307
+0:311
+0:315
+0:319
+0:323
+0:327
+19:3
+231:355
+231:356
+231:357
+231:358
+231:360
+231:361
+231:362
+231:363
+231:364
+231:365
+231:366
+232:368
+232:369
+232:370
+232:371
+232:373
+232:374
+232:375
+232:376
+232:377
+232:378
+232:379
+233:381
+233:382
+233:383
+233:384
+233:386
+233:387
+233:388
+233:389
+233:390
+233:391
+233:392
+234:394
+234:395
+234:396
+234:397
+234:399
+234:400
+234:401
+234:402
+234:403
+234:404
+234:405
+235:407
+235:408
+235:409
+235:410
+235:412
+235:413
+235:414
+235:415
+235:416
+235:417
+235:418
+236:420
+236:421
+236:422
+236:423
+236:425
+236:426
+236:427
+236:428
+236:429
+236:430
+236:431
+237:433
+237:434
+237:435
+237:436
+237:438
+237:439
+237:440
+237:441
+237:442
+237:443
+237:444
+238:446
+238:447
+238:448
+238:449
+238:451
+238:452
+238:453
+238:454
+238:455
+238:456
+238:457
+239:459
+239:460
+239:461
+239:462
+239:464
+239:465
+239:466
+239:467
+239:468
+239:469
+239:470
+241:472
+241:473
+241:474
+241:475
+241:477
+241:478
+241:479
+241:480
+241:481
+241:482
+241:483
+242:485
+242:486
+242:487
+242:488
+242:490
+242:491
+242:492
+242:493
+242:494
+242:495
+242:496
+243:498
+243:499
+243:500
+243:501
+243:503
+243:504
+243:505
+243:506
+243:507
+243:508
+243:509
+244:511
+244:512
+244:513
+244:514
+244:516
+244:517
+244:518
+244:519
+244:520
+244:521
+244:522
+245:524
+245:525
+245:526
+245:527
+245:529
+245:530
+245:531
+245:532
+245:533
+245:534
+245:535
+246:537
+246:538
+246:539
+246:540
+246:542
+246:543
+246:544
+246:545
+246:546
+246:547
+246:548
+247:550
+247:551
+247:552
+247:553
+247:555
+247:556
+247:557
+247:558
+247:559
+247:560
+247:561
+248:563
+248:564
+248:565
+248:566
+248:568
+248:569
+248:570
+248:571
+248:572
+248:573
+248:574
+249:576
+249:577
+249:578
+249:579
+249:581
+249:582
+249:583
+249:584
+249:585
+249:586
+249:587
+250:589
+250:590
+250:591
+250:592
+250:594
+250:595
+250:596
+250:597
+250:598
+250:599
+250:600
+251:602
+251:603
+251:604
+251:605
+251:607
+251:608
+251:609
+251:610
+251:611
+251:612
+251:613
+252:615
+252:616
+252:617
+252:618
+252:620
+252:621
+252:622
+252:623
+252:624
+252:625
+252:626
+253:628
+253:629
+253:630
+253:631
+253:633
+253:634
+253:635
+253:636
+253:637
+253:638
+253:639
+254:641
+254:642
+254:643
+254:644
+254:646
+254:647
+254:648
+254:649
+254:650
+254:651
+254:652
+255:654
+255:655
+255:656
+255:657
+255:659
+255:660
+255:661
+255:662
+255:663
+255:664
+255:665
+256:667
+256:668
+256:669
+256:670
+256:672
+256:673
+256:674
+256:675
+256:676
+256:677
+256:678
+257:680
+257:681
+257:682
+257:683
+257:685
+257:686
+257:687
+257:688
+257:689
+257:690
+257:691
+258:693
+258:694
+258:695
+258:696
+258:698
+258:699
+258:700
+258:701
+258:702
+258:703
+258:704
+259:706
+259:707
+259:708
+259:709
+259:711
+259:712
+259:713
+259:714
+259:715
+259:716
+259:717
+260:719
+260:720
+260:721
+260:722
+260:724
+260:725
+260:726
+260:727
+260:728
+260:729
+260:730
+261:732
+261:733
+261:734
+261:735
+261:737
+261:738
+261:739
+261:740
+261:741
+261:742
+261:743
+262:745
+262:746
+262:747
+262:748
+262:750
+262:751
+262:752
+262:753
+262:754
+262:755
+262:756
+263:758
+263:759
+263:760
+263:761
+263:763
+263:764
+263:765
+263:766
+263:767
+263:768
+263:769
+264:771
+264:772
+264:773
+264:774
+264:776
+264:777
+264:778
+264:779
+264:780
+264:781
+264:782
+265:784
+265:785
+265:786
+265:787
+265:789
+265:790
+265:791
+265:792
+265:793
+265:794
+265:795
+266:797
+266:798
+266:799
+266:800
+266:802
+266:803
+266:804
+266:805
+266:806
+266:807
+266:808
+267:810
+267:811
+267:812
+267:813
+267:815
+267:816
+267:817
+267:818
+267:819
+267:820
+267:821
+268:823
+268:824
+268:825
+268:826
+268:828
+268:829
+268:830
+268:831
+268:832
+268:833
+268:834
+269:836
+269:837
+269:838
+269:839
+269:841
+269:842
+269:843
+269:844
+269:845
+269:846
+269:847
+270:849
+270:850
+270:851
+270:852
+270:854
+270:855
+270:856
+270:857
+270:858
+270:859
+270:860
+271:862
+271:863
+271:864
+271:865
+271:867
+271:868
+271:869
+271:870
+271:871
+271:872
+271:873
+272:875
+272:876
+272:877
+272:878
+272:880
+272:881
+272:882
+272:883
+272:884
+272:885
+272:886
+273:888
+273:889
+273:890
+273:891
+273:893
+273:894
+273:895
+273:896
+273:897
+273:898
+273:899
+274:901
+274:902
+274:903
+274:904
+274:906
+274:907
+274:908
+274:909
+274:910
+274:911
+274:912
+275:914
+275:915
+275:916
+275:917
+275:919
+275:920
+275:921
+275:922
+275:923
+275:924
+275:925
+276:927
+276:928
+276:929
+276:930
+276:932
+276:933
+276:934
+276:935
+276:936
+276:937
+276:938
+280:940
+280:941
+280:942
+280:943
+280:946
+280:947
+280:948
+280:949
+280:950
+280:951
+280:952
+280:987
+280:988
+280:989
+280:990
+280:991
+280:992
+280:993
+280:994
+280:998
+280:999
+280:1000
+280:1001
+280:1002
+280:1003
+281:955
+281:956
+281:957
+282:960
+282:961
+282:962
+284:965
+284:966
+284:970
+284:973
+284:976
+284:977
+284:978
+284:979
+285:968
+285:969
+286:971
+286:972
+287:974
+287:975
+289:982
+289:983
+291:995
+291:996
+295:1005
+295:1006
+295:1007
+295:1008
+295:1054
+295:1055
+295:1056
+295:1057
+295:1058
+295:1059
+296:1010
+297:1011
+297:1012
+297:1013
+297:1014
+297:1016
+297:1018
+297:1019
+297:1020
+297:1021
+297:1023
+297:1024
+297:1026
+297:1027
+297:1028
+297:1029
+297:1032
+297:1033
+297:1034
+297:1036
+297:1037
+297:1038
+297:1040
+297:1045
+297:1046
+297:1047
+297:1048
+297:1049
+298:1051
+298:1052
+302:1061
+302:1062
+302:1063
+302:1064
+302:1107
+302:1108
+302:1109
+302:1110
+302:1111
+302:1112
+303:1066
+304:1067
+304:1068
+304:1069
+304:1076
+304:1079
+304:1085
+304:1091
+304:1096
+304:1097
+304:1098
+304:1099
+304:1101
+304:1102
+315:1077
+315:1078
+316:1070
+316:1071
+316:1072
+316:1073
+316:1074
+317:1080
+317:1081
+317:1082
+317:1083
+318:1086
+318:1087
+318:1088
+318:1089
+319:1092
+319:1094
+321:1103
+322:1104
+322:1105
+327:1114
+327:1115
+327:1116
+327:1117
+327:1135
+327:1136
+327:1137
+327:1138
+327:1139
+327:1140
+328:1119
+328:1121
+328:1122
+328:1123
+328:1124
+328:1126
+328:1128
+328:1129
+328:1130
+328:1131
+328:1134
+332:1268
+332:1269
+332:1270
+332:1271
+332:1292
+332:1293
+332:1294
+332:1295
+332:1296
+332:1297
+333:1273
+333:1274
+333:1275
+333:1276
+333:1277
+333:1278
+333:1279
+333:1280
+333:1282
+333:1284
+333:1285
+333:1286
+333:1287
+333:1289
+333:1290
+333:1291
+346:1142
+346:1143
+346:1144
+346:1145
+346:1261
+346:1262
+346:1263
+346:1264
+346:1265
+346:1266
+347:1147
+348:1149
+348:1150
+348:1151
+348:1152
+348:1255
+348:1256
+348:1257
+348:1258
+348:1259
+349:1155
+349:1156
+349:1157
+350:1160
+350:1161
+350:1162
+351:1165
+351:1166
+351:1167
+352:1170
+352:1171
+352:1172
+353:1175
+353:1176
+353:1177
+354:1180
+354:1181
+354:1182
+355:1185
+355:1186
+355:1187
+356:1190
+356:1191
+356:1193
+356:1194
+356:1195
+356:1196
+356:1197
+356:1198
+356:1199
+356:1200
+356:1201
+356:1203
+356:1204
+356:1205
+356:1206
+356:1207
+356:1208
+356:1209
+357:1212
+357:1213
+357:1214
+358:1229
+358:1231
+358:1232
+358:1233
+358:1234
+362:1216
+362:1217
+363:1221
+363:1223
+363:1224
+363:1225
+363:1226
+367:1219
+367:1220
+370:1239
+370:1240
+370:1241
+371:1245
+371:1247
+371:1248
+371:1249
+371:1250
+375:1243
+375:1244
+383:1299
+383:1300
+383:1301
+383:1302
+383:1331
+383:1332
+383:1333
+383:1334
+383:1335
+383:1336
+384:1305
+384:1306
+384:1307
+384:1308
+384:1309
+384:1310
+384:1313
+384:1314
+384:1315
+384:1316
+384:1319
+384:1320
+384:1321
+384:1322
+384:1325
+384:1326
+384:1327
+384:1328
+384:1329
+391:1338
+391:1339
+391:1340
+391:1341
+391:1344
+391:1345
+391:1346
+391:1347
+391:1348
+391:1349
+392:1343
+399:1351
+399:1352
+399:1353
+399:1354
+399:1446
+399:1447
+399:1448
+399:1449
+399:1450
+399:1451
+399:1452
+401:1357
+401:1358
+401:1359
+401:1360
+401:1361
+401:1362
+401:1363
+401:1364
+401:1365
+401:1366
+401:1369
+401:1370
+401:1371
+401:1372
+401:1373
+401:1374
+401:1375
+401:1376
+401:1377
+401:1380
+401:1381
+401:1382
+401:1385
+401:1386
+401:1387
+401:1390
+401:1391
+401:1392
+401:1393
+401:1394
+401:1396
+401:1397
+401:1398
+401:1399
+401:1400
+401:1401
+401:1402
+401:1403
+401:1404
+401:1405
+401:1406
+401:1407
+401:1408
+401:1411
+401:1412
+401:1413
+401:1414
+401:1415
+401:1416
+401:1417
+401:1418
+401:1419
+401:1422
+401:1423
+401:1424
+401:1427
+401:1428
+401:1429
+401:1430
+401:1431
+401:1434
+401:1435
+401:1436
+401:1439
+401:1440
+401:1441
+401:1442
+401:1443
+401:1444
+401:1445
+406:1454
+406:1455
+406:1456
+406:1457
+406:1462
+406:1464
+406:1805
+406:1806
+406:1807
+406:1808
+406:1809
+406:1810
+406:1811
+406:1812
+406:1813
+406:1814
+406:1815
+408:1465
+408:1466
+408:1467
+408:1468
+408:1469
+409:1458
+409:1472
+409:1474
+409:1475
+409:1476
+409:1477
+409:1478
+409:1479
+409:1480
+409:1481
+409:1482
+409:1484
+409:1485
+409:1486
+409:1488
+409:1489
+409:1490
+409:1492
+409:1496
+409:1497
+409:1498
+409:1499
+409:1500
+409:1502
+409:1504
+409:1517
+409:1519
+410:1507
+411:1509
+412:1510
+413:1511
+414:1512
+415:1513
+416:1514
+420:1524
+420:1525
+420:1526
+420:1527
+420:1529
+420:1530
+420:1531
+420:1532
+420:1533
+420:1534
+420:1686
+420:1687
+420:1688
+420:1689
+420:1690
+421:1537
+421:1539
+421:1540
+421:1541
+421:1542
+421:1545
+421:1546
+421:1547
+421:1550
+421:1551
+421:1552
+421:1553
+421:1554
+421:1570
+421:1639
+421:1655
+421:1657
+421:1658
+422:1557
+422:1558
+422:1559
+422:1562
+422:1563
+422:1564
+422:1565
+422:1567
+422:1568
+422:1569
+431:1560
+431:1561
+435:1571
+435:1572
+435:1573
+435:1574
+435:1575
+435:1576
+435:1577
+435:1580
+435:1581
+435:1582
+435:1583
+435:1584
+435:1585
+435:1586
+435:1587
+435:1588
+435:1590
+435:1591
+435:1592
+435:1594
+435:1595
+435:1596
+435:1597
+435:1600
+435:1601
+435:1602
+435:1605
+435:1606
+435:1607
+435:1610
+435:1611
+435:1612
+435:1613
+435:1614
+435:1617
+435:1618
+435:1619
+435:1620
+435:1621
+435:1622
+435:1623
+435:1624
+435:1626
+435:1627
+435:1628
+435:1629
+435:1630
+435:1631
+435:1632
+435:1633
+435:1634
+435:1636
+435:1637
+435:1638
+437:1640
+437:1642
+437:1643
+437:1644
+437:1645
+437:1646
+437:1647
+437:1648
+437:1649
+437:1650
+437:1652
+437:1653
+437:1654
+439:1662
+439:1663
+439:1664
+439:1665
+439:1667
+439:1669
+439:1670
+439:1671
+439:1672
+439:1673
+439:1674
+439:1675
+439:1676
+439:1677
+439:1679
+439:1680
+439:1681
+439:1682
+441:1693
+441:1695
+441:1696
+441:1697
+441:1698
+441:1701
+441:1702
+441:1703
+441:1706
+441:1707
+441:1708
+441:1709
+441:1710
+441:1712
+441:1713
+441:1715
+441:1798
+441:1800
+445:1459
+445:1716
+445:1718
+445:1719
+445:1720
+445:1721
+445:1722
+445:1723
+445:1724
+445:1725
+445:1726
+445:1727
+445:1728
+445:1729
+445:1730
+445:1732
+445:1733
+445:1735
+445:1736
+445:1737
+445:1739
+445:1743
+445:1744
+445:1745
+445:1746
+445:1747
+445:1749
+445:1751
+445:1782
+445:1783
+445:1784
+445:1785
+445:1786
+446:1460
+446:1756
+446:1757
+446:1758
+446:1760
+446:1761
+446:1762
+446:1763
+446:1764
+446:1766
+446:1768
+447:1461
+447:1773
+447:1774
+447:1775
+447:1776
+447:1777
+447:1778
+449:1788
+450:1790
+451:1791
+452:1792
+453:1793
+454:1794
+455:1795
+463:1817
+463:1818
+463:1819
+463:1820
+463:1878
+463:1879
+463:1880
+463:1881
+463:1882
+463:1883
+464:1823
+464:1824
+464:1825
+464:1826
+464:1829
+464:1830
+464:1831
+464:1834
+464:1835
+464:1836
+464:1837
+464:1838
+464:1841
+464:1842
+464:1843
+464:1844
+464:1847
+464:1848
+464:1849
+464:1858
+464:1859
+464:1860
+464:1861
+464:1862
+464:1865
+464:1866
+464:1867
+464:1868
+464:1869
+464:1870
+464:1871
+464:1872
+464:1873
+464:1875
+464:1876
+464:1877
+469:1885
+469:1886
+469:1887
+469:1888
+469:1890
+469:1911
+469:1912
+469:1913
+469:1914
+469:1915
+469:1916
+469:1917
+469:1918
+469:1919
+469:1920
+469:1921
+470:1891
+470:1892
+470:1893
+470:1896
+470:1897
+470:1898
+470:1901
+470:1902
+470:1903
+470:1906
+470:1907
+470:1908
+*E
diff --git a/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java
new file mode 100644
index 000000000..bd43bf3b6
--- /dev/null
+++ b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.java
@@ -0,0 +1,1406 @@
+// $ANTLR 2.7.7 (20080530): "java-expression.g" -> "JavaRecognizer.java"$
+
+ package gnu.classpath.tools.gjdoc.expr;
+
+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;
+
+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 Type builtInTypeSpec(
+ boolean addImagNode
+ ) throws RecognitionException, TokenStreamException {
+ Type t = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST builtInTypeSpec_AST = null;
+ Token lb = null;
+ AST lb_AST = null;
+
+ t=builtInType();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop3:
+ 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 _loop3;
+ }
+
+ } 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;
+ return t;
+ }
+
+ public final Type builtInType() throws RecognitionException, TokenStreamException {
+ Type t = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST builtInType_AST = null;
+
+ switch ( LA(1)) {
+ case LITERAL_void:
+ {
+ AST tmp2_AST = null;
+ tmp2_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp2_AST);
+ match(LITERAL_void);
+ if ( inputState.guessing==0 ) {
+ t=Type.VOID;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_boolean:
+ {
+ AST tmp3_AST = null;
+ tmp3_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp3_AST);
+ match(LITERAL_boolean);
+ if ( inputState.guessing==0 ) {
+ t=Type.BOOLEAN;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_byte:
+ {
+ AST tmp4_AST = null;
+ tmp4_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp4_AST);
+ match(LITERAL_byte);
+ if ( inputState.guessing==0 ) {
+ t=Type.BYTE;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_char:
+ {
+ AST tmp5_AST = null;
+ tmp5_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp5_AST);
+ match(LITERAL_char);
+ if ( inputState.guessing==0 ) {
+ t=Type.CHAR;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_short:
+ {
+ AST tmp6_AST = null;
+ tmp6_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp6_AST);
+ match(LITERAL_short);
+ if ( inputState.guessing==0 ) {
+ t=Type.SHORT;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_int:
+ {
+ AST tmp7_AST = null;
+ tmp7_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp7_AST);
+ match(LITERAL_int);
+ if ( inputState.guessing==0 ) {
+ t=Type.INTEGER;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_float:
+ {
+ AST tmp8_AST = null;
+ tmp8_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp8_AST);
+ match(LITERAL_float);
+ if ( inputState.guessing==0 ) {
+ t=Type.FLOAT;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_long:
+ {
+ AST tmp9_AST = null;
+ tmp9_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp9_AST);
+ match(LITERAL_long);
+ if ( inputState.guessing==0 ) {
+ t=Type.LONG;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_double:
+ {
+ AST tmp10_AST = null;
+ tmp10_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp10_AST);
+ match(LITERAL_double);
+ if ( inputState.guessing==0 ) {
+ t=Type.DOUBLE;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_String:
+ {
+ AST tmp11_AST = null;
+ tmp11_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp11_AST);
+ match(LITERAL_String);
+ if ( inputState.guessing==0 ) {
+ t=Type.STRING;
+ }
+ builtInType_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = builtInType_AST;
+ return t;
+ }
+
+ public final Type type() throws RecognitionException, TokenStreamException {
+ Type t;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST type_AST = null;
+
+ t=builtInType();
+ astFactory.addASTChild(currentAST, returnAST);
+ type_AST = (AST)currentAST.root;
+ returnAST = type_AST;
+ return t;
+ }
+
+ public final String identifier() throws RecognitionException, TokenStreamException {
+ String s = null;;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST identifier_AST = null;
+ Token i = null;
+ AST i_AST = null;
+ Token i2 = null;
+ AST i2_AST = null;
+
+ i = LT(1);
+ i_AST = astFactory.create(i);
+ astFactory.addASTChild(currentAST, i_AST);
+ match(IDENT);
+ if ( inputState.guessing==0 ) {
+ s=i.getText();
+ }
+ {
+ _loop8:
+ do {
+ if ((LA(1)==DOT)) {
+ AST tmp12_AST = null;
+ tmp12_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp12_AST);
+ match(DOT);
+ i2 = LT(1);
+ i2_AST = astFactory.create(i2);
+ astFactory.addASTChild(currentAST, i2_AST);
+ match(IDENT);
+ if ( inputState.guessing==0 ) {
+ s+="."+i2.getText();
+ }
+ }
+ else {
+ break _loop8;
+ }
+
+ } while (true);
+ }
+ identifier_AST = (AST)currentAST.root;
+ returnAST = identifier_AST;
+ return s;
+ }
+
+ public final Expression expression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST expression_AST = null;
+
+ e=conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(Token.EOF_TYPE);
+ expression_AST = (AST)currentAST.root;
+ returnAST = expression_AST;
+ return e;
+ }
+
+ public final Expression conditionalExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST conditionalExpression_AST = null;
+ Expression a,b,c;
+
+ e=logicalOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ switch ( LA(1)) {
+ case QUESTION:
+ {
+ AST tmp14_AST = null;
+ tmp14_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp14_AST);
+ match(QUESTION);
+ b=conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(COLON);
+ c=conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new ConditionalExpression(e,b,c);
+ }
+ break;
+ }
+ case EOF:
+ case COLON:
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ conditionalExpression_AST = (AST)currentAST.root;
+ returnAST = conditionalExpression_AST;
+ return e;
+ }
+
+ public final Expression logicalOrExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST logicalOrExpression_AST = null;
+ Expression a,b;
+
+ e=logicalAndExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop14:
+ do {
+ if ((LA(1)==LOR)) {
+ AST tmp16_AST = null;
+ tmp16_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp16_AST);
+ match(LOR);
+ b=logicalAndExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new LogicalOrExpression(e,b);
+ }
+ }
+ else {
+ break _loop14;
+ }
+
+ } while (true);
+ }
+ logicalOrExpression_AST = (AST)currentAST.root;
+ returnAST = logicalOrExpression_AST;
+ return e;
+ }
+
+ public final Expression logicalAndExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST logicalAndExpression_AST = null;
+ Expression a,b;
+
+ e=inclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop17:
+ do {
+ if ((LA(1)==LAND)) {
+ AST tmp17_AST = null;
+ tmp17_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp17_AST);
+ match(LAND);
+ b=inclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new LogicalAndExpression(e,b);
+ }
+ }
+ else {
+ break _loop17;
+ }
+
+ } while (true);
+ }
+ logicalAndExpression_AST = (AST)currentAST.root;
+ returnAST = logicalAndExpression_AST;
+ return e;
+ }
+
+ public final Expression inclusiveOrExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST inclusiveOrExpression_AST = null;
+ Expression a,b;
+
+ e=exclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop20:
+ do {
+ if ((LA(1)==BOR)) {
+ AST tmp18_AST = null;
+ tmp18_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp18_AST);
+ match(BOR);
+ b=exclusiveOrExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new InclusiveOrExpression(e,b);
+ }
+ }
+ else {
+ break _loop20;
+ }
+
+ } while (true);
+ }
+ inclusiveOrExpression_AST = (AST)currentAST.root;
+ returnAST = inclusiveOrExpression_AST;
+ return e;
+ }
+
+ public final Expression exclusiveOrExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST exclusiveOrExpression_AST = null;
+ Expression a,b;
+
+ e=andExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop23:
+ do {
+ if ((LA(1)==BXOR)) {
+ AST tmp19_AST = null;
+ tmp19_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp19_AST);
+ match(BXOR);
+ b=andExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new ExclusiveOrExpression(e,b);
+ }
+ }
+ else {
+ break _loop23;
+ }
+
+ } while (true);
+ }
+ exclusiveOrExpression_AST = (AST)currentAST.root;
+ returnAST = exclusiveOrExpression_AST;
+ return e;
+ }
+
+ public final Expression andExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST andExpression_AST = null;
+ Expression a,b;
+
+ e=equalityExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop26:
+ do {
+ if ((LA(1)==BAND)) {
+ AST tmp20_AST = null;
+ tmp20_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp20_AST);
+ match(BAND);
+ b=equalityExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new AndExpression(e,b);
+ }
+ }
+ else {
+ break _loop26;
+ }
+
+ } while (true);
+ }
+ andExpression_AST = (AST)currentAST.root;
+ returnAST = andExpression_AST;
+ return e;
+ }
+
+ public final Expression equalityExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST equalityExpression_AST = null;
+ Expression a,b;
+
+ e=relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop30:
+ do {
+ if ((LA(1)==NOT_EQUAL||LA(1)==EQUAL)) {
+ {
+ switch ( LA(1)) {
+ case NOT_EQUAL:
+ {
+ AST tmp21_AST = null;
+ tmp21_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp21_AST);
+ match(NOT_EQUAL);
+ a=relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new NotEqualExpression(e,a);
+ }
+ break;
+ }
+ case EQUAL:
+ {
+ AST tmp22_AST = null;
+ tmp22_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp22_AST);
+ match(EQUAL);
+ a=relationalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new EqualExpression(e,a);
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ break _loop30;
+ }
+
+ } while (true);
+ }
+ equalityExpression_AST = (AST)currentAST.root;
+ returnAST = equalityExpression_AST;
+ return e;
+ }
+
+ public final Expression relationalExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST relationalExpression_AST = null;
+ Expression a,b;
+
+ e=shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ {
+ _loop35:
+ do {
+ if (((LA(1) >= LT && LA(1) <= GE))) {
+ {
+ switch ( LA(1)) {
+ case LT:
+ {
+ AST tmp23_AST = null;
+ tmp23_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp23_AST);
+ match(LT);
+ a=shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new LessThanExpression(e,a);
+ }
+ break;
+ }
+ case GT:
+ {
+ AST tmp24_AST = null;
+ tmp24_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp24_AST);
+ match(GT);
+ a=shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new GreaterThanExpression(e,a);
+ }
+ break;
+ }
+ case LE:
+ {
+ AST tmp25_AST = null;
+ tmp25_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp25_AST);
+ match(LE);
+ a=shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new LessThanOrEqualExpression(e,a);
+ }
+ break;
+ }
+ case GE:
+ {
+ AST tmp26_AST = null;
+ tmp26_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp26_AST);
+ match(GE);
+ a=shiftExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new GreaterThanOrEqualExpression(e,a);
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ break _loop35;
+ }
+
+ } while (true);
+ }
+ }
+ relationalExpression_AST = (AST)currentAST.root;
+ returnAST = relationalExpression_AST;
+ return e;
+ }
+
+ public final Expression shiftExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST shiftExpression_AST = null;
+ Expression a,b;
+
+ e=additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop39:
+ do {
+ if (((LA(1) >= SL && LA(1) <= BSR))) {
+ {
+ switch ( LA(1)) {
+ case SL:
+ {
+ AST tmp27_AST = null;
+ tmp27_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp27_AST);
+ match(SL);
+ a=additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new ShiftLeftExpression(e,a);
+ }
+ break;
+ }
+ case SR:
+ {
+ AST tmp28_AST = null;
+ tmp28_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp28_AST);
+ match(SR);
+ a=additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new ShiftRightExpression(e,a);
+ }
+ break;
+ }
+ case BSR:
+ {
+ AST tmp29_AST = null;
+ tmp29_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp29_AST);
+ match(BSR);
+ a=additiveExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new BitShiftRightExpression(e,a);
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ break _loop39;
+ }
+
+ } while (true);
+ }
+ shiftExpression_AST = (AST)currentAST.root;
+ returnAST = shiftExpression_AST;
+ return e;
+ }
+
+ public final Expression additiveExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST additiveExpression_AST = null;
+ Expression a,b;
+
+ e=multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop43:
+ do {
+ if ((LA(1)==PLUS||LA(1)==MINUS)) {
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ AST tmp30_AST = null;
+ tmp30_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp30_AST);
+ match(PLUS);
+ a=multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new AdditionExpression(e,a);
+ }
+ break;
+ }
+ case MINUS:
+ {
+ AST tmp31_AST = null;
+ tmp31_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp31_AST);
+ match(MINUS);
+ a=multiplicativeExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new SubtractionExpression(e,a);
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ break _loop43;
+ }
+
+ } while (true);
+ }
+ additiveExpression_AST = (AST)currentAST.root;
+ returnAST = additiveExpression_AST;
+ return e;
+ }
+
+ public final Expression multiplicativeExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST multiplicativeExpression_AST = null;
+ Expression a,b;
+
+ e=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ {
+ _loop47:
+ do {
+ if (((LA(1) >= STAR && LA(1) <= MOD))) {
+ {
+ switch ( LA(1)) {
+ case STAR:
+ {
+ AST tmp32_AST = null;
+ tmp32_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp32_AST);
+ match(STAR);
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new MultiplicationExpression(e,a);
+ }
+ break;
+ }
+ case DIV:
+ {
+ AST tmp33_AST = null;
+ tmp33_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp33_AST);
+ match(DIV);
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new DivisionExpression(e,a);
+ }
+ break;
+ }
+ case MOD:
+ {
+ AST tmp34_AST = null;
+ tmp34_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp34_AST);
+ match(MOD);
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new ModuloExpression(e,a);
+ }
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ break _loop47;
+ }
+
+ } while (true);
+ }
+ multiplicativeExpression_AST = (AST)currentAST.root;
+ returnAST = multiplicativeExpression_AST;
+ return e;
+ }
+
+ public final Expression unaryExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST unaryExpression_AST = null;
+ Expression a,b;
+
+ switch ( LA(1)) {
+ case MINUS:
+ {
+ AST tmp35_AST = null;
+ tmp35_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp35_AST);
+ match(MINUS);
+ if ( inputState.guessing==0 ) {
+ tmp35_AST.setType(UNARY_MINUS);
+ }
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new NegateExpression(a);
+ }
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case PLUS:
+ {
+ AST tmp36_AST = null;
+ tmp36_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp36_AST);
+ match(PLUS);
+ if ( inputState.guessing==0 ) {
+ tmp36_AST.setType(UNARY_PLUS);
+ }
+ e=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case IDENT:
+ case BNOT:
+ case LNOT:
+ case LPAREN:
+ case LITERAL_true:
+ case LITERAL_false:
+ case LITERAL_null:
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ e=unaryExpressionNotPlusMinus();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = unaryExpression_AST;
+ return e;
+ }
+
+ public final Expression unaryExpressionNotPlusMinus() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST unaryExpressionNotPlusMinus_AST = null;
+ Token lpb = null;
+ AST lpb_AST = null;
+ Expression a; Type t;
+
+ switch ( LA(1)) {
+ case BNOT:
+ {
+ AST tmp37_AST = null;
+ tmp37_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp37_AST);
+ match(BNOT);
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new NotExpression(a);
+ }
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ break;
+ }
+ case LNOT:
+ {
+ AST tmp38_AST = null;
+ tmp38_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp38_AST);
+ match(LNOT);
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new LogicalNotExpression(a);
+ }
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ boolean synPredMatched51 = false;
+ if (((LA(1)==LPAREN) && ((LA(2) >= LITERAL_void && LA(2) <= LITERAL_String)))) {
+ int _m51 = mark();
+ synPredMatched51 = true;
+ inputState.guessing++;
+ try {
+ {
+ match(LPAREN);
+ builtInTypeSpec(true);
+ match(RPAREN);
+ }
+ }
+ catch (RecognitionException pe) {
+ synPredMatched51 = false;
+ }
+ rewind(_m51);
+inputState.guessing--;
+ }
+ if ( synPredMatched51 ) {
+ lpb = LT(1);
+ lpb_AST = astFactory.create(lpb);
+ astFactory.makeASTRoot(currentAST, lpb_AST);
+ match(LPAREN);
+ if ( inputState.guessing==0 ) {
+ lpb_AST.setType(TYPECAST);
+ }
+ t=builtInTypeSpec(true);
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ a=unaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new TypeCastExpression(t,a);
+ }
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ }
+ else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) {
+ e=primaryExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ unaryExpressionNotPlusMinus_AST = (AST)currentAST.root;
+ }
+ else {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = unaryExpressionNotPlusMinus_AST;
+ return e;
+ }
+
+ public final Expression primaryExpression() throws RecognitionException, TokenStreamException {
+ Expression e = null; String i = null;;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST primaryExpression_AST = null;
+
+ switch ( LA(1)) {
+ case NUM_INT:
+ case CHAR_LITERAL:
+ case STRING_LITERAL:
+ case NUM_FLOAT:
+ case NUM_LONG:
+ case NUM_DOUBLE:
+ {
+ e=constant();
+ astFactory.addASTChild(currentAST, returnAST);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case IDENT:
+ {
+ i=identifier();
+ astFactory.addASTChild(currentAST, returnAST);
+ if ( inputState.guessing==0 ) {
+ e=new IdentifierExpression(i);
+ }
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_true:
+ {
+ AST tmp40_AST = null;
+ tmp40_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp40_AST);
+ match(LITERAL_true);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantBoolean(true);
+ }
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_false:
+ {
+ AST tmp41_AST = null;
+ tmp41_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp41_AST);
+ match(LITERAL_false);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantBoolean(false);
+ }
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LITERAL_null:
+ {
+ AST tmp42_AST = null;
+ tmp42_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp42_AST);
+ match(LITERAL_null);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantNull();
+ }
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ case LPAREN:
+ {
+ match(LPAREN);
+ e=conditionalExpression();
+ astFactory.addASTChild(currentAST, returnAST);
+ match(RPAREN);
+ primaryExpression_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = primaryExpression_AST;
+ return e;
+ }
+
+ public final Expression constant() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST constant_AST = null;
+ Token l1 = null;
+ AST l1_AST = null;
+ Token l2 = null;
+ AST l2_AST = null;
+ Token l3 = null;
+ AST l3_AST = null;
+ Token l4 = null;
+ AST l4_AST = null;
+ Token l5 = null;
+ AST l5_AST = null;
+ Token l6 = null;
+ AST l6_AST = null;
+
+ switch ( LA(1)) {
+ case NUM_INT:
+ {
+ l1 = LT(1);
+ l1_AST = astFactory.create(l1);
+ astFactory.addASTChild(currentAST, l1_AST);
+ match(NUM_INT);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantInteger(l1.getText());
+ }
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case CHAR_LITERAL:
+ {
+ l2 = LT(1);
+ l2_AST = astFactory.create(l2);
+ astFactory.addASTChild(currentAST, l2_AST);
+ match(CHAR_LITERAL);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantChar(l2.getText());
+ }
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case STRING_LITERAL:
+ {
+ l3 = LT(1);
+ l3_AST = astFactory.create(l3);
+ astFactory.addASTChild(currentAST, l3_AST);
+ match(STRING_LITERAL);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantString(l3.getText().substring(1, l3.getText().length()-1));
+ }
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_FLOAT:
+ {
+ l4 = LT(1);
+ l4_AST = astFactory.create(l4);
+ astFactory.addASTChild(currentAST, l4_AST);
+ match(NUM_FLOAT);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantFloat(l4.getText());
+ }
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_LONG:
+ {
+ l5 = LT(1);
+ l5_AST = astFactory.create(l5);
+ astFactory.addASTChild(currentAST, l5_AST);
+ match(NUM_LONG);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantLong(l5.getText());
+ }
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ case NUM_DOUBLE:
+ {
+ l6 = LT(1);
+ l6_AST = astFactory.create(l6);
+ astFactory.addASTChild(currentAST, l6_AST);
+ match(NUM_DOUBLE);
+ if ( inputState.guessing==0 ) {
+ e=new ConstantDouble(l6.getText());
+ }
+ constant_AST = (AST)currentAST.root;
+ break;
+ }
+ default:
+ {
+ throw new NoViableAltException(LT(1), getFilename());
+ }
+ }
+ returnAST = constant_AST;
+ return e;
+ }
+
+/** Match a, a.b.c refs
+ */
+ public final Expression identPrimary() throws RecognitionException, TokenStreamException {
+ Expression e = null;
+
+ returnAST = null;
+ ASTPair currentAST = new ASTPair();
+ AST identPrimary_AST = null;
+
+ AST tmp45_AST = null;
+ tmp45_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp45_AST);
+ match(IDENT);
+ {
+ _loop55:
+ do {
+ if ((LA(1)==DOT)) {
+ AST tmp46_AST = null;
+ tmp46_AST = astFactory.create(LT(1));
+ astFactory.makeASTRoot(currentAST, tmp46_AST);
+ match(DOT);
+ AST tmp47_AST = null;
+ tmp47_AST = astFactory.create(LT(1));
+ astFactory.addASTChild(currentAST, tmp47_AST);
+ match(IDENT);
+ }
+ else {
+ break _loop55;
+ }
+
+ } while (true);
+ }
+ identPrimary_AST = (AST)currentAST.root;
+ returnAST = identPrimary_AST;
+ return e;
+ }
+
+
+ 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",
+ "LBRACK",
+ "RBRACK",
+ "\"void\"",
+ "\"boolean\"",
+ "\"byte\"",
+ "\"char\"",
+ "\"short\"",
+ "\"int\"",
+ "\"float\"",
+ "\"long\"",
+ "\"double\"",
+ "\"String\"",
+ "IDENT",
+ "DOT",
+ "QUESTION",
+ "COLON",
+ "LOR",
+ "LAND",
+ "BOR",
+ "BXOR",
+ "BAND",
+ "NOT_EQUAL",
+ "EQUAL",
+ "LT",
+ "GT",
+ "LE",
+ "GE",
+ "SL",
+ "SR",
+ "BSR",
+ "PLUS",
+ "MINUS",
+ "STAR",
+ "DIV",
+ "MOD",
+ "BNOT",
+ "LNOT",
+ "LPAREN",
+ "RPAREN",
+ "\"true\"",
+ "\"false\"",
+ "\"null\"",
+ "NUM_INT",
+ "CHAR_LITERAL",
+ "STRING_LITERAL",
+ "NUM_FLOAT",
+ "NUM_LONG",
+ "NUM_DOUBLE",
+ "LCURLY",
+ "RCURLY",
+ "COMMA",
+ "ASSIGN",
+ "DIV_ASSIGN",
+ "PLUS_ASSIGN",
+ "INC",
+ "MINUS_ASSIGN",
+ "DEC",
+ "STAR_ASSIGN",
+ "MOD_ASSIGN",
+ "SR_ASSIGN",
+ "BSR_ASSIGN",
+ "SL_ASSIGN",
+ "BXOR_ASSIGN",
+ "BOR_ASSIGN",
+ "BAND_ASSIGN",
+ "SEMI",
+ "WS",
+ "SL_COMMIT",
+ "ML_COMMENT",
+ "ESC",
+ "HEX_DIGIT",
+ "VOCAB",
+ "EXPONENT",
+ "FLOAT_SUFFIX"
+ };
+
+ protected void buildTokenTypeASTClassMap() {
+ tokenTypeToASTClassMap=null;
+ };
+
+ private static final long[] mk_tokenSet_0() {
+ long[] data = { 72057594037927936L, 268042240L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
+ private static final long[] mk_tokenSet_1() {
+ long[] data = { -72057594037927934L, 268435455L, 0L, 0L};
+ return data;
+ }
+ public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
+
+ }
diff --git a/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.smap b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.smap
new file mode 100644
index 000000000..667caad55
--- /dev/null
+++ b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaRecognizer.smap
@@ -0,0 +1,987 @@
+SMAP
+JavaRecognizer.java
+G
+*S G
+*F
++ 0 java-expression.g
+java-expression.g
+*L
+19:3
+46:56
+46:57
+46:58
+46:59
+46:61
+46:62
+46:63
+46:101
+46:102
+46:103
+47:64
+47:65
+47:67
+47:68
+47:69
+47:70
+47:71
+47:72
+47:73
+47:74
+47:75
+47:76
+47:77
+47:78
+47:80
+47:81
+47:82
+47:83
+47:84
+47:86
+47:87
+48:88
+48:89
+48:95
+48:97
+48:98
+49:91
+49:100
+50:92
+51:93
+57:242
+57:243
+57:245
+57:246
+57:247
+57:252
+57:253
+57:254
+58:249
+58:250
+58:251
+62:105
+62:106
+62:108
+62:109
+62:110
+62:112
+62:233
+62:234
+62:235
+62:236
+62:237
+62:238
+62:239
+62:240
+63:113
+63:114
+63:115
+63:116
+63:117
+63:118
+63:119
+63:120
+64:125
+64:126
+64:127
+64:128
+64:129
+64:130
+64:131
+64:132
+65:137
+65:138
+65:139
+65:140
+65:141
+65:142
+65:143
+65:144
+66:122
+66:149
+66:150
+66:151
+66:152
+66:153
+66:154
+66:155
+66:156
+67:134
+67:161
+67:162
+67:163
+67:164
+67:165
+67:166
+67:167
+67:168
+68:146
+68:173
+68:174
+68:175
+68:176
+68:177
+68:178
+68:179
+68:180
+69:158
+69:185
+69:186
+69:187
+69:188
+69:189
+69:190
+69:191
+69:192
+70:170
+70:197
+70:198
+70:199
+70:200
+70:201
+70:202
+70:203
+70:204
+71:182
+71:209
+71:210
+71:211
+71:212
+71:213
+71:214
+71:215
+71:216
+72:194
+72:221
+72:222
+72:223
+72:224
+72:225
+72:226
+72:227
+72:228
+73:206
+74:218
+75:230
+77:256
+77:257
+77:259
+77:260
+77:261
+77:297
+77:298
+77:299
+78:262
+78:263
+78:264
+78:265
+78:267
+78:268
+78:269
+78:270
+78:271
+78:272
+78:274
+78:275
+78:276
+78:277
+78:278
+78:279
+78:280
+78:281
+78:282
+78:283
+78:284
+78:285
+78:286
+78:287
+78:289
+78:290
+78:291
+78:292
+78:294
+78:295
+78:296
+81:301
+81:302
+81:304
+81:305
+81:306
+81:312
+81:313
+81:314
+82:308
+82:309
+82:310
+84:311
+86:316
+86:317
+86:319
+86:320
+86:321
+86:322
+86:357
+86:358
+86:359
+87:324
+87:325
+88:327
+88:328
+88:329
+88:330
+88:331
+88:332
+88:333
+88:334
+88:335
+88:336
+88:337
+88:338
+88:339
+88:340
+88:350
+88:351
+88:352
+88:353
+88:354
+89:356
+93:361
+93:362
+93:364
+93:365
+93:366
+93:367
+93:392
+93:393
+93:394
+94:369
+94:370
+94:371
+94:372
+94:373
+94:374
+94:375
+94:376
+94:377
+94:378
+94:379
+94:380
+94:381
+94:382
+94:384
+94:385
+94:386
+94:387
+94:389
+94:390
+94:391
+99:396
+99:397
+99:399
+99:400
+99:401
+99:402
+99:427
+99:428
+99:429
+100:404
+100:405
+100:406
+100:407
+100:408
+100:409
+100:410
+100:411
+100:412
+100:413
+100:414
+100:415
+100:416
+100:417
+100:419
+100:420
+100:421
+100:422
+100:424
+100:425
+100:426
+105:431
+105:432
+105:434
+105:435
+105:436
+105:437
+105:462
+105:463
+105:464
+106:439
+106:440
+106:441
+106:442
+106:443
+106:444
+106:445
+106:446
+106:447
+106:448
+106:449
+106:450
+106:451
+106:452
+106:454
+106:455
+106:456
+106:457
+106:459
+106:460
+106:461
+111:466
+111:467
+111:469
+111:470
+111:471
+111:472
+111:497
+111:498
+111:499
+112:474
+112:475
+112:476
+112:477
+112:478
+112:479
+112:480
+112:481
+112:482
+112:483
+112:484
+112:485
+112:486
+112:487
+112:489
+112:490
+112:491
+112:492
+112:494
+112:495
+112:496
+117:501
+117:502
+117:504
+117:505
+117:506
+117:507
+117:532
+117:533
+117:534
+118:509
+118:510
+118:511
+118:512
+118:513
+118:514
+118:515
+118:516
+118:517
+118:518
+118:519
+118:520
+118:521
+118:522
+118:524
+118:525
+118:526
+118:527
+118:529
+118:530
+118:531
+123:536
+123:537
+123:539
+123:540
+123:541
+123:542
+123:592
+123:593
+123:594
+124:544
+124:545
+124:546
+124:547
+124:548
+124:549
+124:551
+124:552
+124:553
+124:554
+124:555
+124:556
+124:557
+124:558
+124:559
+124:560
+124:561
+124:565
+124:566
+124:567
+124:568
+124:569
+124:570
+124:571
+124:572
+124:573
+124:574
+124:578
+124:579
+124:580
+124:581
+124:582
+124:584
+124:585
+124:586
+124:587
+124:589
+124:590
+124:591
+129:596
+129:597
+129:599
+129:600
+129:601
+129:602
+129:680
+129:681
+129:682
+130:604
+130:605
+131:607
+131:608
+131:609
+131:610
+131:612
+131:613
+131:614
+131:615
+131:616
+131:617
+131:618
+131:619
+131:620
+131:621
+131:622
+131:665
+131:666
+131:667
+131:668
+131:669
+131:671
+131:672
+131:673
+131:674
+131:676
+131:677
+132:626
+132:627
+132:628
+132:629
+132:630
+132:631
+132:632
+132:633
+132:634
+132:635
+132:679
+133:639
+133:640
+133:641
+133:642
+133:643
+133:644
+133:645
+133:646
+133:647
+133:648
+134:652
+134:653
+134:654
+134:655
+134:656
+134:657
+134:658
+134:659
+134:660
+134:661
+143:684
+143:685
+143:687
+143:688
+143:689
+143:690
+143:753
+143:754
+143:755
+144:692
+144:693
+144:694
+144:695
+144:696
+144:697
+144:699
+144:700
+144:701
+144:702
+144:703
+144:704
+144:705
+144:706
+144:707
+144:708
+144:709
+144:713
+144:714
+144:715
+144:716
+144:717
+144:718
+144:719
+144:720
+144:721
+144:722
+144:726
+144:727
+144:728
+144:729
+144:730
+144:731
+144:732
+144:733
+144:734
+144:735
+144:739
+144:740
+144:741
+144:742
+144:743
+144:745
+144:746
+144:747
+144:748
+144:750
+144:751
+144:752
+149:757
+149:758
+149:760
+149:761
+149:762
+149:763
+149:813
+149:814
+149:815
+150:765
+150:766
+150:767
+150:768
+150:769
+150:770
+150:772
+150:773
+150:774
+150:775
+150:776
+150:777
+150:778
+150:779
+150:780
+150:781
+150:782
+150:786
+150:787
+150:788
+150:789
+150:790
+150:791
+150:792
+150:793
+150:794
+150:795
+150:799
+150:800
+150:801
+150:802
+150:803
+150:805
+150:806
+150:807
+150:808
+150:810
+150:811
+150:812
+155:817
+155:818
+155:820
+155:821
+155:822
+155:823
+155:886
+155:887
+155:888
+156:825
+156:826
+156:827
+156:828
+156:829
+156:830
+156:832
+156:833
+156:834
+156:835
+156:836
+156:837
+156:838
+156:839
+156:840
+156:841
+156:842
+156:846
+156:847
+156:848
+156:849
+156:850
+156:851
+156:852
+156:853
+156:854
+156:855
+156:859
+156:860
+156:861
+156:862
+156:863
+156:864
+156:865
+156:866
+156:867
+156:868
+156:872
+156:873
+156:874
+156:875
+156:876
+156:878
+156:879
+156:880
+156:881
+156:883
+156:884
+156:885
+160:890
+160:891
+160:893
+160:894
+160:895
+160:896
+160:898
+160:949
+160:950
+160:951
+160:952
+160:953
+160:954
+160:955
+160:956
+161:899
+161:900
+161:901
+161:902
+161:903
+161:904
+161:905
+161:906
+161:908
+161:909
+161:910
+161:911
+162:916
+162:917
+162:918
+162:919
+162:920
+162:921
+162:922
+162:923
+162:925
+162:926
+162:927
+163:930
+163:931
+163:932
+163:933
+163:934
+163:935
+163:936
+163:937
+163:938
+163:939
+163:940
+163:941
+163:942
+163:943
+163:944
+163:945
+163:946
+164:913
+166:958
+166:959
+166:961
+166:962
+166:963
+166:966
+166:968
+166:997
+166:1033
+166:1038
+166:1039
+166:1040
+166:1041
+166:1042
+166:1043
+166:1044
+166:1045
+167:969
+167:970
+167:971
+167:972
+167:973
+167:974
+167:975
+167:976
+167:977
+167:978
+168:983
+168:984
+168:985
+168:986
+168:987
+168:988
+168:989
+168:990
+168:991
+168:992
+170:980
+171:994
+171:998
+171:999
+171:1000
+171:1001
+171:1002
+171:1003
+171:1005
+171:1006
+171:1007
+171:1009
+171:1010
+171:1011
+171:1012
+171:1013
+171:1014
+171:1015
+171:1016
+172:964
+172:965
+172:1017
+172:1018
+172:1019
+172:1020
+172:1021
+172:1022
+172:1024
+172:1025
+172:1026
+173:1027
+173:1028
+173:1029
+173:1030
+175:1034
+175:1035
+175:1036
+175:1037
+176:1032
+179:1047
+179:1048
+179:1050
+179:1051
+179:1052
+179:1054
+179:1122
+179:1123
+179:1124
+179:1125
+179:1126
+179:1127
+179:1128
+179:1129
+180:1055
+180:1056
+180:1057
+180:1058
+180:1059
+180:1060
+180:1061
+180:1062
+180:1063
+180:1064
+181:1067
+181:1068
+181:1069
+181:1070
+181:1071
+181:1072
+182:1077
+182:1078
+182:1079
+182:1080
+182:1081
+182:1082
+182:1083
+182:1084
+183:1089
+183:1090
+183:1091
+183:1092
+183:1093
+183:1094
+183:1095
+183:1096
+184:1074
+184:1101
+184:1102
+184:1103
+184:1104
+184:1105
+184:1106
+184:1107
+184:1108
+185:1086
+185:1113
+185:1114
+185:1115
+185:1116
+185:1117
+185:1118
+186:1098
+187:1110
+187:1119
+190:1232
+190:1234
+190:1235
+190:1237
+190:1238
+190:1239
+190:1265
+190:1266
+190:1267
+191:1233
+191:1241
+191:1242
+191:1243
+191:1244
+192:1245
+192:1246
+192:1247
+192:1257
+192:1258
+192:1259
+192:1260
+192:1262
+192:1263
+192:1264
+198:1248
+198:1249
+198:1250
+198:1251
+198:1252
+198:1253
+198:1254
+198:1255
+198:1256
+202:1131
+202:1132
+202:1134
+202:1135
+202:1136
+202:1150
+202:1223
+202:1224
+202:1225
+202:1226
+202:1227
+202:1228
+202:1229
+202:1230
+203:1137
+203:1138
+203:1151
+203:1152
+203:1153
+203:1154
+203:1155
+203:1156
+203:1157
+203:1158
+204:1139
+204:1140
+204:1163
+204:1164
+204:1165
+204:1166
+204:1167
+204:1168
+204:1169
+204:1170
+205:1141
+205:1142
+205:1175
+205:1176
+205:1177
+205:1178
+205:1179
+205:1180
+205:1181
+205:1182
+206:1143
+206:1144
+206:1160
+206:1187
+206:1188
+206:1189
+206:1190
+206:1191
+206:1192
+206:1193
+206:1194
+207:1145
+207:1146
+207:1172
+207:1199
+207:1200
+207:1201
+207:1202
+207:1203
+207:1204
+207:1205
+207:1206
+208:1147
+208:1148
+208:1184
+208:1211
+208:1212
+208:1213
+208:1214
+208:1215
+208:1216
+208:1217
+208:1218
+209:1196
+210:1208
+211:1220
+*E
diff --git a/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.java b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.java
new file mode 100644
index 000000000..9387c93f9
--- /dev/null
+++ b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.java
@@ -0,0 +1,122 @@
+// $ANTLR 2.7.7 (20080530): "java-expression.g" -> "JavaLexer.java"$
+
+ package gnu.classpath.tools.gjdoc.expr;
+
+public interface JavaTokenTypes {
+ int EOF = 1;
+ int NULL_TREE_LOOKAHEAD = 3;
+ int BLOCK = 4;
+ int MODIFIERS = 5;
+ int OBJBLOCK = 6;
+ int SLIST = 7;
+ int CTOR_DEF = 8;
+ int METHOD_DEF = 9;
+ int VARIABLE_DEF = 10;
+ int INSTANCE_INIT = 11;
+ int STATIC_INIT = 12;
+ int TYPE = 13;
+ int CLASS_DEF = 14;
+ int INTERFACE_DEF = 15;
+ int PACKAGE_DEF = 16;
+ int ARRAY_DECLARATOR = 17;
+ int EXTENDS_CLAUSE = 18;
+ int IMPLEMENTS_CLAUSE = 19;
+ int PARAMETERS = 20;
+ int PARAMETER_DEF = 21;
+ int LABELED_STAT = 22;
+ int TYPECAST = 23;
+ int INDEX_OP = 24;
+ int POST_INC = 25;
+ int POST_DEC = 26;
+ int METHOD_CALL = 27;
+ int EXPR = 28;
+ int ARRAY_INIT = 29;
+ int IMPORT = 30;
+ int UNARY_MINUS = 31;
+ int UNARY_PLUS = 32;
+ int CASE_GROUP = 33;
+ int ELIST = 34;
+ int FOR_INIT = 35;
+ int FOR_CONDITION = 36;
+ int FOR_ITERATOR = 37;
+ int EMPTY_STAT = 38;
+ int FINAL = 39;
+ int ABSTRACT = 40;
+ int STRICTFP = 41;
+ int SUPER_CTOR_CALL = 42;
+ int CTOR_CALL = 43;
+ int LBRACK = 44;
+ int RBRACK = 45;
+ int LITERAL_void = 46;
+ int LITERAL_boolean = 47;
+ int LITERAL_byte = 48;
+ int LITERAL_char = 49;
+ int LITERAL_short = 50;
+ int LITERAL_int = 51;
+ int LITERAL_float = 52;
+ int LITERAL_long = 53;
+ int LITERAL_double = 54;
+ int LITERAL_String = 55;
+ int IDENT = 56;
+ int DOT = 57;
+ int QUESTION = 58;
+ int COLON = 59;
+ int LOR = 60;
+ int LAND = 61;
+ int BOR = 62;
+ int BXOR = 63;
+ int BAND = 64;
+ int NOT_EQUAL = 65;
+ int EQUAL = 66;
+ int LT = 67;
+ int GT = 68;
+ int LE = 69;
+ int GE = 70;
+ int SL = 71;
+ int SR = 72;
+ int BSR = 73;
+ int PLUS = 74;
+ int MINUS = 75;
+ int STAR = 76;
+ int DIV = 77;
+ int MOD = 78;
+ int BNOT = 79;
+ int LNOT = 80;
+ int LPAREN = 81;
+ int RPAREN = 82;
+ int LITERAL_true = 83;
+ int LITERAL_false = 84;
+ int LITERAL_null = 85;
+ int NUM_INT = 86;
+ int CHAR_LITERAL = 87;
+ int STRING_LITERAL = 88;
+ int NUM_FLOAT = 89;
+ int NUM_LONG = 90;
+ int NUM_DOUBLE = 91;
+ int LCURLY = 92;
+ int RCURLY = 93;
+ int COMMA = 94;
+ int ASSIGN = 95;
+ int DIV_ASSIGN = 96;
+ int PLUS_ASSIGN = 97;
+ int INC = 98;
+ int MINUS_ASSIGN = 99;
+ int DEC = 100;
+ int STAR_ASSIGN = 101;
+ int MOD_ASSIGN = 102;
+ int SR_ASSIGN = 103;
+ int BSR_ASSIGN = 104;
+ int SL_ASSIGN = 105;
+ int BXOR_ASSIGN = 106;
+ int BOR_ASSIGN = 107;
+ int BAND_ASSIGN = 108;
+ int SEMI = 109;
+ int WS = 110;
+ int SL_COMMIT = 111;
+ int ML_COMMENT = 112;
+ int ESC = 113;
+ int HEX_DIGIT = 114;
+ int VOCAB = 115;
+ int EXPONENT = 116;
+ int FLOAT_SUFFIX = 117;
+}
diff --git a/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.txt b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.txt
new file mode 100644
index 000000000..b9983e22f
--- /dev/null
+++ b/libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc/expr/JavaTokenTypes.txt
@@ -0,0 +1,116 @@
+// $ANTLR 2.7.7 (20080530): java-expression.g -> JavaTokenTypes.txt$
+Java // output token vocab name
+BLOCK=4
+MODIFIERS=5
+OBJBLOCK=6
+SLIST=7
+CTOR_DEF=8
+METHOD_DEF=9
+VARIABLE_DEF=10
+INSTANCE_INIT=11
+STATIC_INIT=12
+TYPE=13
+CLASS_DEF=14
+INTERFACE_DEF=15
+PACKAGE_DEF=16
+ARRAY_DECLARATOR=17
+EXTENDS_CLAUSE=18
+IMPLEMENTS_CLAUSE=19
+PARAMETERS=20
+PARAMETER_DEF=21
+LABELED_STAT=22
+TYPECAST=23
+INDEX_OP=24
+POST_INC=25
+POST_DEC=26
+METHOD_CALL=27
+EXPR=28
+ARRAY_INIT=29
+IMPORT=30
+UNARY_MINUS=31
+UNARY_PLUS=32
+CASE_GROUP=33
+ELIST=34
+FOR_INIT=35
+FOR_CONDITION=36
+FOR_ITERATOR=37
+EMPTY_STAT=38
+FINAL="final"=39
+ABSTRACT="abstract"=40
+STRICTFP="strictfp"=41
+SUPER_CTOR_CALL=42
+CTOR_CALL=43
+LBRACK=44
+RBRACK=45
+LITERAL_void="void"=46
+LITERAL_boolean="boolean"=47
+LITERAL_byte="byte"=48
+LITERAL_char="char"=49
+LITERAL_short="short"=50
+LITERAL_int="int"=51
+LITERAL_float="float"=52
+LITERAL_long="long"=53
+LITERAL_double="double"=54
+LITERAL_String="String"=55
+IDENT=56
+DOT=57
+QUESTION=58
+COLON=59
+LOR=60
+LAND=61
+BOR=62
+BXOR=63
+BAND=64
+NOT_EQUAL=65
+EQUAL=66
+LT=67
+GT=68
+LE=69
+GE=70
+SL=71
+SR=72
+BSR=73
+PLUS=74
+MINUS=75
+STAR=76
+DIV=77
+MOD=78
+BNOT=79
+LNOT=80
+LPAREN=81
+RPAREN=82
+LITERAL_true="true"=83
+LITERAL_false="false"=84
+LITERAL_null="null"=85
+NUM_INT=86
+CHAR_LITERAL=87
+STRING_LITERAL=88
+NUM_FLOAT=89
+NUM_LONG=90
+NUM_DOUBLE=91
+LCURLY=92
+RCURLY=93
+COMMA=94
+ASSIGN=95
+DIV_ASSIGN=96
+PLUS_ASSIGN=97
+INC=98
+MINUS_ASSIGN=99
+DEC=100
+STAR_ASSIGN=101
+MOD_ASSIGN=102
+SR_ASSIGN=103
+BSR_ASSIGN=104
+SL_ASSIGN=105
+BXOR_ASSIGN=106
+BOR_ASSIGN=107
+BAND_ASSIGN=108
+SEMI=109
+WS=110
+SL_COMMIT=111
+ML_COMMENT=112
+ESC=113
+HEX_DIGIT=114
+VOCAB=115
+EXPONENT=116
+FLOAT_SUFFIX=117
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-25 17:46:51 +0000