KDevelop API Documentation

JavaLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "java.g" -> "JavaLexer.cpp"$ */
00002 #include "JavaLexer.hpp"
00003 #include <antlr/CharBuffer.hpp>
00004 #include <antlr/TokenStreamException.hpp>
00005 #include <antlr/TokenStreamIOException.hpp>
00006 #include <antlr/TokenStreamRecognitionException.hpp>
00007 #include <antlr/CharStreamException.hpp>
00008 #include <antlr/CharStreamIOException.hpp>
00009 #include <antlr/NoViableAltForCharException.hpp>
00010 
00011 #line 1041 "java.g"
00012 
00013 #include <string>
00014 
00015 #line 16 "JavaLexer.cpp"
00016 JavaLexer::JavaLexer(ANTLR_USE_NAMESPACE(std)istream& in)
00017     : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),true)
00018 {
00019     initLiterals();
00020 }
00021 
00022 JavaLexer::JavaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
00023     : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,true)
00024 {
00025     initLiterals();
00026 }
00027 
00028 JavaLexer::JavaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
00029     : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,true)
00030 {
00031     initLiterals();
00032 }
00033 
00034 void JavaLexer::initLiterals()
00035 {
00036     literals["byte"] = 51;
00037     literals["public"] = 62;
00038     literals["case"] = 94;
00039     literals["short"] = 53;
00040     literals["break"] = 89;
00041     literals["while"] = 87;
00042     literals["new"] = 137;
00043     literals["instanceof"] = 122;
00044     literals["implements"] = 76;
00045     literals["synchronized"] = 68;
00046     literals["float"] = 55;
00047     literals["package"] = 44;
00048     literals["return"] = 91;
00049     literals["throw"] = 93;
00050     literals["null"] = 136;
00051     literals["threadsafe"] = 67;
00052     literals["protected"] = 63;
00053     literals["class"] = 70;
00054     literals["throws"] = 82;
00055     literals["do"] = 88;
00056     literals["strictfp"] = 41;
00057     literals["super"] = 80;
00058     literals["transient"] = 65;
00059     literals["native"] = 66;
00060     literals["interface"] = 72;
00061     literals["final"] = 39;
00062     literals["if"] = 84;
00063     literals["double"] = 57;
00064     literals["volatile"] = 69;
00065     literals["catch"] = 98;
00066     literals["try"] = 96;
00067     literals["int"] = 54;
00068     literals["for"] = 86;
00069     literals["extends"] = 71;
00070     literals["boolean"] = 50;
00071     literals["char"] = 52;
00072     literals["private"] = 61;
00073     literals["default"] = 95;
00074     literals["false"] = 135;
00075     literals["this"] = 79;
00076     literals["static"] = 64;
00077     literals["abstract"] = 40;
00078     literals["continue"] = 90;
00079     literals["finally"] = 97;
00080     literals["else"] = 85;
00081     literals["import"] = 46;
00082     literals["void"] = 49;
00083     literals["switch"] = 92;
00084     literals["true"] = 134;
00085     literals["long"] = 56;
00086 }
00087 
00088 ANTLR_USE_NAMESPACE(antlr)RefToken JavaLexer::nextToken()
00089 {
00090     ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00091     for (;;) {
00092         ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00093         int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
00094         resetText();
00095         try {   // for lexical and char stream error handling
00096             switch ( LA(1)) {
00097             case static_cast<unsigned char>('?'):
00098             {
00099                 mQUESTION(true);
00100                 theRetToken=_returnToken;
00101                 break;
00102             }
00103             case static_cast<unsigned char>('('):
00104             {
00105                 mLPAREN(true);
00106                 theRetToken=_returnToken;
00107                 break;
00108             }
00109             case static_cast<unsigned char>(')'):
00110             {
00111                 mRPAREN(true);
00112                 theRetToken=_returnToken;
00113                 break;
00114             }
00115             case static_cast<unsigned char>('['):
00116             {
00117                 mLBRACK(true);
00118                 theRetToken=_returnToken;
00119                 break;
00120             }
00121             case static_cast<unsigned char>(']'):
00122             {
00123                 mRBRACK(true);
00124                 theRetToken=_returnToken;
00125                 break;
00126             }
00127             case static_cast<unsigned char>('{'):
00128             {
00129                 mLCURLY(true);
00130                 theRetToken=_returnToken;
00131                 break;
00132             }
00133             case static_cast<unsigned char>('}'):
00134             {
00135                 mRCURLY(true);
00136                 theRetToken=_returnToken;
00137                 break;
00138             }
00139             case static_cast<unsigned char>(':'):
00140             {
00141                 mCOLON(true);
00142                 theRetToken=_returnToken;
00143                 break;
00144             }
00145             case static_cast<unsigned char>(','):
00146             {
00147                 mCOMMA(true);
00148                 theRetToken=_returnToken;
00149                 break;
00150             }
00151             case static_cast<unsigned char>('~'):
00152             {
00153                 mBNOT(true);
00154                 theRetToken=_returnToken;
00155                 break;
00156             }
00157             case static_cast<unsigned char>(';'):
00158             {
00159                 mSEMI(true);
00160                 theRetToken=_returnToken;
00161                 break;
00162             }
00163             case static_cast<unsigned char>('\t'):
00164             case static_cast<unsigned char>('\n'):
00165             case static_cast<unsigned char>('\14'):
00166             case static_cast<unsigned char>('\r'):
00167             case static_cast<unsigned char>(' '):
00168             {
00169                 mWS(true);
00170                 theRetToken=_returnToken;
00171                 break;
00172             }
00173             case static_cast<unsigned char>('\''):
00174             {
00175                 mCHAR_LITERAL(true);
00176                 theRetToken=_returnToken;
00177                 break;
00178             }
00179             case static_cast<unsigned char>('"'):
00180             {
00181                 mSTRING_LITERAL(true);
00182                 theRetToken=_returnToken;
00183                 break;
00184             }
00185             case static_cast<unsigned char>('$'):
00186             case static_cast<unsigned char>('A'):
00187             case static_cast<unsigned char>('B'):
00188             case static_cast<unsigned char>('C'):
00189             case static_cast<unsigned char>('D'):
00190             case static_cast<unsigned char>('E'):
00191             case static_cast<unsigned char>('F'):
00192             case static_cast<unsigned char>('G'):
00193             case static_cast<unsigned char>('H'):
00194             case static_cast<unsigned char>('I'):
00195             case static_cast<unsigned char>('J'):
00196             case static_cast<unsigned char>('K'):
00197             case static_cast<unsigned char>('L'):
00198             case static_cast<unsigned char>('M'):
00199             case static_cast<unsigned char>('N'):
00200             case static_cast<unsigned char>('O'):
00201             case static_cast<unsigned char>('P'):
00202             case static_cast<unsigned char>('Q'):
00203             case static_cast<unsigned char>('R'):
00204             case static_cast<unsigned char>('S'):
00205             case static_cast<unsigned char>('T'):
00206             case static_cast<unsigned char>('U'):
00207             case static_cast<unsigned char>('V'):
00208             case static_cast<unsigned char>('W'):
00209             case static_cast<unsigned char>('X'):
00210             case static_cast<unsigned char>('Y'):
00211             case static_cast<unsigned char>('Z'):
00212             case static_cast<unsigned char>('_'):
00213             case static_cast<unsigned char>('a'):
00214             case static_cast<unsigned char>('b'):
00215             case static_cast<unsigned char>('c'):
00216             case static_cast<unsigned char>('d'):
00217             case static_cast<unsigned char>('e'):
00218             case static_cast<unsigned char>('f'):
00219             case static_cast<unsigned char>('g'):
00220             case static_cast<unsigned char>('h'):
00221             case static_cast<unsigned char>('i'):
00222             case static_cast<unsigned char>('j'):
00223             case static_cast<unsigned char>('k'):
00224             case static_cast<unsigned char>('l'):
00225             case static_cast<unsigned char>('m'):
00226             case static_cast<unsigned char>('n'):
00227             case static_cast<unsigned char>('o'):
00228             case static_cast<unsigned char>('p'):
00229             case static_cast<unsigned char>('q'):
00230             case static_cast<unsigned char>('r'):
00231             case static_cast<unsigned char>('s'):
00232             case static_cast<unsigned char>('t'):
00233             case static_cast<unsigned char>('u'):
00234             case static_cast<unsigned char>('v'):
00235             case static_cast<unsigned char>('w'):
00236             case static_cast<unsigned char>('x'):
00237             case static_cast<unsigned char>('y'):
00238             case static_cast<unsigned char>('z'):
00239             {
00240                 mIDENT(true);
00241                 theRetToken=_returnToken;
00242                 break;
00243             }
00244             case static_cast<unsigned char>('.'):
00245             case static_cast<unsigned char>('0'):
00246             case static_cast<unsigned char>('1'):
00247             case static_cast<unsigned char>('2'):
00248             case static_cast<unsigned char>('3'):
00249             case static_cast<unsigned char>('4'):
00250             case static_cast<unsigned char>('5'):
00251             case static_cast<unsigned char>('6'):
00252             case static_cast<unsigned char>('7'):
00253             case static_cast<unsigned char>('8'):
00254             case static_cast<unsigned char>('9'):
00255             {
00256                 mNUM_INT(true);
00257                 theRetToken=_returnToken;
00258                 break;
00259             }
00260             default:
00261                 if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('>')) && (LA(3) == static_cast<unsigned char>('>')) && (LA(4) == static_cast<unsigned char>('='))) {
00262                     mBSR_ASSIGN(true);
00263                     theRetToken=_returnToken;
00264                 }
00265                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('>')) && (LA(3) == static_cast<unsigned char>('='))) {
00266                     mSR_ASSIGN(true);
00267                     theRetToken=_returnToken;
00268                 }
00269                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('>')) && (LA(3) == static_cast<unsigned char>('>')) && (true)) {
00270                     mBSR(true);
00271                     theRetToken=_returnToken;
00272                 }
00273                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('<')) && (LA(3) == static_cast<unsigned char>('='))) {
00274                     mSL_ASSIGN(true);
00275                     theRetToken=_returnToken;
00276                 }
00277                 else if ((LA(1) == static_cast<unsigned char>('=')) && (LA(2) == static_cast<unsigned char>('='))) {
00278                     mEQUAL(true);
00279                     theRetToken=_returnToken;
00280                 }
00281                 else if ((LA(1) == static_cast<unsigned char>('!')) && (LA(2) == static_cast<unsigned char>('='))) {
00282                     mNOT_EQUAL(true);
00283                     theRetToken=_returnToken;
00284                 }
00285                 else if ((LA(1) == static_cast<unsigned char>('/')) && (LA(2) == static_cast<unsigned char>('='))) {
00286                     mDIV_ASSIGN(true);
00287                     theRetToken=_returnToken;
00288                 }
00289                 else if ((LA(1) == static_cast<unsigned char>('+')) && (LA(2) == static_cast<unsigned char>('='))) {
00290                     mPLUS_ASSIGN(true);
00291                     theRetToken=_returnToken;
00292                 }
00293                 else if ((LA(1) == static_cast<unsigned char>('+')) && (LA(2) == static_cast<unsigned char>('+'))) {
00294                     mINC(true);
00295                     theRetToken=_returnToken;
00296                 }
00297                 else if ((LA(1) == static_cast<unsigned char>('-')) && (LA(2) == static_cast<unsigned char>('='))) {
00298                     mMINUS_ASSIGN(true);
00299                     theRetToken=_returnToken;
00300                 }
00301                 else if ((LA(1) == static_cast<unsigned char>('-')) && (LA(2) == static_cast<unsigned char>('-'))) {
00302                     mDEC(true);
00303                     theRetToken=_returnToken;
00304                 }
00305                 else if ((LA(1) == static_cast<unsigned char>('*')) && (LA(2) == static_cast<unsigned char>('='))) {
00306                     mSTAR_ASSIGN(true);
00307                     theRetToken=_returnToken;
00308                 }
00309                 else if ((LA(1) == static_cast<unsigned char>('%')) && (LA(2) == static_cast<unsigned char>('='))) {
00310                     mMOD_ASSIGN(true);
00311                     theRetToken=_returnToken;
00312                 }
00313                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('>')) && (true)) {
00314                     mSR(true);
00315                     theRetToken=_returnToken;
00316                 }
00317                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('='))) {
00318                     mGE(true);
00319                     theRetToken=_returnToken;
00320                 }
00321                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('<')) && (true)) {
00322                     mSL(true);
00323                     theRetToken=_returnToken;
00324                 }
00325                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('='))) {
00326                     mLE(true);
00327                     theRetToken=_returnToken;
00328                 }
00329                 else if ((LA(1) == static_cast<unsigned char>('^')) && (LA(2) == static_cast<unsigned char>('='))) {
00330                     mBXOR_ASSIGN(true);
00331                     theRetToken=_returnToken;
00332                 }
00333                 else if ((LA(1) == static_cast<unsigned char>('|')) && (LA(2) == static_cast<unsigned char>('='))) {
00334                     mBOR_ASSIGN(true);
00335                     theRetToken=_returnToken;
00336                 }
00337                 else if ((LA(1) == static_cast<unsigned char>('|')) && (LA(2) == static_cast<unsigned char>('|'))) {
00338                     mLOR(true);
00339                     theRetToken=_returnToken;
00340                 }
00341                 else if ((LA(1) == static_cast<unsigned char>('&')) && (LA(2) == static_cast<unsigned char>('='))) {
00342                     mBAND_ASSIGN(true);
00343                     theRetToken=_returnToken;
00344                 }
00345                 else if ((LA(1) == static_cast<unsigned char>('&')) && (LA(2) == static_cast<unsigned char>('&'))) {
00346                     mLAND(true);
00347                     theRetToken=_returnToken;
00348                 }
00349                 else if ((LA(1) == static_cast<unsigned char>('/')) && (LA(2) == static_cast<unsigned char>('/'))) {
00350                     mSL_COMMENT(true);
00351                     theRetToken=_returnToken;
00352                 }
00353                 else if ((LA(1) == static_cast<unsigned char>('/')) && (LA(2) == static_cast<unsigned char>('*'))) {
00354                     mML_COMMENT(true);
00355                     theRetToken=_returnToken;
00356                 }
00357                 else if ((LA(1) == static_cast<unsigned char>('=')) && (true)) {
00358                     mASSIGN(true);
00359                     theRetToken=_returnToken;
00360                 }
00361                 else if ((LA(1) == static_cast<unsigned char>('!')) && (true)) {
00362                     mLNOT(true);
00363                     theRetToken=_returnToken;
00364                 }
00365                 else if ((LA(1) == static_cast<unsigned char>('/')) && (true)) {
00366                     mDIV(true);
00367                     theRetToken=_returnToken;
00368                 }
00369                 else if ((LA(1) == static_cast<unsigned char>('+')) && (true)) {
00370                     mPLUS(true);
00371                     theRetToken=_returnToken;
00372                 }
00373                 else if ((LA(1) == static_cast<unsigned char>('-')) && (true)) {
00374                     mMINUS(true);
00375                     theRetToken=_returnToken;
00376                 }
00377                 else if ((LA(1) == static_cast<unsigned char>('*')) && (true)) {
00378                     mSTAR(true);
00379                     theRetToken=_returnToken;
00380                 }
00381                 else if ((LA(1) == static_cast<unsigned char>('%')) && (true)) {
00382                     mMOD(true);
00383                     theRetToken=_returnToken;
00384                 }
00385                 else if ((LA(1) == static_cast<unsigned char>('>')) && (true)) {
00386                     mGT(true);
00387                     theRetToken=_returnToken;
00388                 }
00389                 else if ((LA(1) == static_cast<unsigned char>('<')) && (true)) {
00390                     mLT_(true);
00391                     theRetToken=_returnToken;
00392                 }
00393                 else if ((LA(1) == static_cast<unsigned char>('^')) && (true)) {
00394                     mBXOR(true);
00395                     theRetToken=_returnToken;
00396                 }
00397                 else if ((LA(1) == static_cast<unsigned char>('|')) && (true)) {
00398                     mBOR(true);
00399                     theRetToken=_returnToken;
00400                 }
00401                 else if ((LA(1) == static_cast<unsigned char>('&')) && (true)) {
00402                     mBAND(true);
00403                     theRetToken=_returnToken;
00404                 }
00405             else {
00406                 if (LA(1)==EOF_CHAR)
00407                 {
00408                     uponEOF();
00409                     _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
00410                 }
00411                 else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00412             }
00413             }
00414             if ( !_returnToken )
00415                 goto tryAgain; // found SKIP token
00416 
00417             _ttype = _returnToken->getType();
00418             _returnToken->setType(_ttype);
00419             return _returnToken;
00420         }
00421         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
00422                 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
00423         }
00424         catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
00425             throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
00426         }
00427         catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
00428             throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
00429         }
00430 tryAgain:;
00431     }
00432 }
00433 
00434 void JavaLexer::mQUESTION(bool _createToken) {
00435     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00436     _ttype = QUESTION;
00437     int _saveIndex;
00438     
00439     match(static_cast<unsigned char>('?'));
00440     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00441        _token = makeToken(_ttype);
00442        _token->setText(text.substr(_begin, text.length()-_begin));
00443     }
00444     _returnToken = _token;
00445     _saveIndex=0;
00446 }
00447 
00448 void JavaLexer::mLPAREN(bool _createToken) {
00449     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00450     _ttype = LPAREN;
00451     int _saveIndex;
00452     
00453     match(static_cast<unsigned char>('('));
00454     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00455        _token = makeToken(_ttype);
00456        _token->setText(text.substr(_begin, text.length()-_begin));
00457     }
00458     _returnToken = _token;
00459     _saveIndex=0;
00460 }
00461 
00462 void JavaLexer::mRPAREN(bool _createToken) {
00463     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00464     _ttype = RPAREN;
00465     int _saveIndex;
00466     
00467     match(static_cast<unsigned char>(')'));
00468     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00469        _token = makeToken(_ttype);
00470        _token->setText(text.substr(_begin, text.length()-_begin));
00471     }
00472     _returnToken = _token;
00473     _saveIndex=0;
00474 }
00475 
00476 void JavaLexer::mLBRACK(bool _createToken) {
00477     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00478     _ttype = LBRACK;
00479     int _saveIndex;
00480     
00481     match(static_cast<unsigned char>('['));
00482     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00483        _token = makeToken(_ttype);
00484        _token->setText(text.substr(_begin, text.length()-_begin));
00485     }
00486     _returnToken = _token;
00487     _saveIndex=0;
00488 }
00489 
00490 void JavaLexer::mRBRACK(bool _createToken) {
00491     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00492     _ttype = RBRACK;
00493     int _saveIndex;
00494     
00495     match(static_cast<unsigned char>(']'));
00496     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00497        _token = makeToken(_ttype);
00498        _token->setText(text.substr(_begin, text.length()-_begin));
00499     }
00500     _returnToken = _token;
00501     _saveIndex=0;
00502 }
00503 
00504 void JavaLexer::mLCURLY(bool _createToken) {
00505     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00506     _ttype = LCURLY;
00507     int _saveIndex;
00508     
00509     match(static_cast<unsigned char>('{'));
00510     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00511        _token = makeToken(_ttype);
00512        _token->setText(text.substr(_begin, text.length()-_begin));
00513     }
00514     _returnToken = _token;
00515     _saveIndex=0;
00516 }
00517 
00518 void JavaLexer::mRCURLY(bool _createToken) {
00519     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00520     _ttype = RCURLY;
00521     int _saveIndex;
00522     
00523     match(static_cast<unsigned char>('}'));
00524     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00525        _token = makeToken(_ttype);
00526        _token->setText(text.substr(_begin, text.length()-_begin));
00527     }
00528     _returnToken = _token;
00529     _saveIndex=0;
00530 }
00531 
00532 void JavaLexer::mCOLON(bool _createToken) {
00533     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00534     _ttype = COLON;
00535     int _saveIndex;
00536     
00537     match(static_cast<unsigned char>(':'));
00538     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00539        _token = makeToken(_ttype);
00540        _token->setText(text.substr(_begin, text.length()-_begin));
00541     }
00542     _returnToken = _token;
00543     _saveIndex=0;
00544 }
00545 
00546 void JavaLexer::mCOMMA(bool _createToken) {
00547     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00548     _ttype = COMMA;
00549     int _saveIndex;
00550     
00551     match(static_cast<unsigned char>(','));
00552     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00553        _token = makeToken(_ttype);
00554        _token->setText(text.substr(_begin, text.length()-_begin));
00555     }
00556     _returnToken = _token;
00557     _saveIndex=0;
00558 }
00559 
00560 void JavaLexer::mASSIGN(bool _createToken) {
00561     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00562     _ttype = ASSIGN;
00563     int _saveIndex;
00564     
00565     match(static_cast<unsigned char>('='));
00566     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00567        _token = makeToken(_ttype);
00568        _token->setText(text.substr(_begin, text.length()-_begin));
00569     }
00570     _returnToken = _token;
00571     _saveIndex=0;
00572 }
00573 
00574 void JavaLexer::mEQUAL(bool _createToken) {
00575     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00576     _ttype = EQUAL;
00577     int _saveIndex;
00578     
00579     match("==");
00580     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00581        _token = makeToken(_ttype);
00582        _token->setText(text.substr(_begin, text.length()-_begin));
00583     }
00584     _returnToken = _token;
00585     _saveIndex=0;
00586 }
00587 
00588 void JavaLexer::mLNOT(bool _createToken) {
00589     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00590     _ttype = LNOT;
00591     int _saveIndex;
00592     
00593     match(static_cast<unsigned char>('!'));
00594     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00595        _token = makeToken(_ttype);
00596        _token->setText(text.substr(_begin, text.length()-_begin));
00597     }
00598     _returnToken = _token;
00599     _saveIndex=0;
00600 }
00601 
00602 void JavaLexer::mBNOT(bool _createToken) {
00603     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00604     _ttype = BNOT;
00605     int _saveIndex;
00606     
00607     match(static_cast<unsigned char>('~'));
00608     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00609        _token = makeToken(_ttype);
00610        _token->setText(text.substr(_begin, text.length()-_begin));
00611     }
00612     _returnToken = _token;
00613     _saveIndex=0;
00614 }
00615 
00616 void JavaLexer::mNOT_EQUAL(bool _createToken) {
00617     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00618     _ttype = NOT_EQUAL;
00619     int _saveIndex;
00620     
00621     match("!=");
00622     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00623        _token = makeToken(_ttype);
00624        _token->setText(text.substr(_begin, text.length()-_begin));
00625     }
00626     _returnToken = _token;
00627     _saveIndex=0;
00628 }
00629 
00630 void JavaLexer::mDIV(bool _createToken) {
00631     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00632     _ttype = DIV;
00633     int _saveIndex;
00634     
00635     match(static_cast<unsigned char>('/'));
00636     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00637        _token = makeToken(_ttype);
00638        _token->setText(text.substr(_begin, text.length()-_begin));
00639     }
00640     _returnToken = _token;
00641     _saveIndex=0;
00642 }
00643 
00644 void JavaLexer::mDIV_ASSIGN(bool _createToken) {
00645     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00646     _ttype = DIV_ASSIGN;
00647     int _saveIndex;
00648     
00649     match("/=");
00650     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00651        _token = makeToken(_ttype);
00652        _token->setText(text.substr(_begin, text.length()-_begin));
00653     }
00654     _returnToken = _token;
00655     _saveIndex=0;
00656 }
00657 
00658 void JavaLexer::mPLUS(bool _createToken) {
00659     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00660     _ttype = PLUS;
00661     int _saveIndex;
00662     
00663     match(static_cast<unsigned char>('+'));
00664     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00665        _token = makeToken(_ttype);
00666        _token->setText(text.substr(_begin, text.length()-_begin));
00667     }
00668     _returnToken = _token;
00669     _saveIndex=0;
00670 }
00671 
00672 void JavaLexer::mPLUS_ASSIGN(bool _createToken) {
00673     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00674     _ttype = PLUS_ASSIGN;
00675     int _saveIndex;
00676     
00677     match("+=");
00678     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00679        _token = makeToken(_ttype);
00680        _token->setText(text.substr(_begin, text.length()-_begin));
00681     }
00682     _returnToken = _token;
00683     _saveIndex=0;
00684 }
00685 
00686 void JavaLexer::mINC(bool _createToken) {
00687     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00688     _ttype = INC;
00689     int _saveIndex;
00690     
00691     match("++");
00692     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00693        _token = makeToken(_ttype);
00694        _token->setText(text.substr(_begin, text.length()-_begin));
00695     }
00696     _returnToken = _token;
00697     _saveIndex=0;
00698 }
00699 
00700 void JavaLexer::mMINUS(bool _createToken) {
00701     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00702     _ttype = MINUS;
00703     int _saveIndex;
00704     
00705     match(static_cast<unsigned char>('-'));
00706     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00707        _token = makeToken(_ttype);
00708        _token->setText(text.substr(_begin, text.length()-_begin));
00709     }
00710     _returnToken = _token;
00711     _saveIndex=0;
00712 }
00713 
00714 void JavaLexer::mMINUS_ASSIGN(bool _createToken) {
00715     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00716     _ttype = MINUS_ASSIGN;
00717     int _saveIndex;
00718     
00719     match("-=");
00720     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00721        _token = makeToken(_ttype);
00722        _token->setText(text.substr(_begin, text.length()-_begin));
00723     }
00724     _returnToken = _token;
00725     _saveIndex=0;
00726 }
00727 
00728 void JavaLexer::mDEC(bool _createToken) {
00729     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00730     _ttype = DEC;
00731     int _saveIndex;
00732     
00733     match("--");
00734     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00735        _token = makeToken(_ttype);
00736        _token->setText(text.substr(_begin, text.length()-_begin));
00737     }
00738     _returnToken = _token;
00739     _saveIndex=0;
00740 }
00741 
00742 void JavaLexer::mSTAR(bool _createToken) {
00743     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00744     _ttype = STAR;
00745     int _saveIndex;
00746     
00747     match(static_cast<unsigned char>('*'));
00748     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00749        _token = makeToken(_ttype);
00750        _token->setText(text.substr(_begin, text.length()-_begin));
00751     }
00752     _returnToken = _token;
00753     _saveIndex=0;
00754 }
00755 
00756 void JavaLexer::mSTAR_ASSIGN(bool _createToken) {
00757     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00758     _ttype = STAR_ASSIGN;
00759     int _saveIndex;
00760     
00761     match("*=");
00762     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00763        _token = makeToken(_ttype);
00764        _token->setText(text.substr(_begin, text.length()-_begin));
00765     }
00766     _returnToken = _token;
00767     _saveIndex=0;
00768 }
00769 
00770 void JavaLexer::mMOD(bool _createToken) {
00771     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00772     _ttype = MOD;
00773     int _saveIndex;
00774     
00775     match(static_cast<unsigned char>('%'));
00776     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00777        _token = makeToken(_ttype);
00778        _token->setText(text.substr(_begin, text.length()-_begin));
00779     }
00780     _returnToken = _token;
00781     _saveIndex=0;
00782 }
00783 
00784 void JavaLexer::mMOD_ASSIGN(bool _createToken) {
00785     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00786     _ttype = MOD_ASSIGN;
00787     int _saveIndex;
00788     
00789     match("%=");
00790     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00791        _token = makeToken(_ttype);
00792        _token->setText(text.substr(_begin, text.length()-_begin));
00793     }
00794     _returnToken = _token;
00795     _saveIndex=0;
00796 }
00797 
00798 void JavaLexer::mSR(bool _createToken) {
00799     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00800     _ttype = SR;
00801     int _saveIndex;
00802     
00803     match(">>");
00804     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00805        _token = makeToken(_ttype);
00806        _token->setText(text.substr(_begin, text.length()-_begin));
00807     }
00808     _returnToken = _token;
00809     _saveIndex=0;
00810 }
00811 
00812 void JavaLexer::mSR_ASSIGN(bool _createToken) {
00813     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00814     _ttype = SR_ASSIGN;
00815     int _saveIndex;
00816     
00817     match(">>=");
00818     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00819        _token = makeToken(_ttype);
00820        _token->setText(text.substr(_begin, text.length()-_begin));
00821     }
00822     _returnToken = _token;
00823     _saveIndex=0;
00824 }
00825 
00826 void JavaLexer::mBSR(bool _createToken) {
00827     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00828     _ttype = BSR;
00829     int _saveIndex;
00830     
00831     match(">>>");
00832     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00833        _token = makeToken(_ttype);
00834        _token->setText(text.substr(_begin, text.length()-_begin));
00835     }
00836     _returnToken = _token;
00837     _saveIndex=0;
00838 }
00839 
00840 void JavaLexer::mBSR_ASSIGN(bool _createToken) {
00841     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00842     _ttype = BSR_ASSIGN;
00843     int _saveIndex;
00844     
00845     match(">>>=");
00846     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00847        _token = makeToken(_ttype);
00848        _token->setText(text.substr(_begin, text.length()-_begin));
00849     }
00850     _returnToken = _token;
00851     _saveIndex=0;
00852 }
00853 
00854 void JavaLexer::mGE(bool _createToken) {
00855     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00856     _ttype = GE;
00857     int _saveIndex;
00858     
00859     match(">=");
00860     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00861        _token = makeToken(_ttype);
00862        _token->setText(text.substr(_begin, text.length()-_begin));
00863     }
00864     _returnToken = _token;
00865     _saveIndex=0;
00866 }
00867 
00868 void JavaLexer::mGT(bool _createToken) {
00869     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00870     _ttype = GT;
00871     int _saveIndex;
00872     
00873     match(">");
00874     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00875        _token = makeToken(_ttype);
00876        _token->setText(text.substr(_begin, text.length()-_begin));
00877     }
00878     _returnToken = _token;
00879     _saveIndex=0;
00880 }
00881 
00882 void JavaLexer::mSL(bool _createToken) {
00883     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00884     _ttype = SL;
00885     int _saveIndex;
00886     
00887     match("<<");
00888     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00889        _token = makeToken(_ttype);
00890        _token->setText(text.substr(_begin, text.length()-_begin));
00891     }
00892     _returnToken = _token;
00893     _saveIndex=0;
00894 }
00895 
00896 void JavaLexer::mSL_ASSIGN(bool _createToken) {
00897     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00898     _ttype = SL_ASSIGN;
00899     int _saveIndex;
00900     
00901     match("<<=");
00902     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00903        _token = makeToken(_ttype);
00904        _token->setText(text.substr(_begin, text.length()-_begin));
00905     }
00906     _returnToken = _token;
00907     _saveIndex=0;
00908 }
00909 
00910 void JavaLexer::mLE(bool _createToken) {
00911     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00912     _ttype = LE;
00913     int _saveIndex;
00914     
00915     match("<=");
00916     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00917        _token = makeToken(_ttype);
00918        _token->setText(text.substr(_begin, text.length()-_begin));
00919     }
00920     _returnToken = _token;
00921     _saveIndex=0;
00922 }
00923 
00924 void JavaLexer::mLT_(bool _createToken) {
00925     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00926     _ttype = LT_;
00927     int _saveIndex;
00928     
00929     match(static_cast<unsigned char>('<'));
00930     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00931        _token = makeToken(_ttype);
00932        _token->setText(text.substr(_begin, text.length()-_begin));
00933     }
00934     _returnToken = _token;
00935     _saveIndex=0;
00936 }
00937 
00938 void JavaLexer::mBXOR(bool _createToken) {
00939     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00940     _ttype = BXOR;
00941     int _saveIndex;
00942     
00943     match(static_cast<unsigned char>('^'));
00944     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00945        _token = makeToken(_ttype);
00946        _token->setText(text.substr(_begin, text.length()-_begin));
00947     }
00948     _returnToken = _token;
00949     _saveIndex=0;
00950 }
00951 
00952 void JavaLexer::mBXOR_ASSIGN(bool _createToken) {
00953     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00954     _ttype = BXOR_ASSIGN;
00955     int _saveIndex;
00956     
00957     match("^=");
00958     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00959        _token = makeToken(_ttype);
00960        _token->setText(text.substr(_begin, text.length()-_begin));
00961     }
00962     _returnToken = _token;
00963     _saveIndex=0;
00964 }
00965 
00966 void JavaLexer::mBOR(bool _createToken) {
00967     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00968     _ttype = BOR;
00969     int _saveIndex;
00970     
00971     match(static_cast<unsigned char>('|'));
00972     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00973        _token = makeToken(_ttype);
00974        _token->setText(text.substr(_begin, text.length()-_begin));
00975     }
00976     _returnToken = _token;
00977     _saveIndex=0;
00978 }
00979 
00980 void JavaLexer::mBOR_ASSIGN(bool _createToken) {
00981     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00982     _ttype = BOR_ASSIGN;
00983     int _saveIndex;
00984     
00985     match("|=");
00986     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00987        _token = makeToken(_ttype);
00988        _token->setText(text.substr(_begin, text.length()-_begin));
00989     }
00990     _returnToken = _token;
00991     _saveIndex=0;
00992 }
00993 
00994 void JavaLexer::mLOR(bool _createToken) {
00995     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00996     _ttype = LOR;
00997     int _saveIndex;
00998     
00999     match("||");
01000     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01001        _token = makeToken(_ttype);
01002        _token->setText(text.substr(_begin, text.length()-_begin));
01003     }
01004     _returnToken = _token;
01005     _saveIndex=0;
01006 }
01007 
01008 void JavaLexer::mBAND(bool _createToken) {
01009     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01010     _ttype = BAND;
01011     int _saveIndex;
01012     
01013     match(static_cast<unsigned char>('&'));
01014     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01015        _token = makeToken(_ttype);
01016        _token->setText(text.substr(_begin, text.length()-_begin));
01017     }
01018     _returnToken = _token;
01019     _saveIndex=0;
01020 }
01021 
01022 void JavaLexer::mBAND_ASSIGN(bool _createToken) {
01023     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01024     _ttype = BAND_ASSIGN;
01025     int _saveIndex;
01026     
01027     match("&=");
01028     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01029        _token = makeToken(_ttype);
01030        _token->setText(text.substr(_begin, text.length()-_begin));
01031     }
01032     _returnToken = _token;
01033     _saveIndex=0;
01034 }
01035 
01036 void JavaLexer::mLAND(bool _createToken) {
01037     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01038     _ttype = LAND;
01039     int _saveIndex;
01040     
01041     match("&&");
01042     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01043        _token = makeToken(_ttype);
01044        _token->setText(text.substr(_begin, text.length()-_begin));
01045     }
01046     _returnToken = _token;
01047     _saveIndex=0;
01048 }
01049 
01050 void JavaLexer::mSEMI(bool _createToken) {
01051     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01052     _ttype = SEMI;
01053     int _saveIndex;
01054     
01055     match(static_cast<unsigned char>(';'));
01056     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01057        _token = makeToken(_ttype);
01058        _token->setText(text.substr(_begin, text.length()-_begin));
01059     }
01060     _returnToken = _token;
01061     _saveIndex=0;
01062 }
01063 
01064 void JavaLexer::mWS(bool _createToken) {
01065     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01066     _ttype = WS;
01067     int _saveIndex;
01068     
01069     { // ( ... )+
01070     int _cnt245=0;
01071     for (;;) {
01072         switch ( LA(1)) {
01073         case static_cast<unsigned char>(' '):
01074         {
01075             match(static_cast<unsigned char>(' '));
01076             break;
01077         }
01078         case static_cast<unsigned char>('\t'):
01079         {
01080             match(static_cast<unsigned char>('\t'));
01081             break;
01082         }
01083         case static_cast<unsigned char>('\14'):
01084         {
01085             match(static_cast<unsigned char>('\14'));
01086             break;
01087         }
01088         case static_cast<unsigned char>('\n'):
01089         case static_cast<unsigned char>('\r'):
01090         {
01091             {
01092             if ((LA(1) == static_cast<unsigned char>('\r')) && (LA(2) == static_cast<unsigned char>('\n')) && (true) && (true)) {
01093                 match("\r\n");
01094             }
01095             else if ((LA(1) == static_cast<unsigned char>('\r')) && (true) && (true) && (true)) {
01096                 match(static_cast<unsigned char>('\r'));
01097             }
01098             else if ((LA(1) == static_cast<unsigned char>('\n'))) {
01099                 match(static_cast<unsigned char>('\n'));
01100             }
01101             else {
01102                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01103             }
01104             
01105             }
01106 #line 1137 "java.g"
01107             newline();
01108 #line 1109 "JavaLexer.cpp"
01109             break;
01110         }
01111         default:
01112         {
01113             if ( _cnt245>=1 ) { goto _loop245; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01114         }
01115         }
01116         _cnt245++;
01117     }
01118     _loop245:;
01119     }  // ( ... )+
01120 #line 1139 "java.g"
01121     _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01122 #line 1123 "JavaLexer.cpp"
01123     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01124        _token = makeToken(_ttype);
01125        _token->setText(text.substr(_begin, text.length()-_begin));
01126     }
01127     _returnToken = _token;
01128     _saveIndex=0;
01129 }
01130 
01131 void JavaLexer::mSL_COMMENT(bool _createToken) {
01132     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01133     _ttype = SL_COMMENT;
01134     int _saveIndex;
01135     
01136     match("//");
01137     { // ( ... )*
01138     for (;;) {
01139         if ((_tokenSet_0.member(LA(1)))) {
01140             {
01141             match(_tokenSet_0);
01142             }
01143         }
01144         else {
01145             goto _loop249;
01146         }
01147         
01148     }
01149     _loop249:;
01150     } // ( ... )*
01151     {
01152     switch ( LA(1)) {
01153     case static_cast<unsigned char>('\n'):
01154     {
01155         match(static_cast<unsigned char>('\n'));
01156         break;
01157     }
01158     case static_cast<unsigned char>('\r'):
01159     {
01160         match(static_cast<unsigned char>('\r'));
01161         {
01162         if ((LA(1) == static_cast<unsigned char>('\n'))) {
01163             match(static_cast<unsigned char>('\n'));
01164         }
01165         else {
01166         }
01167         
01168         }
01169         break;
01170     }
01171     default:
01172     {
01173         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01174     }
01175     }
01176     }
01177 #line 1146 "java.g"
01178     
01179                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01180                 newline();
01181             
01182 #line 1183 "JavaLexer.cpp"
01183     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01184        _token = makeToken(_ttype);
01185        _token->setText(text.substr(_begin, text.length()-_begin));
01186     }
01187     _returnToken = _token;
01188     _saveIndex=0;
01189 }
01190 
01191 void JavaLexer::mML_COMMENT(bool _createToken) {
01192     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01193     _ttype = ML_COMMENT;
01194     int _saveIndex;
01195     
01196     match("/*");
01197     { // ( ... )*
01198     for (;;) {
01199         if ((LA(1) == static_cast<unsigned char>('\r')) && (LA(2) == static_cast<unsigned char>('\n')) && ((LA(3) >= static_cast<unsigned char>('\3') && LA(3) <= static_cast<unsigned char>('\377'))) && ((LA(4) >= static_cast<unsigned char>('\3') && LA(4) <= static_cast<unsigned char>('\377')))) {
01200             match(static_cast<unsigned char>('\r'));
01201             match(static_cast<unsigned char>('\n'));
01202 #line 1167 "java.g"
01203             newline();
01204 #line 1205 "JavaLexer.cpp"
01205         }
01206         else if (((LA(1) == static_cast<unsigned char>('*')) && ((LA(2) >= static_cast<unsigned char>('\3') && LA(2) <= static_cast<unsigned char>('\377'))) && ((LA(3) >= static_cast<unsigned char>('\3') && LA(3) <= static_cast<unsigned char>('\377'))))&&( LA(2)!='/' )) {
01207             match(static_cast<unsigned char>('*'));
01208         }
01209         else if ((LA(1) == static_cast<unsigned char>('\r')) && ((LA(2) >= static_cast<unsigned char>('\3') && LA(2) <= static_cast<unsigned char>('\377'))) && ((LA(3) >= static_cast<unsigned char>('\3') && LA(3) <= static_cast<unsigned char>('\377'))) && (true)) {
01210             match(static_cast<unsigned char>('\r'));
01211 #line 1168 "java.g"
01212             newline();
01213 #line 1214 "JavaLexer.cpp"
01214         }
01215         else if ((LA(1) == static_cast<unsigned char>('\n'))) {
01216             match(static_cast<unsigned char>('\n'));
01217 #line 1169 "java.g"
01218             newline();
01219 #line 1220 "JavaLexer.cpp"
01220         }
01221         else if ((_tokenSet_1.member(LA(1)))) {
01222             {
01223             match(_tokenSet_1);
01224             }
01225         }
01226         else {
01227             goto _loop255;
01228         }
01229         
01230     }
01231     _loop255:;
01232     } // ( ... )*
01233     match("*/");
01234 #line 1173 "java.g"
01235     _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01236 #line 1237 "JavaLexer.cpp"
01237     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01238        _token = makeToken(_ttype);
01239        _token->setText(text.substr(_begin, text.length()-_begin));
01240     }
01241     _returnToken = _token;
01242     _saveIndex=0;
01243 }
01244 
01245 void JavaLexer::mCHAR_LITERAL(bool _createToken) {
01246     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01247     _ttype = CHAR_LITERAL;
01248     int _saveIndex;
01249     
01250     match(static_cast<unsigned char>('\''));
01251     {
01252     if ((LA(1) == static_cast<unsigned char>('\\'))) {
01253         mESC(false);
01254     }
01255     else if ((_tokenSet_2.member(LA(1)))) {
01256         matchNot(static_cast<unsigned char>('\''));
01257     }
01258     else {
01259         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01260     }
01261     
01262     }
01263     match(static_cast<unsigned char>('\''));
01264     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01265        _token = makeToken(_ttype);
01266        _token->setText(text.substr(_begin, text.length()-_begin));
01267     }
01268     _returnToken = _token;
01269     _saveIndex=0;
01270 }
01271 
01272 void JavaLexer::mESC(bool _createToken) {
01273     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01274     _ttype = ESC;
01275     int _saveIndex;
01276     
01277     match(static_cast<unsigned char>('\\'));
01278     {
01279     switch ( LA(1)) {
01280     case static_cast<unsigned char>('n'):
01281     {
01282         match(static_cast<unsigned char>('n'));
01283         break;
01284     }
01285     case static_cast<unsigned char>('r'):
01286     {
01287         match(static_cast<unsigned char>('r'));
01288         break;
01289     }
01290     case static_cast<unsigned char>('t'):
01291     {
01292         match(static_cast<unsigned char>('t'));
01293         break;
01294     }
01295     case static_cast<unsigned char>('b'):
01296     {
01297         match(static_cast<unsigned char>('b'));
01298         break;
01299     }
01300     case static_cast<unsigned char>('f'):
01301     {
01302         match(static_cast<unsigned char>('f'));
01303         break;
01304     }
01305     case static_cast<unsigned char>('"'):
01306     {
01307         match(static_cast<unsigned char>('"'));
01308         break;
01309     }
01310     case static_cast<unsigned char>('\''):
01311     {
01312         match(static_cast<unsigned char>('\''));
01313         break;
01314     }
01315     case static_cast<unsigned char>('\\'):
01316     {
01317         match(static_cast<unsigned char>('\\'));
01318         break;
01319     }
01320     case static_cast<unsigned char>('u'):
01321     {
01322         { // ( ... )+
01323         int _cnt265=0;
01324         for (;;) {
01325             if ((LA(1) == static_cast<unsigned char>('u'))) {
01326                 match(static_cast<unsigned char>('u'));
01327             }
01328             else {
01329                 if ( _cnt265>=1 ) { goto _loop265; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01330             }
01331             
01332             _cnt265++;
01333         }
01334         _loop265:;
01335         }  // ( ... )+
01336         mHEX_DIGIT(false);
01337         mHEX_DIGIT(false);
01338         mHEX_DIGIT(false);
01339         mHEX_DIGIT(false);
01340         break;
01341     }
01342     case static_cast<unsigned char>('0'):
01343     case static_cast<unsigned char>('1'):
01344     case static_cast<unsigned char>('2'):
01345     case static_cast<unsigned char>('3'):
01346     {
01347         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('3'));
01348         {
01349         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('7'))) && ((LA(2) >= static_cast<unsigned char>('\3') && LA(2) <= static_cast<unsigned char>('\377'))) && (true) && (true)) {
01350             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('7'));
01351             {
01352             if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('7'))) && ((LA(2) >= static_cast<unsigned char>('\3') && LA(2) <= static_cast<unsigned char>('\377'))) && (true) && (true)) {
01353                 matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('7'));
01354             }
01355             else if (((LA(1) >= static_cast<unsigned char>('\3') && LA(1) <= static_cast<unsigned char>('\377'))) && (true) && (true) && (true)) {
01356             }
01357             else {
01358                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01359             }
01360             
01361             }
01362         }
01363         else if (((LA(1) >= static_cast<unsigned char>('\3') && LA(1) <= static_cast<unsigned char>('\377'))) && (true) && (true) && (true)) {
01364         }
01365         else {
01366             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01367         }
01368         
01369         }
01370         break;
01371     }
01372     case static_cast<unsigned char>('4'):
01373     case static_cast<unsigned char>('5'):
01374     case static_cast<unsigned char>('6'):
01375     case static_cast<unsigned char>('7'):
01376     {
01377         matchRange(static_cast<unsigned char>('4'),static_cast<unsigned char>('7'));
01378         {
01379         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('7'))) && ((LA(2) >= static_cast<unsigned char>('\3') && LA(2) <= static_cast<unsigned char>('\377'))) && (true) && (true)) {
01380             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('7'));
01381         }
01382         else if (((LA(1) >= static_cast<unsigned char>('\3') && LA(1) <= static_cast<unsigned char>('\377'))) && (true) && (true) && (true)) {
01383         }
01384         else {
01385             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01386         }
01387         
01388         }
01389         break;
01390     }
01391     default:
01392     {
01393         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01394     }
01395     }
01396     }
01397     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01398        _token = makeToken(_ttype);
01399        _token->setText(text.substr(_begin, text.length()-_begin));
01400     }
01401     _returnToken = _token;
01402     _saveIndex=0;
01403 }
01404 
01405 void JavaLexer::mSTRING_LITERAL(bool _createToken) {
01406     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01407     _ttype = STRING_LITERAL;
01408     int _saveIndex;
01409     
01410     match(static_cast<unsigned char>('"'));
01411     { // ( ... )*
01412     for (;;) {
01413         if ((LA(1) == static_cast<unsigned char>('\\'))) {
01414             mESC(false);
01415         }
01416         else if ((_tokenSet_3.member(LA(1)))) {
01417             {
01418             match(_tokenSet_3);
01419             }
01420         }
01421         else {
01422             goto _loop261;
01423         }
01424         
01425     }
01426     _loop261:;
01427     } // ( ... )*
01428     match(static_cast<unsigned char>('"'));
01429     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01430        _token = makeToken(_ttype);
01431        _token->setText(text.substr(_begin, text.length()-_begin));
01432     }
01433     _returnToken = _token;
01434     _saveIndex=0;
01435 }
01436 
01437 void JavaLexer::mHEX_DIGIT(bool _createToken) {
01438     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01439     _ttype = HEX_DIGIT;
01440     int _saveIndex;
01441     
01442     {
01443     switch ( LA(1)) {
01444     case static_cast<unsigned char>('0'):
01445     case static_cast<unsigned char>('1'):
01446     case static_cast<unsigned char>('2'):
01447     case static_cast<unsigned char>('3'):
01448     case static_cast<unsigned char>('4'):
01449     case static_cast<unsigned char>('5'):
01450     case static_cast<unsigned char>('6'):
01451     case static_cast<unsigned char>('7'):
01452     case static_cast<unsigned char>('8'):
01453     case static_cast<unsigned char>('9'):
01454     {
01455         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01456         break;
01457     }
01458     case static_cast<unsigned char>('A'):
01459     case static_cast<unsigned char>('B'):
01460     case static_cast<unsigned char>('C'):
01461     case static_cast<unsigned char>('D'):
01462     case static_cast<unsigned char>('E'):
01463     case static_cast<unsigned char>('F'):
01464     {
01465         matchRange(static_cast<unsigned char>('A'),static_cast<unsigned char>('F'));
01466         break;
01467     }
01468     case static_cast<unsigned char>('a'):
01469     case static_cast<unsigned char>('b'):
01470     case static_cast<unsigned char>('c'):
01471     case static_cast<unsigned char>('d'):
01472     case static_cast<unsigned char>('e'):
01473     case static_cast<unsigned char>('f'):
01474     {
01475         matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('f'));
01476         break;
01477     }
01478     default:
01479     {
01480         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01481     }
01482     }
01483     }
01484     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01485        _token = makeToken(_ttype);
01486        _token->setText(text.substr(_begin, text.length()-_begin));
01487     }
01488     _returnToken = _token;
01489     _saveIndex=0;
01490 }
01491 
01492 void JavaLexer::mVOCAB(bool _createToken) {
01493     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01494     _ttype = VOCAB;
01495     int _saveIndex;
01496     
01497     matchRange(static_cast<unsigned char>('\3'),static_cast<unsigned char>('\377'));
01498     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01499        _token = makeToken(_ttype);
01500        _token->setText(text.substr(_begin, text.length()-_begin));
01501     }
01502     _returnToken = _token;
01503     _saveIndex=0;
01504 }
01505 
01506 void JavaLexer::mIDENT(bool _createToken) {
01507     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01508     _ttype = IDENT;
01509     int _saveIndex;
01510     
01511     {
01512     switch ( LA(1)) {
01513     case static_cast<unsigned char>('a'):
01514     case static_cast<unsigned char>('b'):
01515     case static_cast<unsigned char>('c'):
01516     case static_cast<unsigned char>('d'):
01517     case static_cast<unsigned char>('e'):
01518     case static_cast<unsigned char>('f'):
01519     case static_cast<unsigned char>('g'):
01520     case static_cast<unsigned char>('h'):
01521     case static_cast<unsigned char>('i'):
01522     case static_cast<unsigned char>('j'):
01523     case static_cast<unsigned char>('k'):
01524     case static_cast<unsigned char>('l'):
01525     case static_cast<unsigned char>('m'):
01526     case static_cast<unsigned char>('n'):
01527     case static_cast<unsigned char>('o'):
01528     case static_cast<unsigned char>('p'):
01529     case static_cast<unsigned char>('q'):
01530     case static_cast<unsigned char>('r'):
01531     case static_cast<unsigned char>('s'):
01532     case static_cast<unsigned char>('t'):
01533     case static_cast<unsigned char>('u'):
01534     case static_cast<unsigned char>('v'):
01535     case static_cast<unsigned char>('w'):
01536     case static_cast<unsigned char>('x'):
01537     case static_cast<unsigned char>('y'):
01538     case static_cast<unsigned char>('z'):
01539     {
01540         matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
01541         break;
01542     }
01543     case static_cast<unsigned char>('A'):
01544     case static_cast<unsigned char>('B'):
01545     case static_cast<unsigned char>('C'):
01546     case static_cast<unsigned char>('D'):
01547     case static_cast<unsigned char>('E'):
01548     case static_cast<unsigned char>('F'):
01549     case static_cast<unsigned char>('G'):
01550     case static_cast<unsigned char>('H'):
01551     case static_cast<unsigned char>('I'):
01552     case static_cast<unsigned char>('J'):
01553     case static_cast<unsigned char>('K'):
01554     case static_cast<unsigned char>('L'):
01555     case static_cast<unsigned char>('M'):
01556     case static_cast<unsigned char>('N'):
01557     case static_cast<unsigned char>('O'):
01558     case static_cast<unsigned char>('P'):
01559     case static_cast<unsigned char>('Q'):
01560     case static_cast<unsigned char>('R'):
01561     case static_cast<unsigned char>('S'):
01562     case static_cast<unsigned char>('T'):
01563     case static_cast<unsigned char>('U'):
01564     case static_cast<unsigned char>('V'):
01565     case static_cast<unsigned char>('W'):
01566     case static_cast<unsigned char>('X'):
01567     case static_cast<unsigned char>('Y'):
01568     case static_cast<unsigned char>('Z'):
01569     {
01570         matchRange(static_cast<unsigned char>('A'),static_cast<unsigned char>('Z'));
01571         break;
01572     }
01573     case static_cast<unsigned char>('_'):
01574     {
01575         match(static_cast<unsigned char>('_'));
01576         break;
01577     }
01578     case static_cast<unsigned char>('$'):
01579     {
01580         match(static_cast<unsigned char>('$'));
01581         break;
01582     }
01583     default:
01584     {
01585         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01586     }
01587     }
01588     }
01589     { // ( ... )*
01590     for (;;) {
01591         switch ( LA(1)) {
01592         case static_cast<unsigned char>('a'):
01593         case static_cast<unsigned char>('b'):
01594         case static_cast<unsigned char>('c'):
01595         case static_cast<unsigned char>('d'):
01596         case static_cast<unsigned char>('e'):
01597         case static_cast<unsigned char>('f'):
01598         case static_cast<unsigned char>('g'):
01599         case static_cast<unsigned char>('h'):
01600         case static_cast<unsigned char>('i'):
01601         case static_cast<unsigned char>('j'):
01602         case static_cast<unsigned char>('k'):
01603         case static_cast<unsigned char>('l'):
01604         case static_cast<unsigned char>('m'):
01605         case static_cast<unsigned char>('n'):
01606         case static_cast<unsigned char>('o'):
01607         case static_cast<unsigned char>('p'):
01608         case static_cast<unsigned char>('q'):
01609         case static_cast<unsigned char>('r'):
01610         case static_cast<unsigned char>('s'):
01611         case static_cast<unsigned char>('t'):
01612         case static_cast<unsigned char>('u'):
01613         case static_cast<unsigned char>('v'):
01614         case static_cast<unsigned char>('w'):
01615         case static_cast<unsigned char>('x'):
01616         case static_cast<unsigned char>('y'):
01617         case static_cast<unsigned char>('z'):
01618         {
01619             matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
01620             break;
01621         }
01622         case static_cast<unsigned char>('A'):
01623         case static_cast<unsigned char>('B'):
01624         case static_cast<unsigned char>('C'):
01625         case static_cast<unsigned char>('D'):
01626         case static_cast<unsigned char>('E'):
01627         case static_cast<unsigned char>('F'):
01628         case static_cast<unsigned char>('G'):
01629         case static_cast<unsigned char>('H'):
01630         case static_cast<unsigned char>('I'):
01631         case static_cast<unsigned char>('J'):
01632         case static_cast<unsigned char>('K'):
01633         case static_cast<unsigned char>('L'):
01634         case static_cast<unsigned char>('M'):
01635         case static_cast<unsigned char>('N'):
01636         case static_cast<unsigned char>('O'):
01637         case static_cast<unsigned char>('P'):
01638         case static_cast<unsigned char>('Q'):
01639         case static_cast<unsigned char>('R'):
01640         case static_cast<unsigned char>('S'):
01641         case static_cast<unsigned char>('T'):
01642         case static_cast<unsigned char>('U'):
01643         case static_cast<unsigned char>('V'):
01644         case static_cast<unsigned char>('W'):
01645         case static_cast<unsigned char>('X'):
01646         case static_cast<unsigned char>('Y'):
01647         case static_cast<unsigned char>('Z'):
01648         {
01649             matchRange(static_cast<unsigned char>('A'),static_cast<unsigned char>('Z'));
01650             break;
01651         }
01652         case static_cast<unsigned char>('_'):
01653         {
01654             match(static_cast<unsigned char>('_'));
01655             break;
01656         }
01657         case static_cast<unsigned char>('0'):
01658         case static_cast<unsigned char>('1'):
01659         case static_cast<unsigned char>('2'):
01660         case static_cast<unsigned char>('3'):
01661         case static_cast<unsigned char>('4'):
01662         case static_cast<unsigned char>('5'):
01663         case static_cast<unsigned char>('6'):
01664         case static_cast<unsigned char>('7'):
01665         case static_cast<unsigned char>('8'):
01666         case static_cast<unsigned char>('9'):
01667         {
01668             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01669             break;
01670         }
01671         case static_cast<unsigned char>('$'):
01672         {
01673             match(static_cast<unsigned char>('$'));
01674             break;
01675         }
01676         default:
01677         {
01678             goto _loop275;
01679         }
01680         }
01681     }
01682     _loop275:;
01683     } // ( ... )*
01684     _ttype = testLiteralsTable(_ttype);
01685     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01686        _token = makeToken(_ttype);
01687        _token->setText(text.substr(_begin, text.length()-_begin));
01688     }
01689     _returnToken = _token;
01690     _saveIndex=0;
01691 }
01692 
01693 void JavaLexer::mNUM_INT(bool _createToken) {
01694     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01695     _ttype = NUM_INT;
01696     int _saveIndex;
01697     ANTLR_USE_NAMESPACE(antlr)RefToken f1;
01698     ANTLR_USE_NAMESPACE(antlr)RefToken f2;
01699     ANTLR_USE_NAMESPACE(antlr)RefToken f3;
01700     ANTLR_USE_NAMESPACE(antlr)RefToken f4;
01701 #line 1251 "java.g"
01702     
01703             bool isDecimal = false;
01704             ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken;
01705         
01706 #line 1707 "JavaLexer.cpp"
01707     
01708     switch ( LA(1)) {
01709     case static_cast<unsigned char>('.'):
01710     {
01711         match(static_cast<unsigned char>('.'));
01712 #line 1256 "java.g"
01713         _ttype = DOT;
01714 #line 1715 "JavaLexer.cpp"
01715         {
01716         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01717             { // ( ... )+
01718             int _cnt279=0;
01719             for (;;) {
01720                 if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01721                     matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01722                 }
01723                 else {
01724                     if ( _cnt279>=1 ) { goto _loop279; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01725                 }
01726                 
01727                 _cnt279++;
01728             }
01729             _loop279:;
01730             }  // ( ... )+
01731             {
01732             if ((LA(1) == static_cast<unsigned char>('E') || LA(1) == static_cast<unsigned char>('e'))) {
01733                 mEXPONENT(false);
01734             }
01735             else {
01736             }
01737             
01738             }
01739             {
01740             if ((LA(1) == static_cast<unsigned char>('D') || LA(1) == static_cast<unsigned char>('F') || LA(1) == static_cast<unsigned char>('d') || LA(1) == static_cast<unsigned char>('f'))) {
01741                 mFLOAT_SUFFIX(true);
01742                 f1=_returnToken;
01743 #line 1257 "java.g"
01744                 t=f1;
01745 #line 1746 "JavaLexer.cpp"
01746             }
01747             else {
01748             }
01749             
01750             }
01751 #line 1258 "java.g"
01752             
01753                                 if ( t &&
01754                                       (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
01755                                         t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
01756                                     _ttype = NUM_FLOAT;
01757                                 }
01758                                 else {
01759                                     _ttype = NUM_DOUBLE; // assume double
01760                                 }
01761                             
01762 #line 1763 "JavaLexer.cpp"
01763         }
01764         else {
01765         }
01766         
01767         }
01768         break;
01769     }
01770     case static_cast<unsigned char>('0'):
01771     case static_cast<unsigned char>('1'):
01772     case static_cast<unsigned char>('2'):
01773     case static_cast<unsigned char>('3'):
01774     case static_cast<unsigned char>('4'):
01775     case static_cast<unsigned char>('5'):
01776     case static_cast<unsigned char>('6'):
01777     case static_cast<unsigned char>('7'):
01778     case static_cast<unsigned char>('8'):
01779     case static_cast<unsigned char>('9'):
01780     {
01781         {
01782         switch ( LA(1)) {
01783         case static_cast<unsigned char>('0'):
01784         {
01785             match(static_cast<unsigned char>('0'));
01786 #line 1270 "java.g"
01787             isDecimal = true;
01788 #line 1789 "JavaLexer.cpp"
01789             {
01790             switch ( LA(1)) {
01791             case static_cast<unsigned char>('X'):
01792             case static_cast<unsigned char>('x'):
01793             {
01794                 {
01795                 switch ( LA(1)) {
01796                 case static_cast<unsigned char>('x'):
01797                 {
01798                     match(static_cast<unsigned char>('x'));
01799                     break;
01800                 }
01801                 case static_cast<unsigned char>('X'):
01802                 {
01803                     match(static_cast<unsigned char>('X'));
01804                     break;
01805                 }
01806                 default:
01807                 {
01808                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01809                 }
01810                 }
01811                 }
01812                 { // ( ... )+
01813                 int _cnt286=0;
01814                 for (;;) {
01815                     if ((_tokenSet_4.member(LA(1))) && (true) && (true) && (true)) {
01816                         mHEX_DIGIT(false);
01817                     }
01818                     else {
01819                         if ( _cnt286>=1 ) { goto _loop286; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01820                     }
01821                     
01822                     _cnt286++;
01823                 }
01824                 _loop286:;
01825                 }  // ( ... )+
01826                 break;
01827             }
01828             case static_cast<unsigned char>('0'):
01829             case static_cast<unsigned char>('1'):
01830             case static_cast<unsigned char>('2'):
01831             case static_cast<unsigned char>('3'):
01832             case static_cast<unsigned char>('4'):
01833             case static_cast<unsigned char>('5'):
01834             case static_cast<unsigned char>('6'):
01835             case static_cast<unsigned char>('7'):
01836             {
01837                 { // ( ... )+
01838                 int _cnt288=0;
01839                 for (;;) {
01840                     if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('7')))) {
01841                         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('7'));
01842                     }
01843                     else {
01844                         if ( _cnt288>=1 ) { goto _loop288; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01845                     }
01846                     
01847                     _cnt288++;
01848                 }
01849                 _loop288:;
01850                 }  // ( ... )+
01851                 break;
01852             }
01853             default:
01854                 {
01855                 }
01856             }
01857             }
01858             break;
01859         }
01860         case static_cast<unsigned char>('1'):
01861         case static_cast<unsigned char>('2'):
01862         case static_cast<unsigned char>('3'):
01863         case static_cast<unsigned char>('4'):
01864         case static_cast<unsigned char>('5'):
01865         case static_cast<unsigned char>('6'):
01866         case static_cast<unsigned char>('7'):
01867         case static_cast<unsigned char>('8'):
01868         case static_cast<unsigned char>('9'):
01869         {
01870             {
01871             matchRange(static_cast<unsigned char>('1'),static_cast<unsigned char>('9'));
01872             }
01873             { // ( ... )*
01874             for (;;) {
01875                 if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01876                     matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01877                 }
01878                 else {
01879                     goto _loop291;
01880                 }
01881                 
01882             }
01883             _loop291:;
01884             } // ( ... )*
01885 #line 1285 "java.g"
01886             isDecimal=true;
01887 #line 1888 "JavaLexer.cpp"
01888             break;
01889         }
01890         default:
01891         {
01892             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01893         }
01894         }
01895         }
01896         {
01897         if ((LA(1) == static_cast<unsigned char>('L') || LA(1) == static_cast<unsigned char>('l'))) {
01898             {
01899             switch ( LA(1)) {
01900             case static_cast<unsigned char>('l'):
01901             {
01902                 match(static_cast<unsigned char>('l'));
01903                 break;
01904             }
01905             case static_cast<unsigned char>('L'):
01906             {
01907                 match(static_cast<unsigned char>('L'));
01908                 break;
01909             }
01910             default:
01911             {
01912                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01913             }
01914             }
01915             }
01916 #line 1287 "java.g"
01917             _ttype = NUM_LONG;
01918 #line 1919 "JavaLexer.cpp"
01919         }
01920         else if (((LA(1) == static_cast<unsigned char>('.') || LA(1) == static_cast<unsigned char>('D') || LA(1) == static_cast<unsigned char>('E') || LA(1) == static_cast<unsigned char>('F') || LA(1) == static_cast<unsigned char>('d') || LA(1) == static_cast<unsigned char>('e') || LA(1) == static_cast<unsigned char>('f')))&&(isDecimal)) {
01921             {
01922             switch ( LA(1)) {
01923             case static_cast<unsigned char>('.'):
01924             {
01925                 match(static_cast<unsigned char>('.'));
01926                 { // ( ... )*
01927                 for (;;) {
01928                     if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01929                         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01930                     }
01931                     else {
01932                         goto _loop296;
01933                     }
01934                     
01935                 }
01936                 _loop296:;
01937                 } // ( ... )*
01938                 {
01939                 if ((LA(1) == static_cast<unsigned char>('E') || LA(1) == static_cast<unsigned char>('e'))) {
01940                     mEXPONENT(false);
01941                 }
01942                 else {
01943                 }
01944                 
01945                 }
01946                 {
01947                 if ((LA(1) == static_cast<unsigned char>('D') || LA(1) == static_cast<unsigned char>('F') || LA(1) == static_cast<unsigned char>('d') || LA(1) == static_cast<unsigned char>('f'))) {
01948                     mFLOAT_SUFFIX(true);
01949                     f2=_returnToken;
01950 #line 1291 "java.g"
01951                     t=f2;
01952 #line 1953 "JavaLexer.cpp"
01953                 }
01954                 else {
01955                 }
01956                 
01957                 }
01958                 break;
01959             }
01960             case static_cast<unsigned char>('E'):
01961             case static_cast<unsigned char>('e'):
01962             {
01963                 mEXPONENT(false);
01964                 {
01965                 if ((LA(1) == static_cast<unsigned char>('D') || LA(1) == static_cast<unsigned char>('F') || LA(1) == static_cast<unsigned char>('d') || LA(1) == static_cast<unsigned char>('f'))) {
01966                     mFLOAT_SUFFIX(true);
01967                     f3=_returnToken;
01968 #line 1292 "java.g"
01969                     t=f3;
01970 #line 1971 "JavaLexer.cpp"
01971                 }
01972                 else {
01973                 }
01974                 
01975                 }
01976                 break;
01977             }
01978             case static_cast<unsigned char>('D'):
01979             case static_cast<unsigned char>('F'):
01980             case static_cast<unsigned char>('d'):
01981             case static_cast<unsigned char>('f'):
01982             {
01983                 mFLOAT_SUFFIX(true);
01984                 f4=_returnToken;
01985 #line 1293 "java.g"
01986                 t=f4;
01987 #line 1988 "JavaLexer.cpp"
01988                 break;
01989             }
01990             default:
01991             {
01992                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01993             }
01994             }
01995             }
01996 #line 1295 "java.g"
01997             
01998                                 if ( t &&
01999                                       (t->getText().find('f') != ANTLR_USE_NAMESPACE(std)string::npos ||
02000                                         t->getText().find('F') != ANTLR_USE_NAMESPACE(std)string::npos ) ) {
02001                                     _ttype = NUM_FLOAT;
02002                                 }
02003                                 else {
02004                                     _ttype = NUM_DOUBLE; // assume double
02005                                 }
02006                             
02007 #line 2008 "JavaLexer.cpp"
02008         }
02009         else {
02010         }
02011         
02012         }
02013         break;
02014     }
02015     default:
02016     {
02017         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02018     }
02019     }
02020     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
02021        _token = makeToken(_ttype);
02022        _token->setText(text.substr(_begin, text.length()-_begin));
02023     }
02024     _returnToken = _token;
02025     _saveIndex=0;
02026 }
02027 
02028 void JavaLexer::mEXPONENT(bool _createToken) {
02029     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
02030     _ttype = EXPONENT;
02031     int _saveIndex;
02032     
02033     {
02034     switch ( LA(1)) {
02035     case static_cast<unsigned char>('e'):
02036     {
02037         match(static_cast<unsigned char>('e'));
02038         break;
02039     }
02040     case static_cast<unsigned char>('E'):
02041     {
02042         match(static_cast<unsigned char>('E'));
02043         break;
02044     }
02045     default:
02046     {
02047         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02048     }
02049     }
02050     }
02051     {
02052     switch ( LA(1)) {
02053     case static_cast<unsigned char>('+'):
02054     {
02055         match(static_cast<unsigned char>('+'));
02056         break;
02057     }
02058     case static_cast<unsigned char>('-'):
02059     {
02060         match(static_cast<unsigned char>('-'));
02061         break;
02062     }
02063     case static_cast<unsigned char>('0'):
02064     case static_cast<unsigned char>('1'):
02065     case static_cast<unsigned char>('2'):
02066     case static_cast<unsigned char>('3'):
02067     case static_cast<unsigned char>('4'):
02068     case static_cast<unsigned char>('5'):
02069     case static_cast<unsigned char>('6'):
02070     case static_cast<unsigned char>('7'):
02071     case static_cast<unsigned char>('8'):
02072     case static_cast<unsigned char>('9'):
02073     {
02074         break;
02075     }
02076     default:
02077     {
02078         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02079     }
02080     }
02081     }
02082     { // ( ... )+
02083     int _cnt304=0;
02084     for (;;) {
02085         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
02086             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
02087         }
02088         else {
02089             if ( _cnt304>=1 ) { goto _loop304; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
02090         }
02091         
02092         _cnt304++;
02093     }
02094     _loop304:;
02095     }  // ( ... )+
02096     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
02097        _token = makeToken(_ttype);
02098        _token->setText(text.substr(_begin, text.length()-_begin));
02099     }
02100     _returnToken = _token;
02101     _saveIndex=0;
02102 }
02103 
02104 void JavaLexer::mFLOAT_SUFFIX(bool _createToken) {
02105     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
02106     _ttype = FLOAT_SUFFIX;
02107     int _saveIndex;
02108     
02109     switch ( LA(1)) {
02110     case static_cast<unsigned char>('f'):
02111     {
02112         match(static_cast<unsigned char>('f'));
02113         break;
02114     }
02115     case static_cast<unsigned char>('F'):
02116     {
02117         match(static_cast<unsigned char>('F'));
02118         break;
02119     }
02120     case static_cast<unsigned char>('d'):
02121     {
02122         match(static_cast<unsigned char>('d'));
02123         break;
02124     }
02125     case static_cast<unsigned char>('D'):
02126     {
02127         match(static_cast<unsigned char>('D'));
02128         break;
02129     }
02130     default:
02131     {
02132         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
02133     }
02134     }
02135     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
02136        _token = makeToken(_ttype);
02137        _token->setText(text.substr(_begin, text.length()-_begin));
02138     }
02139     _returnToken = _token;
02140     _saveIndex=0;
02141 }
02142 
02143 
02144 const unsigned long JavaLexer::_tokenSet_0_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02145 // NULL_TREE_LOOKAHEAD BLOCK MODIFIERS OBJBLOCK SLIST CTOR_DEF METHOD_DEF 
02146 // INSTANCE_INIT STATIC_INIT CLASS_DEF INTERFACE_DEF PACKAGE_DEF ARRAY_DECLARATOR 
02147 // EXTENDS_CLAUSE IMPLEMENTS_CLAUSE PARAMETERS PARAMETER_DEF LABELED_STAT 
02148 // TYPECAST INDEX_OP POST_INC POST_DEC METHOD_CALL EXPR ARRAY_INIT IMPORT 
02149 // UNARY_MINUS UNARY_PLUS CASE_GROUP ELIST FOR_INIT FOR_CONDITION FOR_ITERATOR 
02150 // EMPTY_STAT "final" "abstract" "strictfp" SUPER_CTOR_CALL CTOR_CALL "package" 
02151 // SEMI "import" LBRACK RBRACK "void" "boolean" "byte" "char" "short" "int" 
02152 // "float" "long" "double" IDENT DOT STAR "private" "public" "protected" 
02153 // "static" "transient" "native" "threadsafe" "synchronized" "volatile" 
02154 // "class" "extends" "interface" LCURLY RCURLY COMMA "implements" LPAREN 
02155 // RPAREN "this" "super" ASSIGN "throws" COLON "if" "else" "for" "while" 
02156 // "do" "break" "continue" "return" "switch" "throw" "case" "default" "try" 
02157 // "finally" "catch" PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN 
02158 // SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION 
02159 // LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL 
02160 // SR BSR PLUS MINUS DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" 
02161 // NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE WS 
02162 // SL_COMMENT ML_COMMENT ESC HEX_DIGIT VOCAB EXPONENT FLOAT_SUFFIX 
02163 const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_0(_tokenSet_0_data_,16);
02164 const unsigned long JavaLexer::_tokenSet_1_data_[] = { 4294958072UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02165 // NULL_TREE_LOOKAHEAD BLOCK MODIFIERS OBJBLOCK SLIST CTOR_DEF METHOD_DEF 
02166 // INSTANCE_INIT STATIC_INIT CLASS_DEF INTERFACE_DEF PACKAGE_DEF ARRAY_DECLARATOR 
02167 // EXTENDS_CLAUSE IMPLEMENTS_CLAUSE PARAMETERS PARAMETER_DEF LABELED_STAT 
02168 // TYPECAST INDEX_OP POST_INC POST_DEC METHOD_CALL EXPR ARRAY_INIT IMPORT 
02169 // UNARY_MINUS UNARY_PLUS CASE_GROUP ELIST FOR_INIT FOR_CONDITION FOR_ITERATOR 
02170 // EMPTY_STAT "final" "abstract" "strictfp" CTOR_CALL "package" SEMI "import" 
02171 // LBRACK RBRACK "void" "boolean" "byte" "char" "short" "int" "float" "long" 
02172 // "double" IDENT DOT STAR "private" "public" "protected" "static" "transient" 
02173 // "native" "threadsafe" "synchronized" "volatile" "class" "extends" "interface" 
02174 // LCURLY RCURLY COMMA "implements" LPAREN RPAREN "this" "super" ASSIGN 
02175 // "throws" COLON "if" "else" "for" "while" "do" "break" "continue" "return" 
02176 // "switch" "throw" "case" "default" "try" "finally" "catch" PLUS_ASSIGN 
02177 // MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN SR_ASSIGN BSR_ASSIGN 
02178 // SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION LOR LAND BOR BXOR 
02179 // BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL SR BSR PLUS MINUS 
02180 // DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" NUM_INT CHAR_LITERAL 
02181 // STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE WS SL_COMMENT ML_COMMENT 
02182 // ESC HEX_DIGIT VOCAB EXPONENT FLOAT_SUFFIX 
02183 const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_1(_tokenSet_1_data_,16);
02184 const unsigned long JavaLexer::_tokenSet_2_data_[] = { 4294967288UL, 4294967167UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02185 // NULL_TREE_LOOKAHEAD BLOCK MODIFIERS OBJBLOCK SLIST CTOR_DEF METHOD_DEF 
02186 // VARIABLE_DEF INSTANCE_INIT STATIC_INIT TYPE CLASS_DEF INTERFACE_DEF 
02187 // PACKAGE_DEF ARRAY_DECLARATOR EXTENDS_CLAUSE IMPLEMENTS_CLAUSE PARAMETERS 
02188 // PARAMETER_DEF LABELED_STAT TYPECAST INDEX_OP POST_INC POST_DEC METHOD_CALL 
02189 // EXPR ARRAY_INIT IMPORT UNARY_MINUS UNARY_PLUS CASE_GROUP ELIST FOR_INIT 
02190 // FOR_CONDITION FOR_ITERATOR EMPTY_STAT "abstract" "strictfp" SUPER_CTOR_CALL 
02191 // CTOR_CALL "package" SEMI "import" LBRACK RBRACK "void" "boolean" "byte" 
02192 // "char" "short" "int" "float" "long" "double" IDENT DOT STAR "private" 
02193 // "public" "protected" "static" "transient" "native" "threadsafe" "synchronized" 
02194 // "volatile" "class" "extends" "interface" LCURLY RCURLY COMMA "implements" 
02195 // LPAREN RPAREN "this" "super" ASSIGN "throws" COLON "if" "else" "for" 
02196 // "while" "do" "break" "continue" "return" "throw" "case" "default" "try" 
02197 // "finally" "catch" PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN 
02198 // SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION 
02199 // LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL 
02200 // SR BSR PLUS MINUS DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" 
02201 // NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE WS 
02202 // SL_COMMENT ML_COMMENT ESC HEX_DIGIT VOCAB EXPONENT FLOAT_SUFFIX 
02203 const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_2(_tokenSet_2_data_,16);
02204 const unsigned long JavaLexer::_tokenSet_3_data_[] = { 4294967288UL, 4294967291UL, 4026531839UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02205 // NULL_TREE_LOOKAHEAD BLOCK MODIFIERS OBJBLOCK SLIST CTOR_DEF METHOD_DEF 
02206 // VARIABLE_DEF INSTANCE_INIT STATIC_INIT TYPE CLASS_DEF INTERFACE_DEF 
02207 // PACKAGE_DEF ARRAY_DECLARATOR EXTENDS_CLAUSE IMPLEMENTS_CLAUSE PARAMETERS 
02208 // PARAMETER_DEF LABELED_STAT TYPECAST INDEX_OP POST_INC POST_DEC METHOD_CALL 
02209 // EXPR ARRAY_INIT IMPORT UNARY_MINUS UNARY_PLUS CASE_GROUP FOR_INIT FOR_CONDITION 
02210 // FOR_ITERATOR EMPTY_STAT "final" "abstract" "strictfp" SUPER_CTOR_CALL 
02211 // CTOR_CALL "package" SEMI "import" LBRACK RBRACK "void" "boolean" "byte" 
02212 // "char" "short" "int" "float" "long" "double" IDENT DOT STAR "private" 
02213 // "public" "protected" "static" "transient" "native" "threadsafe" "synchronized" 
02214 // "volatile" "class" "extends" "interface" LCURLY RCURLY COMMA "implements" 
02215 // LPAREN RPAREN "this" "super" ASSIGN "throws" COLON "if" "else" "for" 
02216 // "while" "do" "break" "continue" "return" "throw" "case" "default" "try" 
02217 // "finally" "catch" PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN MOD_ASSIGN 
02218 // SR_ASSIGN BSR_ASSIGN SL_ASSIGN BAND_ASSIGN BXOR_ASSIGN BOR_ASSIGN QUESTION 
02219 // LOR LAND BOR BXOR BAND NOT_EQUAL EQUAL LT_ GT LE GE "instanceof" SL 
02220 // SR BSR PLUS MINUS DIV MOD INC DEC BNOT LNOT "true" "false" "null" "new" 
02221 // NUM_INT CHAR_LITERAL STRING_LITERAL NUM_FLOAT NUM_LONG NUM_DOUBLE WS 
02222 // SL_COMMENT ML_COMMENT ESC HEX_DIGIT VOCAB EXPONENT FLOAT_SUFFIX 
02223 const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_3(_tokenSet_3_data_,16);
02224 const unsigned long JavaLexer::_tokenSet_4_data_[] = { 0UL, 67043328UL, 126UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
02225 // RBRACK "void" "boolean" "byte" "char" "short" "int" "float" "long" "double" 
02226 // "transient" "native" "threadsafe" "synchronized" "volatile" "class" 
02227 // "finally" "catch" PLUS_ASSIGN MINUS_ASSIGN STAR_ASSIGN DIV_ASSIGN 
02228 const ANTLR_USE_NAMESPACE(antlr)BitSet JavaLexer::_tokenSet_4(_tokenSet_4_data_,10);
02229 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Feb 22 09:22:30 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003