GPLIB++: CRLSConfigLexer.cpp Source File

00001 /* $ANTLR 2.7.6 (20070220): "CRLSConfig.g" -> "CRLSConfigLexer.cpp"$ */
00002 #include "CRLSConfigLexer.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 1 "CRLSConfig.g"
00012 #line 13 "CRLSConfigLexer.cpp"
00013 CRLSConfigLexer::CRLSConfigLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 CRLSConfigLexer::CRLSConfigLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 CRLSConfigLexer::CRLSConfigLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void CRLSConfigLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken CRLSConfigLexer::nextToken()
00036 {
00037         antlr::RefToken theRetToken;
00038         for (;;) {
00039                 antlr::RefToken theRetToken;
00040                 int _ttype = antlr::Token::INVALID_TYPE;
00041                 resetText();
00042                 try {   // for lexical and char stream error handling
00043                         switch ( LA(1)) {
00044                         case 0x3d /* '=' */ :
00045                         {
00046                                 mEQUAL(true);
00047                                 theRetToken=_returnToken;
00048                                 break;
00049                         }
00050                         case 0x9 /* '\t' */ :
00051                         case 0xa /* '\n' */ :
00052                         case 0xd /* '\r' */ :
00053                         case 0x20 /* ' ' */ :
00054                         {
00055                                 mWS(true);
00056                                 theRetToken=_returnToken;
00057                                 break;
00058                         }
00059                         case 0x2b /* '+' */ :
00060                         case 0x2d /* '-' */ :
00061                         case 0x2e /* '.' */ :
00062                         case 0x30 /* '0' */ :
00063                         case 0x31 /* '1' */ :
00064                         case 0x32 /* '2' */ :
00065                         case 0x33 /* '3' */ :
00066                         case 0x34 /* '4' */ :
00067                         case 0x35 /* '5' */ :
00068                         case 0x36 /* '6' */ :
00069                         case 0x37 /* '7' */ :
00070                         case 0x38 /* '8' */ :
00071                         case 0x39 /* '9' */ :
00072                         {
00073                                 mNUMBER(true);
00074                                 theRetToken=_returnToken;
00075                                 break;
00076                         }
00077                         case 0x2f /* '/' */ :
00078                         {
00079                                 mCOMMENT(true);
00080                                 theRetToken=_returnToken;
00081                                 break;
00082                         }
00083                         default:
00084                                 if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x6c /* 'l' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x6e /* 'n' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
00085                                         mFILTERLENGTHT(true);
00086                                         theRetToken=_returnToken;
00087                                 }
00088                                 else if ((LA(1) == 0x6c /* 'l' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6d /* 'm' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x64 /* 'd' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (true) && (true) && (true) && (true)) {
00089                                         mLAMBDAT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 else if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true)) {
00093                                         mFALSE(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 else if ((LA(1) == 0x64 /* 'd' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (true) && (true) && (true) && (true) && (true)) {
00097                                         mDELTAT(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true)) {
00101                                         mSHIFTT(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00105                                         mTRUE(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00109                                         mSTRING(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                         else {
00113                                 if (LA(1)==EOF_CHAR)
00114                                 {
00115                                         uponEOF();
00116                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00117                                 }
00118                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00119                         }
00120                         }
00121                         if ( !_returnToken )
00122                                 goto tryAgain; // found SKIP token
00123 
00124                         _ttype = _returnToken->getType();
00125                         _ttype = testLiteralsTable(_ttype);
00126                         _returnToken->setType(_ttype);
00127                         return _returnToken;
00128                 }
00129                 catch (antlr::RecognitionException& e) {
00130                                 throw antlr::TokenStreamRecognitionException(e);
00131                 }
00132                 catch (antlr::CharStreamIOException& csie) {
00133                         throw antlr::TokenStreamIOException(csie.io);
00134                 }
00135                 catch (antlr::CharStreamException& cse) {
00136                         throw antlr::TokenStreamException(cse.getMessage());
00137                 }
00138 tryAgain:;
00139         }
00140 }
00141 
00142 void CRLSConfigLexer::mEQUAL(bool _createToken) {
00143         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00144         _ttype = EQUAL;
00145         std::string::size_type _saveIndex;
00146         
00147         match('=' /* charlit */ );
00148         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00149            _token = makeToken(_ttype);
00150            _token->setText(text.substr(_begin, text.length()-_begin));
00151         }
00152         _returnToken = _token;
00153         _saveIndex=0;
00154 }
00155 
00156 void CRLSConfigLexer::mTRUE(bool _createToken) {
00157         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00158         _ttype = TRUE;
00159         std::string::size_type _saveIndex;
00160         
00161         match("true");
00162         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00163            _token = makeToken(_ttype);
00164            _token->setText(text.substr(_begin, text.length()-_begin));
00165         }
00166         _returnToken = _token;
00167         _saveIndex=0;
00168 }
00169 
00170 void CRLSConfigLexer::mFALSE(bool _createToken) {
00171         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00172         _ttype = FALSE;
00173         std::string::size_type _saveIndex;
00174         
00175         match("false");
00176         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00177            _token = makeToken(_ttype);
00178            _token->setText(text.substr(_begin, text.length()-_begin));
00179         }
00180         _returnToken = _token;
00181         _saveIndex=0;
00182 }
00183 
00184 void CRLSConfigLexer::mWS(bool _createToken) {
00185         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00186         _ttype = WS;
00187         std::string::size_type _saveIndex;
00188         
00189         { // ( ... )+
00190         int _cnt34=0;
00191         for (;;) {
00192                 switch ( LA(1)) {
00193                 case 0x20 /* ' ' */ :
00194                 {
00195                         match(' ' /* charlit */ );
00196                         break;
00197                 }
00198                 case 0xa /* '\n' */ :
00199                 case 0xd /* '\r' */ :
00200                 {
00201                         mNEWLINE(false);
00202                         break;
00203                 }
00204                 case 0x9 /* '\t' */ :
00205                 {
00206                         match('\t' /* charlit */ );
00207                         break;
00208                 }
00209                 default:
00210                 {
00211                         if ( _cnt34>=1 ) { goto _loop34; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00212                 }
00213                 }
00214                 _cnt34++;
00215         }
00216         _loop34:;
00217         }  // ( ... )+
00218         if ( inputState->guessing==0 ) {
00219 #line 70 "CRLSConfig.g"
00220                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00221 #line 222 "CRLSConfigLexer.cpp"
00222         }
00223         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00224            _token = makeToken(_ttype);
00225            _token->setText(text.substr(_begin, text.length()-_begin));
00226         }
00227         _returnToken = _token;
00228         _saveIndex=0;
00229 }
00230 
00231 void CRLSConfigLexer::mNEWLINE(bool _createToken) {
00232         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00233         _ttype = NEWLINE;
00234         std::string::size_type _saveIndex;
00235         
00236         {
00237         switch ( LA(1)) {
00238         case 0xa /* '\n' */ :
00239         {
00240                 match('\n' /* charlit */ );
00241                 break;
00242         }
00243         case 0xd /* '\r' */ :
00244         {
00245                 match('\r' /* charlit */ );
00246                 match('\n' /* charlit */ );
00247                 break;
00248         }
00249         default:
00250         {
00251                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00252         }
00253         }
00254         }
00255         if ( inputState->guessing==0 ) {
00256 #line 96 "CRLSConfig.g"
00257                 newline();
00258 #line 259 "CRLSConfigLexer.cpp"
00259         }
00260         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00261            _token = makeToken(_ttype);
00262            _token->setText(text.substr(_begin, text.length()-_begin));
00263         }
00264         _returnToken = _token;
00265         _saveIndex=0;
00266 }
00267 
00268 void CRLSConfigLexer::mSTRING(bool _createToken) {
00269         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00270         _ttype = STRING;
00271         std::string::size_type _saveIndex;
00272         
00273         mCHAR(false);
00274         { // ( ... )*
00275         for (;;) {
00276                 switch ( LA(1)) {
00277                 case 0x61 /* 'a' */ :
00278                 case 0x62 /* 'b' */ :
00279                 case 0x63 /* 'c' */ :
00280                 case 0x64 /* 'd' */ :
00281                 case 0x65 /* 'e' */ :
00282                 case 0x66 /* 'f' */ :
00283                 case 0x67 /* 'g' */ :
00284                 case 0x68 /* 'h' */ :
00285                 case 0x69 /* 'i' */ :
00286                 case 0x6a /* 'j' */ :
00287                 case 0x6b /* 'k' */ :
00288                 case 0x6c /* 'l' */ :
00289                 case 0x6d /* 'm' */ :
00290                 case 0x6e /* 'n' */ :
00291                 case 0x6f /* 'o' */ :
00292                 case 0x70 /* 'p' */ :
00293                 case 0x71 /* 'q' */ :
00294                 case 0x72 /* 'r' */ :
00295                 case 0x73 /* 's' */ :
00296                 case 0x74 /* 't' */ :
00297                 case 0x75 /* 'u' */ :
00298                 case 0x76 /* 'v' */ :
00299                 case 0x77 /* 'w' */ :
00300                 case 0x78 /* 'x' */ :
00301                 case 0x79 /* 'y' */ :
00302                 case 0x7a /* 'z' */ :
00303                 {
00304                         mCHAR(false);
00305                         break;
00306                 }
00307                 case 0x30 /* '0' */ :
00308                 case 0x31 /* '1' */ :
00309                 case 0x32 /* '2' */ :
00310                 case 0x33 /* '3' */ :
00311                 case 0x34 /* '4' */ :
00312                 case 0x35 /* '5' */ :
00313                 case 0x36 /* '6' */ :
00314                 case 0x37 /* '7' */ :
00315                 case 0x38 /* '8' */ :
00316                 case 0x39 /* '9' */ :
00317                 {
00318                         mDIGIT(false);
00319                         break;
00320                 }
00321                 case 0x23 /* '#' */ :
00322                 case 0x24 /* '$' */ :
00323                 case 0x25 /* '%' */ :
00324                 case 0x26 /* '&' */ :
00325                 case 0x27 /* '\'' */ :
00326                 case 0x28 /* '(' */ :
00327                 case 0x29 /* ')' */ :
00328                 case 0x2a /* '*' */ :
00329                 case 0x2b /* '+' */ :
00330                 case 0x2c /* ',' */ :
00331                 case 0x2d /* '-' */ :
00332                 case 0x2e /* '.' */ :
00333                 case 0x2f /* '/' */ :
00334                 case 0x3a /* ':' */ :
00335                 case 0x3b /* ';' */ :
00336                 case 0x3c /* '<' */ :
00337                 case 0x3f /* '?' */ :
00338                 case 0x40 /* '@' */ :
00339                 case 0x5b /* '[' */ :
00340                 case 0x5d /* ']' */ :
00341                 case 0x5e /* '^' */ :
00342                 case 0x5f /* '_' */ :
00343                 case 0x7b /* '{' */ :
00344                 case 0x7c /* '|' */ :
00345                 case 0x7d /* '}' */ :
00346                 case 0x7e /* '~' */ :
00347                 {
00348                         mOTHER(false);
00349                         break;
00350                 }
00351                 default:
00352                 {
00353                         goto _loop37;
00354                 }
00355                 }
00356         }
00357         _loop37:;
00358         } // ( ... )*
00359         _ttype = testLiteralsTable(_ttype);
00360         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00361            _token = makeToken(_ttype);
00362            _token->setText(text.substr(_begin, text.length()-_begin));
00363         }
00364         _returnToken = _token;
00365         _saveIndex=0;
00366 }
00367 
00368 void CRLSConfigLexer::mCHAR(bool _createToken) {
00369         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00370         _ttype = CHAR;
00371         std::string::size_type _saveIndex;
00372         
00373         {
00374         matchRange('a','z');
00375         }
00376         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00377            _token = makeToken(_ttype);
00378            _token->setText(text.substr(_begin, text.length()-_begin));
00379         }
00380         _returnToken = _token;
00381         _saveIndex=0;
00382 }
00383 
00384 void CRLSConfigLexer::mDIGIT(bool _createToken) {
00385         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00386         _ttype = DIGIT;
00387         std::string::size_type _saveIndex;
00388         
00389         matchRange('0','9');
00390         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00391            _token = makeToken(_ttype);
00392            _token->setText(text.substr(_begin, text.length()-_begin));
00393         }
00394         _returnToken = _token;
00395         _saveIndex=0;
00396 }
00397 
00398 void CRLSConfigLexer::mOTHER(bool _createToken) {
00399         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00400         _ttype = OTHER;
00401         std::string::size_type _saveIndex;
00402         
00403         switch ( LA(1)) {
00404         case 0x27 /* '\'' */ :
00405         {
00406                 match('\'' /* charlit */ );
00407                 break;
00408         }
00409         case 0x23 /* '#' */ :
00410         {
00411                 match('#' /* charlit */ );
00412                 break;
00413         }
00414         case 0x24 /* '$' */ :
00415         {
00416                 match('$' /* charlit */ );
00417                 break;
00418         }
00419         case 0x25 /* '%' */ :
00420         {
00421                 match('%' /* charlit */ );
00422                 break;
00423         }
00424         case 0x26 /* '&' */ :
00425         {
00426                 match('&' /* charlit */ );
00427                 break;
00428         }
00429         case 0x28 /* '(' */ :
00430         {
00431                 match('(' /* charlit */ );
00432                 break;
00433         }
00434         case 0x29 /* ')' */ :
00435         {
00436                 match(')' /* charlit */ );
00437                 break;
00438         }
00439         case 0x2a /* '*' */ :
00440         {
00441                 match('*' /* charlit */ );
00442                 break;
00443         }
00444         case 0x2b /* '+' */ :
00445         {
00446                 match('+' /* charlit */ );
00447                 break;
00448         }
00449         case 0x2c /* ',' */ :
00450         {
00451                 match(',' /* charlit */ );
00452                 break;
00453         }
00454         case 0x2d /* '-' */ :
00455         {
00456                 match('-' /* charlit */ );
00457                 break;
00458         }
00459         case 0x2e /* '.' */ :
00460         {
00461                 match('.' /* charlit */ );
00462                 break;
00463         }
00464         case 0x2f /* '/' */ :
00465         {
00466                 match('/' /* charlit */ );
00467                 break;
00468         }
00469         case 0x3a /* ':' */ :
00470         {
00471                 match(':' /* charlit */ );
00472                 break;
00473         }
00474         case 0x3b /* ';' */ :
00475         {
00476                 match(';' /* charlit */ );
00477                 break;
00478         }
00479         case 0x3c /* '<' */ :
00480         {
00481                 match('<' /* charlit */ );
00482                 break;
00483         }
00484         case 0x3f /* '?' */ :
00485         {
00486                 match('?' /* charlit */ );
00487                 break;
00488         }
00489         case 0x40 /* '@' */ :
00490         {
00491                 match('@' /* charlit */ );
00492                 break;
00493         }
00494         case 0x5b /* '[' */ :
00495         {
00496                 match('[' /* charlit */ );
00497                 break;
00498         }
00499         case 0x5d /* ']' */ :
00500         {
00501                 match(']' /* charlit */ );
00502                 break;
00503         }
00504         case 0x5e /* '^' */ :
00505         {
00506                 match('^' /* charlit */ );
00507                 break;
00508         }
00509         case 0x5f /* '_' */ :
00510         {
00511                 match('_' /* charlit */ );
00512                 break;
00513         }
00514         case 0x7b /* '{' */ :
00515         {
00516                 match('{' /* charlit */ );
00517                 break;
00518         }
00519         case 0x7c /* '|' */ :
00520         {
00521                 match('|' /* charlit */ );
00522                 break;
00523         }
00524         case 0x7d /* '}' */ :
00525         {
00526                 match('}' /* charlit */ );
00527                 break;
00528         }
00529         case 0x7e /* '~' */ :
00530         {
00531                 match('~' /* charlit */ );
00532                 break;
00533         }
00534         default:
00535         {
00536                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00537         }
00538         }
00539         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00540            _token = makeToken(_ttype);
00541            _token->setText(text.substr(_begin, text.length()-_begin));
00542         }
00543         _returnToken = _token;
00544         _saveIndex=0;
00545 }
00546 
00547 void CRLSConfigLexer::mNUMBER(bool _createToken) {
00548         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00549         _ttype = NUMBER;
00550         std::string::size_type _saveIndex;
00551         
00552         {
00553         switch ( LA(1)) {
00554         case 0x2b /* '+' */ :
00555         {
00556                 match('+' /* charlit */ );
00557                 break;
00558         }
00559         case 0x2d /* '-' */ :
00560         {
00561                 match('-' /* charlit */ );
00562                 break;
00563         }
00564         case 0x2e /* '.' */ :
00565         case 0x30 /* '0' */ :
00566         case 0x31 /* '1' */ :
00567         case 0x32 /* '2' */ :
00568         case 0x33 /* '3' */ :
00569         case 0x34 /* '4' */ :
00570         case 0x35 /* '5' */ :
00571         case 0x36 /* '6' */ :
00572         case 0x37 /* '7' */ :
00573         case 0x38 /* '8' */ :
00574         case 0x39 /* '9' */ :
00575         {
00576                 break;
00577         }
00578         default:
00579         {
00580                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00581         }
00582         }
00583         }
00584         {
00585         bool synPredMatched42 = false;
00586         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00587                 int _m42 = mark();
00588                 synPredMatched42 = true;
00589                 inputState->guessing++;
00590                 try {
00591                         {
00592                         mREAL(false);
00593                         }
00594                 }
00595                 catch (antlr::RecognitionException& pe) {
00596                         synPredMatched42 = false;
00597                 }
00598                 rewind(_m42);
00599                 inputState->guessing--;
00600         }
00601         if ( synPredMatched42 ) {
00602                 mREAL(false);
00603         }
00604         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00605                 mINT(false);
00606         }
00607         else {
00608                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00609         }
00610         
00611         }
00612         {
00613         if ((LA(1) == 0x65 /* 'e' */ )) {
00614                 {
00615                 match('e' /* charlit */ );
00616                 }
00617                 {
00618                 switch ( LA(1)) {
00619                 case 0x2b /* '+' */ :
00620                 {
00621                         match('+' /* charlit */ );
00622                         break;
00623                 }
00624                 case 0x2d /* '-' */ :
00625                 {
00626                         match('-' /* charlit */ );
00627                         break;
00628                 }
00629                 case 0x30 /* '0' */ :
00630                 case 0x31 /* '1' */ :
00631                 case 0x32 /* '2' */ :
00632                 case 0x33 /* '3' */ :
00633                 case 0x34 /* '4' */ :
00634                 case 0x35 /* '5' */ :
00635                 case 0x36 /* '6' */ :
00636                 case 0x37 /* '7' */ :
00637                 case 0x38 /* '8' */ :
00638                 case 0x39 /* '9' */ :
00639                 {
00640                         break;
00641                 }
00642                 default:
00643                 {
00644                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00645                 }
00646                 }
00647                 }
00648                 mINT(false);
00649         }
00650         else {
00651         }
00652         
00653         }
00654         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00655            _token = makeToken(_ttype);
00656            _token->setText(text.substr(_begin, text.length()-_begin));
00657         }
00658         _returnToken = _token;
00659         _saveIndex=0;
00660 }
00661 
00662 void CRLSConfigLexer::mREAL(bool _createToken) {
00663         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00664         _ttype = REAL;
00665         std::string::size_type _saveIndex;
00666         
00667         {
00668         switch ( LA(1)) {
00669         case 0x2e /* '.' */ :
00670         {
00671                 match('.' /* charlit */ );
00672                 mINT(false);
00673                 break;
00674         }
00675         case 0x30 /* '0' */ :
00676         case 0x31 /* '1' */ :
00677         case 0x32 /* '2' */ :
00678         case 0x33 /* '3' */ :
00679         case 0x34 /* '4' */ :
00680         case 0x35 /* '5' */ :
00681         case 0x36 /* '6' */ :
00682         case 0x37 /* '7' */ :
00683         case 0x38 /* '8' */ :
00684         case 0x39 /* '9' */ :
00685         {
00686                 mINT(false);
00687                 match('.' /* charlit */ );
00688                 {
00689                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00690                         mINT(false);
00691                 }
00692                 else {
00693                 }
00694                 
00695                 }
00696                 break;
00697         }
00698         default:
00699         {
00700                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00701         }
00702         }
00703         }
00704         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00705            _token = makeToken(_ttype);
00706            _token->setText(text.substr(_begin, text.length()-_begin));
00707         }
00708         _returnToken = _token;
00709         _saveIndex=0;
00710 }
00711 
00712 void CRLSConfigLexer::mINT(bool _createToken) {
00713         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00714         _ttype = INT;
00715         std::string::size_type _saveIndex;
00716         
00717         { // ( ... )+
00718         int _cnt57=0;
00719         for (;;) {
00720                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00721                         mDIGIT(false);
00722                 }
00723                 else {
00724                         if ( _cnt57>=1 ) { goto _loop57; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00725                 }
00726                 
00727                 _cnt57++;
00728         }
00729         _loop57:;
00730         }  // ( ... )+
00731         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00732            _token = makeToken(_ttype);
00733            _token->setText(text.substr(_begin, text.length()-_begin));
00734         }
00735         _returnToken = _token;
00736         _saveIndex=0;
00737 }
00738 
00739 void CRLSConfigLexer::mCOMMENT(bool _createToken) {
00740         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00741         _ttype = COMMENT;
00742         std::string::size_type _saveIndex;
00743         
00744         match('/' /* charlit */ );
00745         match('/' /* charlit */ );
00746         { // ( ... )*
00747         for (;;) {
00748                 if ((_tokenSet_1.member(LA(1)))) {
00749                         {
00750                         match(_tokenSet_1);
00751                         }
00752                 }
00753                 else {
00754                         goto _loop49;
00755                 }
00756                 
00757         }
00758         _loop49:;
00759         } // ( ... )*
00760         mNEWLINE(false);
00761         if ( inputState->guessing==0 ) {
00762 #line 87 "CRLSConfig.g"
00763                 
00764                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00765                                 
00766 #line 767 "CRLSConfigLexer.cpp"
00767         }
00768         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00769            _token = makeToken(_ttype);
00770            _token->setText(text.substr(_begin, text.length()-_begin));
00771         }
00772         _returnToken = _token;
00773         _saveIndex=0;
00774 }
00775 
00776 void CRLSConfigLexer::mDELTAT(bool _createToken) {
00777         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00778         _ttype = DELTAT;
00779         std::string::size_type _saveIndex;
00780         
00781         match("delta");
00782         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00783            _token = makeToken(_ttype);
00784            _token->setText(text.substr(_begin, text.length()-_begin));
00785         }
00786         _returnToken = _token;
00787         _saveIndex=0;
00788 }
00789 
00790 void CRLSConfigLexer::mFILTERLENGTHT(bool _createToken) {
00791         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00792         _ttype = FILTERLENGTHT;
00793         std::string::size_type _saveIndex;
00794         
00795         match("filterlength");
00796         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00797            _token = makeToken(_ttype);
00798            _token->setText(text.substr(_begin, text.length()-_begin));
00799         }
00800         _returnToken = _token;
00801         _saveIndex=0;
00802 }
00803 
00804 void CRLSConfigLexer::mSHIFTT(bool _createToken) {
00805         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00806         _ttype = SHIFTT;
00807         std::string::size_type _saveIndex;
00808         
00809         match("shift");
00810         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00811            _token = makeToken(_ttype);
00812            _token->setText(text.substr(_begin, text.length()-_begin));
00813         }
00814         _returnToken = _token;
00815         _saveIndex=0;
00816 }
00817 
00818 void CRLSConfigLexer::mLAMBDAT(bool _createToken) {
00819         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00820         _ttype = LAMBDAT;
00821         std::string::size_type _saveIndex;
00822         
00823         match("lambda");
00824         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00825            _token = makeToken(_ttype);
00826            _token->setText(text.substr(_begin, text.length()-_begin));
00827         }
00828         _returnToken = _token;
00829         _saveIndex=0;
00830 }
00831 
00832 
00833 const unsigned long CRLSConfigLexer::_tokenSet_0_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL };
00834 const antlr::BitSet CRLSConfigLexer::_tokenSet_0(_tokenSet_0_data_,6);
00835 const unsigned long CRLSConfigLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
00836 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
00837 // 0x13 0x14 
00838 const antlr::BitSet CRLSConfigLexer::_tokenSet_1(_tokenSet_1_data_,8);
00839