diff options
Diffstat (limited to 'libjava/classpath/tools/generated/gnu/classpath/tools/gjdoc')
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 00000000000..053f122f0b6 --- /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 00000000000..045e3e308ea --- /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 00000000000..9dfc9db38a5 --- /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 00000000000..667caad55ff --- /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 00000000000..2962388f402 --- /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 00000000000..b9983e22f48 --- /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 |