Seismic Tools

CCalcRecConfLexer.cpp

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