MT Tools » 1DMT

MakeInputConfLexer.cpp

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