summaryrefslogtreecommitdiffstats
path: root/languages/java/JavaLexer.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit114a878c64ce6f8223cfd22d76a20eb16d177e5e (patch)
treeacaf47eb0fa12142d3896416a69e74cbf5a72242 /languages/java/JavaLexer.cpp
downloadtdevelop-114a878c64ce6f8223cfd22d76a20eb16d177e5e.tar.gz
tdevelop-114a878c64ce6f8223cfd22d76a20eb16d177e5e.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'languages/java/JavaLexer.cpp')
-rw-r--r--languages/java/JavaLexer.cpp2183
1 files changed, 2183 insertions, 0 deletions
diff --git a/languages/java/JavaLexer.cpp b/languages/java/JavaLexer.cpp
new file mode 100644
index 00000000..623e816f
--- /dev/null
+++ b/languages/java/JavaLexer.cpp
@@ -0,0 +1,2183 @@
+/* $ANTLR 2.7.7 (20061129): "java.g" -> "JavaLexer.cpp"$ */
+#include "JavaLexer.hpp"
+#include <antlr/CharBuffer.hpp>
+#include <antlr/TokenStreamException.hpp>
+#include <antlr/TokenStreamIOException.hpp>
+#include <antlr/TokenStreamRecognitionException.hpp>
+#include <antlr/CharStreamException.hpp>
+#include <antlr/CharStreamIOException.hpp>
+#include <antlr/NoViableAltForCharException.hpp>
+
+#line 1041 "java.g"
+
+#include <string>
+
+#line 16 "JavaLexer.cpp"
+JavaLexer::JavaLexer(ANTLR_USE_NAMESPACE(std)istream& in)
+ : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true)
+{
+ initLiterals();
+}
+
+JavaLexer::JavaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
+ : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
+{
+ initLiterals();
+}
+
+JavaLexer::JavaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
+ : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true)
+{
+ initLiterals();
+}
+
+void JavaLexer::initLiterals()
+{
+ literals["byte"] = 51;
+ literals["public"] = 62;
+ literals["case"] = 94;
+ literals["short"] = 53;
+ literals["break"] = 89;
+ literals["while"] = 87;
+ literals["new"] = 137;
+ literals["instanceof"] = 122;
+ literals["implements"] = 76;
+ literals["synchronized"] = 68;
+ literals["float"] = 55;
+ literals["package"] = 44;
+ literals["return"] = 91;
+ literals["throw"] = 93;
+ literals["null"] = 136;
+ literals["threadsafe"] = 67;
+ literals["protected"] = 63;
+ literals["class"] = 70;
+ literals["throws"] = 82;
+ literals["do"] = 88;
+ literals["strictfp"] = 41;
+ literals["super"] = 80;
+ literals["transient"] = 65;
+ literals["native"] = 66;
+ literals["interface"] = 72;
+ literals["final"] = 39;
+ literals["if"] = 84;
+ literals["double"] = 57;
+ literals["volatile"] = 69;
+ literals["catch"] = 98;
+ literals["try"] = 96;
+ literals["int"] = 54;
+ literals["for"] = 86;
+ literals["extends"] = 71;
+ literals["boolean"] = 50;
+ literals["char"] = 52;
+ literals["private"] = 61;
+ literals["default"] = 95;
+ literals["false"] = 135;
+ literals["this"] = 79;
+ literals["static"] = 64;
+ literals["abstract"] = 40;
+ literals["continue"] = 90;
+ literals["finally"] = 97;
+ literals["else"] = 85;
+ literals["import"] = 46;
+ literals["void"] = 49;
+ literals["switch"] = 92;
+ literals["true"] = 134;
+ literals["long"] = 56;
+}
+
+ANTLR_USE_NAMESPACE(antlr)RefToken JavaLexer::nextToken()
+{
+ ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
+ for (;;) {
+ ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
+ int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
+ resetText();
+ try { // for lexical and char stream error handling
+ switch ( LA(1)) {
+ case 0x3f /* '?' */ :
+ {
+ mQUESTION(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x28 /* '(' */ :
+ {
+ mLPAREN(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x29 /* ')' */ :
+ {
+ mRPAREN(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x5b /* '[' */ :
+ {
+ mLBRACK(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x5d /* ']' */ :
+ {
+ mRBRACK(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x7b /* '{' */ :
+ {
+ mLCURLY(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x7d /* '}' */ :
+ {
+ mRCURLY(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x3a /* ':' */ :
+ {
+ mCOLON(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x2c /* ',' */ :
+ {
+ mCOMMA(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x7e /* '~' */ :
+ {
+ mBNOT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x3b /* ';' */ :
+ {
+ mSEMI(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x9 /* '\t' */ :
+ case 0xa /* '\n' */ :
+ case 0xc /* '\14' */ :
+ case 0xd /* '\r' */ :
+ case 0x20 /* ' ' */ :
+ {
+ mWS(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x27 /* '\'' */ :
+ {
+ mCHAR_LITERAL(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x22 /* '\"' */ :
+ {
+ mSTRING_LITERAL(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x24 /* '$' */ :
+ case 0x41 /* 'A' */ :
+ case 0x42 /* 'B' */ :
+ case 0x43 /* 'C' */ :
+ case 0x44 /* 'D' */ :
+ case 0x45 /* 'E' */ :
+ case 0x46 /* 'F' */ :
+ case 0x47 /* 'G' */ :
+ case 0x48 /* 'H' */ :
+ case 0x49 /* 'I' */ :
+ case 0x4a /* 'J' */ :
+ case 0x4b /* 'K' */ :
+ case 0x4c /* 'L' */ :
+ case 0x4d /* 'M' */ :
+ case 0x4e /* 'N' */ :
+ case 0x4f /* 'O' */ :
+ case 0x50 /* 'P' */ :
+ case 0x51 /* 'Q' */ :
+ case 0x52 /* 'R' */ :
+ case 0x53 /* 'S' */ :
+ case 0x54 /* 'T' */ :
+ case 0x55 /* 'U' */ :
+ case 0x56 /* 'V' */ :
+ case 0x57 /* 'W' */ :
+ case 0x58 /* 'X' */ :
+ case 0x59 /* 'Y' */ :
+ case 0x5a /* 'Z' */ :
+ case 0x5f /* '_' */ :
+ case 0x61 /* 'a' */ :
+ case 0x62 /* 'b' */ :
+ case 0x63 /* 'c' */ :
+ case 0x64 /* 'd' */ :
+ case 0x65 /* 'e' */ :
+ case 0x66 /* 'f' */ :
+ case 0x67 /* 'g' */ :
+ case 0x68 /* 'h' */ :
+ case 0x69 /* 'i' */ :
+ case 0x6a /* 'j' */ :
+ case 0x6b /* 'k' */ :
+ case 0x6c /* 'l' */ :
+ case 0x6d /* 'm' */ :
+ case 0x6e /* 'n' */ :
+ case 0x6f /* 'o' */ :
+ case 0x70 /* 'p' */ :
+ case 0x71 /* 'q' */ :
+ case 0x72 /* 'r' */ :
+ case 0x73 /* 's' */ :
+ case 0x74 /* 't' */ :
+ case 0x75 /* 'u' */ :
+ case 0x76 /* 'v' */ :
+ case 0x77 /* 'w' */ :
+ case 0x78 /* 'x' */ :
+ case 0x79 /* 'y' */ :
+ case 0x7a /* 'z' */ :
+ {
+ mIDENT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ case 0x2e /* '.' */ :
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ case 0x38 /* '8' */ :
+ case 0x39 /* '9' */ :
+ {
+ mNUM_INT(true);
+ theRetToken=_returnToken;
+ break;
+ }
+ default:
+ if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3e /* '>' */ ) && (LA(3) == 0x3e /* '>' */ ) && (LA(4) == 0x3d /* '=' */ )) {
+ mBSR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3e /* '>' */ ) && (LA(3) == 0x3d /* '=' */ )) {
+ mSR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3e /* '>' */ ) && (LA(3) == 0x3e /* '>' */ ) && (true)) {
+ mBSR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3c /* '<' */ ) && (LA(3) == 0x3d /* '=' */ )) {
+ mSL_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3d /* '=' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mEQUAL(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x21 /* '!' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mNOT_EQUAL(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mDIV_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2b /* '+' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mPLUS_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2b /* '+' */ ) && (LA(2) == 0x2b /* '+' */ )) {
+ mINC(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mMINUS_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x2d /* '-' */ )) {
+ mDEC(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2a /* '*' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mSTAR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x25 /* '%' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mMOD_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3e /* '>' */ ) && (true)) {
+ mSR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mGE(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3c /* '<' */ ) && (true)) {
+ mSL(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mLE(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x5e /* '^' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mBXOR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x7c /* '|' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mBOR_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x7c /* '|' */ ) && (LA(2) == 0x7c /* '|' */ )) {
+ mLOR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x26 /* '&' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+ mBAND_ASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x26 /* '&' */ ) && (LA(2) == 0x26 /* '&' */ )) {
+ mLAND(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) {
+ mSL_COMMENT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2a /* '*' */ )) {
+ mML_COMMENT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3d /* '=' */ ) && (true)) {
+ mASSIGN(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x21 /* '!' */ ) && (true)) {
+ mLNOT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2f /* '/' */ ) && (true)) {
+ mDIV(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2b /* '+' */ ) && (true)) {
+ mPLUS(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2d /* '-' */ ) && (true)) {
+ mMINUS(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x2a /* '*' */ ) && (true)) {
+ mSTAR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x25 /* '%' */ ) && (true)) {
+ mMOD(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3e /* '>' */ ) && (true)) {
+ mGT(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x3c /* '<' */ ) && (true)) {
+ mLT_(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x5e /* '^' */ ) && (true)) {
+ mBXOR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x7c /* '|' */ ) && (true)) {
+ mBOR(true);
+ theRetToken=_returnToken;
+ }
+ else if ((LA(1) == 0x26 /* '&' */ ) && (true)) {
+ mBAND(true);
+ theRetToken=_returnToken;
+ }
+ else {
+ if (LA(1)==EOF_CHAR)
+ {
+ uponEOF();
+ _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
+ }
+ else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+ }
+ if ( !_returnToken )
+ goto tryAgain; // found SKIP token
+
+ _ttype = _returnToken->getType();
+ _returnToken->setType(_ttype);
+ return _returnToken;
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
+ throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
+ throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
+ throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
+ }
+tryAgain:;
+ }
+}
+
+void JavaLexer::mQUESTION(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = QUESTION;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('?' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLPAREN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LPAREN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('(' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mRPAREN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = RPAREN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(')' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLBRACK(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LBRACK;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('[' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mRBRACK(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = RBRACK;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(']' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLCURLY(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LCURLY;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('{' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mRCURLY(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = RCURLY;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('}' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mCOLON(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = COLON;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(':' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mCOMMA(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = COMMA;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(',' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('=' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mEQUAL(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = EQUAL;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("==");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLNOT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LNOT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('!' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBNOT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BNOT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('~' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mNOT_EQUAL(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = NOT_EQUAL;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("!=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mDIV(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = DIV;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('/' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mDIV_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = DIV_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("/=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mPLUS(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = PLUS;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('+' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mPLUS_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = PLUS_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("+=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mINC(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = INC;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("++");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mMINUS(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = MINUS;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('-' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mMINUS_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = MINUS_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("-=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mDEC(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = DEC;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("--");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSTAR(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = STAR;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('*' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSTAR_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = STAR_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("*=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mMOD(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = MOD;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('%' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mMOD_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = MOD_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("%=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSR(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = SR;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">>");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSR_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = SR_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">>=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBSR(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BSR;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">>>");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBSR_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BSR_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">>>=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mGE(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = GE;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mGT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = GT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(">");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSL(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = SL;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("<<");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSL_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = SL_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("<<=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLE(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LE;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("<=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLT_(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LT_;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('<' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBXOR(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BXOR;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('^' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBXOR_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BXOR_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("^=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBOR(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BOR;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('|' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBOR_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BOR_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("|=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLOR(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LOR;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("||");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBAND(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BAND;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('&' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mBAND_ASSIGN(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = BAND_ASSIGN;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("&=");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mLAND(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = LAND;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("&&");
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSEMI(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = SEMI;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match(';' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mWS(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = WS;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ { // ( ... )+
+ int _cnt245=0;
+ for (;;) {
+ switch ( LA(1)) {
+ case 0x20 /* ' ' */ :
+ {
+ match(' ' /* charlit */ );
+ break;
+ }
+ case 0x9 /* '\t' */ :
+ {
+ match('\t' /* charlit */ );
+ break;
+ }
+ case 0xc /* '\14' */ :
+ {
+ match('\14' /* charlit */ );
+ break;
+ }
+ case 0xa /* '\n' */ :
+ case 0xd /* '\r' */ :
+ {
+ {
+ if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && (true) && (true)) {
+ match("\r\n");
+ }
+ else if ((LA(1) == 0xd /* '\r' */ ) && (true) && (true) && (true)) {
+ match('\r' /* charlit */ );
+ }
+ else if ((LA(1) == 0xa /* '\n' */ )) {
+ match('\n' /* charlit */ );
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+#line 1137 "java.g"
+ newline();
+#line 1109 "JavaLexer.cpp"
+ break;
+ }
+ default:
+ {
+ if ( _cnt245>=1 ) { goto _loop245; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+ }
+ _cnt245++;
+ }
+ _loop245:;
+ } // ( ... )+
+#line 1139 "java.g"
+ _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+#line 1123 "JavaLexer.cpp"
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSL_COMMENT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = SL_COMMENT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("//");
+ { // ( ... )*
+ for (;;) {
+ if ((_tokenSet_0.member(LA(1)))) {
+ {
+ match(_tokenSet_0);
+ }
+ }
+ else {
+ goto _loop249;
+ }
+
+ }
+ _loop249:;
+ } // ( ... )*
+ {
+ switch ( LA(1)) {
+ case 0xa /* '\n' */ :
+ {
+ match('\n' /* charlit */ );
+ break;
+ }
+ case 0xd /* '\r' */ :
+ {
+ match('\r' /* charlit */ );
+ {
+ if ((LA(1) == 0xa /* '\n' */ )) {
+ match('\n' /* charlit */ );
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+#line 1146 "java.g"
+
+ _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+ newline();
+
+#line 1183 "JavaLexer.cpp"
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mML_COMMENT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = ML_COMMENT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match("/*");
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && ((LA(3) >= 0x3 /* '\3' */ && LA(3) <= 0xff)) && ((LA(4) >= 0x3 /* '\3' */ && LA(4) <= 0xff))) {
+ match('\r' /* charlit */ );
+ match('\n' /* charlit */ );
+#line 1167 "java.g"
+ newline();
+#line 1205 "JavaLexer.cpp"
+ }
+ else if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */ && LA(3) <= 0xff)))&&( LA(2)!='/' )) {
+ match('*' /* charlit */ );
+ }
+ else if ((LA(1) == 0xd /* '\r' */ ) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)) && ((LA(3) >= 0x3 /* '\3' */ && LA(3) <= 0xff)) && (true)) {
+ match('\r' /* charlit */ );
+#line 1168 "java.g"
+ newline();
+#line 1214 "JavaLexer.cpp"
+ }
+ else if ((LA(1) == 0xa /* '\n' */ )) {
+ match('\n' /* charlit */ );
+#line 1169 "java.g"
+ newline();
+#line 1220 "JavaLexer.cpp"
+ }
+ else if ((_tokenSet_1.member(LA(1)))) {
+ {
+ match(_tokenSet_1);
+ }
+ }
+ else {
+ goto _loop255;
+ }
+
+ }
+ _loop255:;
+ } // ( ... )*
+ match("*/");
+#line 1173 "java.g"
+ _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+#line 1237 "JavaLexer.cpp"
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mCHAR_LITERAL(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = CHAR_LITERAL;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('\'' /* charlit */ );
+ {
+ if ((LA(1) == 0x5c /* '\\' */ )) {
+ mESC(false);
+ }
+ else if ((_tokenSet_2.member(LA(1)))) {
+ matchNot('\'' /* charlit */ );
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ match('\'' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mESC(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = ESC;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('\\' /* charlit */ );
+ {
+ switch ( LA(1)) {
+ case 0x6e /* 'n' */ :
+ {
+ match('n' /* charlit */ );
+ break;
+ }
+ case 0x72 /* 'r' */ :
+ {
+ match('r' /* charlit */ );
+ break;
+ }
+ case 0x74 /* 't' */ :
+ {
+ match('t' /* charlit */ );
+ break;
+ }
+ case 0x62 /* 'b' */ :
+ {
+ match('b' /* charlit */ );
+ break;
+ }
+ case 0x66 /* 'f' */ :
+ {
+ match('f' /* charlit */ );
+ break;
+ }
+ case 0x22 /* '\"' */ :
+ {
+ match('\"' /* charlit */ );
+ break;
+ }
+ case 0x27 /* '\'' */ :
+ {
+ match('\'' /* charlit */ );
+ break;
+ }
+ case 0x5c /* '\\' */ :
+ {
+ match('\\' /* charlit */ );
+ break;
+ }
+ case 0x75 /* 'u' */ :
+ {
+ { // ( ... )+
+ int _cnt265=0;
+ for (;;) {
+ if ((LA(1) == 0x75 /* 'u' */ )) {
+ match('u' /* charlit */ );
+ }
+ else {
+ if ( _cnt265>=1 ) { goto _loop265; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt265++;
+ }
+ _loop265:;
+ } // ( ... )+
+ mHEX_DIGIT(false);
+ mHEX_DIGIT(false);
+ mHEX_DIGIT(false);
+ mHEX_DIGIT(false);
+ break;
+ }
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ {
+ matchRange('0','3');
+ {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ )) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)) && (true) && (true)) {
+ matchRange('0','7');
+ {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ )) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)) && (true) && (true)) {
+ matchRange('0','7');
+ }
+ else if (((LA(1) >= 0x3 /* '\3' */ && LA(1) <= 0xff)) && (true) && (true) && (true)) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ }
+ else if (((LA(1) >= 0x3 /* '\3' */ && LA(1) <= 0xff)) && (true) && (true) && (true)) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ break;
+ }
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ {
+ matchRange('4','7');
+ {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ )) && ((LA(2) >= 0x3 /* '\3' */ && LA(2) <= 0xff)) && (true) && (true)) {
+ matchRange('0','7');
+ }
+ else if (((LA(1) >= 0x3 /* '\3' */ && LA(1) <= 0xff)) && (true) && (true) && (true)) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mSTRING_LITERAL(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = STRING_LITERAL;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ match('\"' /* charlit */ );
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == 0x5c /* '\\' */ )) {
+ mESC(false);
+ }
+ else if ((_tokenSet_3.member(LA(1)))) {
+ {
+ match(_tokenSet_3);
+ }
+ }
+ else {
+ goto _loop261;
+ }
+
+ }
+ _loop261:;
+ } // ( ... )*
+ match('\"' /* charlit */ );
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mHEX_DIGIT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = HEX_DIGIT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ case 0x38 /* '8' */ :
+ case 0x39 /* '9' */ :
+ {
+ matchRange('0','9');
+ break;
+ }
+ case 0x41 /* 'A' */ :
+ case 0x42 /* 'B' */ :
+ case 0x43 /* 'C' */ :
+ case 0x44 /* 'D' */ :
+ case 0x45 /* 'E' */ :
+ case 0x46 /* 'F' */ :
+ {
+ matchRange('A','F');
+ break;
+ }
+ case 0x61 /* 'a' */ :
+ case 0x62 /* 'b' */ :
+ case 0x63 /* 'c' */ :
+ case 0x64 /* 'd' */ :
+ case 0x65 /* 'e' */ :
+ case 0x66 /* 'f' */ :
+ {
+ matchRange('a','f');
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mVOCAB(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = VOCAB;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ matchRange('\3',static_cast<unsigned char>('\377'));
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mIDENT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = IDENT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ case 0x61 /* 'a' */ :
+ case 0x62 /* 'b' */ :
+ case 0x63 /* 'c' */ :
+ case 0x64 /* 'd' */ :
+ case 0x65 /* 'e' */ :
+ case 0x66 /* 'f' */ :
+ case 0x67 /* 'g' */ :
+ case 0x68 /* 'h' */ :
+ case 0x69 /* 'i' */ :
+ case 0x6a /* 'j' */ :
+ case 0x6b /* 'k' */ :
+ case 0x6c /* 'l' */ :
+ case 0x6d /* 'm' */ :
+ case 0x6e /* 'n' */ :
+ case 0x6f /* 'o' */ :
+ case 0x70 /* 'p' */ :
+ case 0x71 /* 'q' */ :
+ case 0x72 /* 'r' */ :
+ case 0x73 /* 's' */ :
+ case 0x74 /* 't' */ :
+ case 0x75 /* 'u' */ :
+ case 0x76 /* 'v' */ :
+ case 0x77 /* 'w' */ :
+ case 0x78 /* 'x' */ :
+ case 0x79 /* 'y' */ :
+ case 0x7a /* 'z' */ :
+ {
+ matchRange('a','z');
+ break;
+ }
+ case 0x41 /* 'A' */ :
+ case 0x42 /* 'B' */ :
+ case 0x43 /* 'C' */ :
+ case 0x44 /* 'D' */ :
+ case 0x45 /* 'E' */ :
+ case 0x46 /* 'F' */ :
+ case 0x47 /* 'G' */ :
+ case 0x48 /* 'H' */ :
+ case 0x49 /* 'I' */ :
+ case 0x4a /* 'J' */ :
+ case 0x4b /* 'K' */ :
+ case 0x4c /* 'L' */ :
+ case 0x4d /* 'M' */ :
+ case 0x4e /* 'N' */ :
+ case 0x4f /* 'O' */ :
+ case 0x50 /* 'P' */ :
+ case 0x51 /* 'Q' */ :
+ case 0x52 /* 'R' */ :
+ case 0x53 /* 'S' */ :
+ case 0x54 /* 'T' */ :
+ case 0x55 /* 'U' */ :
+ case 0x56 /* 'V' */ :
+ case 0x57 /* 'W' */ :
+ case 0x58 /* 'X' */ :
+ case 0x59 /* 'Y' */ :
+ case 0x5a /* 'Z' */ :
+ {
+ matchRange('A','Z');
+ break;
+ }
+ case 0x5f /* '_' */ :
+ {
+ match('_' /* charlit */ );
+ break;
+ }
+ case 0x24 /* '$' */ :
+ {
+ match('$' /* charlit */ );
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case 0x61 /* 'a' */ :
+ case 0x62 /* 'b' */ :
+ case 0x63 /* 'c' */ :
+ case 0x64 /* 'd' */ :
+ case 0x65 /* 'e' */ :
+ case 0x66 /* 'f' */ :
+ case 0x67 /* 'g' */ :
+ case 0x68 /* 'h' */ :
+ case 0x69 /* 'i' */ :
+ case 0x6a /* 'j' */ :
+ case 0x6b /* 'k' */ :
+ case 0x6c /* 'l' */ :
+ case 0x6d /* 'm' */ :
+ case 0x6e /* 'n' */ :
+ case 0x6f /* 'o' */ :
+ case 0x70 /* 'p' */ :
+ case 0x71 /* 'q' */ :
+ case 0x72 /* 'r' */ :
+ case 0x73 /* 's' */ :
+ case 0x74 /* 't' */ :
+ case 0x75 /* 'u' */ :
+ case 0x76 /* 'v' */ :
+ case 0x77 /* 'w' */ :
+ case 0x78 /* 'x' */ :
+ case 0x79 /* 'y' */ :
+ case 0x7a /* 'z' */ :
+ {
+ matchRange('a','z');
+ break;
+ }
+ case 0x41 /* 'A' */ :
+ case 0x42 /* 'B' */ :
+ case 0x43 /* 'C' */ :
+ case 0x44 /* 'D' */ :
+ case 0x45 /* 'E' */ :
+ case 0x46 /* 'F' */ :
+ case 0x47 /* 'G' */ :
+ case 0x48 /* 'H' */ :
+ case 0x49 /* 'I' */ :
+ case 0x4a /* 'J' */ :
+ case 0x4b /* 'K' */ :
+ case 0x4c /* 'L' */ :
+ case 0x4d /* 'M' */ :
+ case 0x4e /* 'N' */ :
+ case 0x4f /* 'O' */ :
+ case 0x50 /* 'P' */ :
+ case 0x51 /* 'Q' */ :
+ case 0x52 /* 'R' */ :
+ case 0x53 /* 'S' */ :
+ case 0x54 /* 'T' */ :
+ case 0x55 /* 'U' */ :
+ case 0x56 /* 'V' */ :
+ case 0x57 /* 'W' */ :
+ case 0x58 /* 'X' */ :
+ case 0x59 /* 'Y' */ :
+ case 0x5a /* 'Z' */ :
+ {
+ matchRange('A','Z');
+ break;
+ }
+ case 0x5f /* '_' */ :
+ {
+ match('_' /* charlit */ );
+ break;
+ }
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ case 0x38 /* '8' */ :
+ case 0x39 /* '9' */ :
+ {
+ matchRange('0','9');
+ break;
+ }
+ case 0x24 /* '$' */ :
+ {
+ match('$' /* charlit */ );
+ break;
+ }
+ default:
+ {
+ goto _loop275;
+ }
+ }
+ }
+ _loop275:;
+ } // ( ... )*
+ _ttype = testLiteralsTable(_ttype);
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mNUM_INT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = NUM_INT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+ ANTLR_USE_NAMESPACE(antlr)RefToken f1;
+ ANTLR_USE_NAMESPACE(antlr)RefToken f2;
+ ANTLR_USE_NAMESPACE(antlr)RefToken f3;
+ ANTLR_USE_NAMESPACE(antlr)RefToken f4;
+#line 1251 "java.g"
+
+ bool isDecimal = false;
+ ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
+
+#line 1707 "JavaLexer.cpp"
+
+ switch ( LA(1)) {
+ case 0x2e /* '.' */ :
+ {
+ match('.' /* charlit */ );
+#line 1256 "java.g"
+ _ttype = DOT;
+#line 1715 "JavaLexer.cpp"
+ {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ { // ( ... )+
+ int _cnt279=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt279>=1 ) { goto _loop279; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt279++;
+ }
+ _loop279:;
+ } // ( ... )+
+ {
+ if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) {
+ mEXPONENT(false);
+ }
+ else {
+ }
+
+ }
+ {
+ if ((LA(1) == 0x44 /* 'D' */ || LA(1) == 0x46 /* 'F' */ || LA(1) == 0x64 /* 'd' */ || LA(1) == 0x66 /* 'f' */ )) {
+ mFLOAT_SUFFIX(true);
+ f1=_returnToken;
+#line 1257 "java.g"
+ t=f1;
+#line 1746 "JavaLexer.cpp"
+ }
+ else {
+ }
+
+ }
+#line 1258 "java.g"
+
+ if ( t &&
+ (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
+ t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
+ _ttype = NUM_FLOAT;
+ }
+ else {
+ _ttype = NUM_DOUBLE; // assume double
+ }
+
+#line 1763 "JavaLexer.cpp"
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ case 0x38 /* '8' */ :
+ case 0x39 /* '9' */ :
+ {
+ {
+ switch ( LA(1)) {
+ case 0x30 /* '0' */ :
+ {
+ match('0' /* charlit */ );
+#line 1270 "java.g"
+ isDecimal = true;
+#line 1789 "JavaLexer.cpp"
+ {
+ switch ( LA(1)) {
+ case 0x58 /* 'X' */ :
+ case 0x78 /* 'x' */ :
+ {
+ {
+ switch ( LA(1)) {
+ case 0x78 /* 'x' */ :
+ {
+ match('x' /* charlit */ );
+ break;
+ }
+ case 0x58 /* 'X' */ :
+ {
+ match('X' /* charlit */ );
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ { // ( ... )+
+ int _cnt286=0;
+ for (;;) {
+ if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
+ mHEX_DIGIT(false);
+ }
+ else {
+ if ( _cnt286>=1 ) { goto _loop286; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt286++;
+ }
+ _loop286:;
+ } // ( ... )+
+ break;
+ }
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ {
+ { // ( ... )+
+ int _cnt288=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x37 /* '7' */ ))) {
+ matchRange('0','7');
+ }
+ else {
+ if ( _cnt288>=1 ) { goto _loop288; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt288++;
+ }
+ _loop288:;
+ } // ( ... )+
+ break;
+ }
+ default:
+ {
+ }
+ }
+ }
+ break;
+ }
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ case 0x38 /* '8' */ :
+ case 0x39 /* '9' */ :
+ {
+ {
+ matchRange('1','9');
+ }
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ matchRange('0','9');
+ }
+ else {
+ goto _loop291;
+ }
+
+ }
+ _loop291:;
+ } // ( ... )*
+#line 1285 "java.g"
+ isDecimal=true;
+#line 1888 "JavaLexer.cpp"
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ if ((LA(1) == 0x4c /* 'L' */ || LA(1) == 0x6c /* 'l' */ )) {
+ {
+ switch ( LA(1)) {
+ case 0x6c /* 'l' */ :
+ {
+ match('l' /* charlit */ );
+ break;
+ }
+ case 0x4c /* 'L' */ :
+ {
+ match('L' /* charlit */ );
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+#line 1287 "java.g"
+ _ttype = NUM_LONG;
+#line 1919 "JavaLexer.cpp"
+ }
+ else if (((LA(1) == 0x2e /* '.' */ || LA(1) == 0x44 /* 'D' */ || LA(1) == 0x45 /* 'E' */ || LA(1) == 0x46 /* 'F' */ || LA(1) == 0x64 /* 'd' */ || LA(1) == 0x65 /* 'e' */ || LA(1) == 0x66 /* 'f' */ ))&&(isDecimal)) {
+ {
+ switch ( LA(1)) {
+ case 0x2e /* '.' */ :
+ {
+ match('.' /* charlit */ );
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ matchRange('0','9');
+ }
+ else {
+ goto _loop296;
+ }
+
+ }
+ _loop296:;
+ } // ( ... )*
+ {
+ if ((LA(1) == 0x45 /* 'E' */ || LA(1) == 0x65 /* 'e' */ )) {
+ mEXPONENT(false);
+ }
+ else {
+ }
+
+ }
+ {
+ if ((LA(1) == 0x44 /* 'D' */ || LA(1) == 0x46 /* 'F' */ || LA(1) == 0x64 /* 'd' */ || LA(1) == 0x66 /* 'f' */ )) {
+ mFLOAT_SUFFIX(true);
+ f2=_returnToken;
+#line 1291 "java.g"
+ t=f2;
+#line 1953 "JavaLexer.cpp"
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 0x45 /* 'E' */ :
+ case 0x65 /* 'e' */ :
+ {
+ mEXPONENT(false);
+ {
+ if ((LA(1) == 0x44 /* 'D' */ || LA(1) == 0x46 /* 'F' */ || LA(1) == 0x64 /* 'd' */ || LA(1) == 0x66 /* 'f' */ )) {
+ mFLOAT_SUFFIX(true);
+ f3=_returnToken;
+#line 1292 "java.g"
+ t=f3;
+#line 1971 "JavaLexer.cpp"
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ case 0x44 /* 'D' */ :
+ case 0x46 /* 'F' */ :
+ case 0x64 /* 'd' */ :
+ case 0x66 /* 'f' */ :
+ {
+ mFLOAT_SUFFIX(true);
+ f4=_returnToken;
+#line 1293 "java.g"
+ t=f4;
+#line 1988 "JavaLexer.cpp"
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+#line 1295 "java.g"
+
+ if ( t &&
+ (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
+ t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
+ _ttype = NUM_FLOAT;
+ }
+ else {
+ _ttype = NUM_DOUBLE; // assume double
+ }
+
+#line 2008 "JavaLexer.cpp"
+ }
+ else {
+ }
+
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mEXPONENT(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = EXPONENT;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ {
+ switch ( LA(1)) {
+ case 0x65 /* 'e' */ :
+ {
+ match('e' /* charlit */ );
+ break;
+ }
+ case 0x45 /* 'E' */ :
+ {
+ match('E' /* charlit */ );
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case 0x2b /* '+' */ :
+ {
+ match('+' /* charlit */ );
+ break;
+ }
+ case 0x2d /* '-' */ :
+ {
+ match('-' /* charlit */ );
+ break;
+ }
+ case 0x30 /* '0' */ :
+ case 0x31 /* '1' */ :
+ case 0x32 /* '2' */ :
+ case 0x33 /* '3' */ :
+ case 0x34 /* '4' */ :
+ case 0x35 /* '5' */ :
+ case 0x36 /* '6' */ :
+ case 0x37 /* '7' */ :
+ case 0x38 /* '8' */ :
+ case 0x39 /* '9' */ :
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ }
+ { // ( ... )+
+ int _cnt304=0;
+ for (;;) {
+ if (((LA(1) >= 0x30 /* '0' */ && LA(1) <= 0x39 /* '9' */ ))) {
+ matchRange('0','9');
+ }
+ else {
+ if ( _cnt304>=1 ) { goto _loop304; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+ }
+
+ _cnt304++;
+ }
+ _loop304:;
+ } // ( ... )+
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+void JavaLexer::mFLOAT_SUFFIX(bool _createToken) {
+ int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+ _ttype = FLOAT_SUFFIX;
+ ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+
+ switch ( LA(1)) {
+ case 0x66 /* 'f' */ :
+ {
+ match('f' /* charlit */ );
+ break;
+ }
+ case 0x46 /* 'F' */ :
+ {
+ match('F' /* charlit */ );
+ break;
+ }
+ case 0x64 /* 'd' */ :
+ {
+ match('d' /* charlit */ );
+ break;
+ }
+ case 0x44 /* 'D' */ :
+ {
+ match('D' /* charlit */ );
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+ }
+ }
+ if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+ _token = makeToken(_ttype);
+ _token->setText(text.substr(_begin, text.length()-_begin));
+ }
+ _returnToken = _token;
+ _saveIndex=0;
+}
+
+
+const unsigned long JavaLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
+// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ %
+// & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G
+// H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c d e f g h
+// i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 0x83
+// 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0x91
+// 0x92 0x93 0x94 0x95 0x96 0x97
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_0(_tokenSet_0_data_,16);
+const unsigned long JavaLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 0x13 0x14
+// 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" # $ %
+// & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H
+// I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c d e f g h i
+// j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 0x83 0x84
+// 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0x91 0x92
+// 0x93 0x94 0x95 0x96 0x97
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_1(_tokenSet_1_data_,16);
+const unsigned long JavaLexer::_tokenSet_2_data_[] = { 4294967288UL, 4294967167UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
+// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! \" #
+// $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F
+// G H I J K L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f g h i
+// j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 0x83 0x84
+// 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0x91 0x92
+// 0x93 0x94 0x95 0x96 0x97
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_2(_tokenSet_2_data_,16);
+const unsigned long JavaLexer::_tokenSet_3_data_[] = { 4294967288UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 0x11 0x12 0x13
+// 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f ! # $
+// % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F
+// G H I J K L M N O P Q R S T U V W X Y Z [ ] ^ _ ` a b c d e f g h i
+// j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 0x83 0x84
+// 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 0x91 0x92
+// 0x93 0x94 0x95 0x96 0x97
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_3(_tokenSet_3_data_,16);
+const unsigned long JavaLexer::_tokenSet_4_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0 1 2 3 4 5 6 7 8 9 A B C D E F a b c d e f
+const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_4(_tokenSet_4_data_,10);
+