Seismic Tools

SurfInvGaConfLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.6 (20070220): "SurfInvGaConf.g" -> "SurfInvGaConfLexer.cpp"$ */
00002 #include "SurfInvGaConfLexer.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 "SurfInvGaConf.g"
00012 #line 13 "SurfInvGaConfLexer.cpp"
00013 SurfInvGaConfLexer::SurfInvGaConfLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 SurfInvGaConfLexer::SurfInvGaConfLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 SurfInvGaConfLexer::SurfInvGaConfLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void SurfInvGaConfLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken SurfInvGaConfLexer::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) == 0x75 /* 'u' */ ) && (LA(2) == 0x73 /* 's' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x76 /* 'v' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x66 /* 'f' */ ) && (LA(8) == 0x6d /* 'm' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x64 /* 'd' */ )) {
00085                                         mUSEVREFMODELT(true);
00086                                         theRetToken=_returnToken;
00087                                 }
00088                                 else if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x78 /* 'x' */ ) && (LA(6) == 0x70 /* 'p' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00089                                         mFITEXPONENTT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x6e /* 'n' */ ) && (LA(7) == 0x67 /* 'g' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00093                                         mCOOLINGRATIOT(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 else if ((LA(1) == 0x67 /* 'g' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00097                                         mGENERATIONST(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x61 /* 'a' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (LA(10) == 0x72 /* 'r' */ )) {
00101                                         mMUTATIONPROBT(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x76 /* 'v' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x72 /* 'r' */ ) && (LA(10) == 0x70 /* 'p' */ )) {
00105                                         mCROSSOVERPROBT(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x6f /* 'o' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x76 /* 'v' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x6c /* 'l' */ )) {
00109                                         mERRORLEVELT(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                                 else 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' */ )) {
00113                                         mOUTPUTBASET(true);
00114                                         theRetToken=_returnToken;
00115                                 }
00116                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x67 /* 'g' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
00117                                         mANNEALINGGENERATIONT(true);
00118                                         theRetToken=_returnToken;
00119                                 }
00120                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x7a /* 'z' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x73 /* 's' */ )) {
00121                                         mTHICKSIZEST(true);
00122                                         theRetToken=_returnToken;
00123                                 }
00124                                 else if ((LA(1) == 0x76 /* 'v' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x6d /* 'm' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x64 /* 'd' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x6c /* 'l' */ ) && (true)) {
00125                                         mVREFMODELT(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 else if ((LA(1) == 0x69 /* 'i' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x70 /* 'p' */ ) && (LA(4) == 0x75 /* 'u' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x64 /* 'd' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x74 /* 't' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (true)) {
00129                                         mINPUTDATAT(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x62 /* 'b' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x73 /* 's' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00133                                         mTHICKBASET(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (true)) {
00137                                         mTHICKSTEPT(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x7a /* 'z' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x73 /* 's' */ ) && (true)) {
00141                                         mSVELSIZEST(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 else if ((LA(1) == 0x69 /* 'i' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x6d /* 'm' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (true) && (true)) {
00145                                         mINITTEMPT(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x62 /* 'b' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (true) && (true)) {
00149                                         mSVELBASET(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (true) && (true)) {
00153                                         mSVELSTEPT(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 else if ((LA(1) == 0x76 /* 'v' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00157                                         mVERBOSET(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x70 /* 'p' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x7a /* 'z' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00161                                         mPOPSIZET(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 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)) {
00165                                         mPOISSONT(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x64 /* 'd' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00169                                         mTHREADST(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (true) && (true) && (true)) {
00173                                         mELITISTT(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if ((LA(1) == 0x77 /* 'w' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x67 /* 'g' */ ) && (LA(5) == 0x68 /* 'h' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00177                                         mWEIGHTST(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 else if ((LA(1) == 0x67 /* 'g' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x79 /* 'y' */ ) && (LA(5) == 0x70 /* 'p' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true)) {
00181                                         mGATYPET(true);
00182                                         theRetToken=_returnToken;
00183                                 }
00184                                 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)) {
00185                                         mFALSE(true);
00186                                         theRetToken=_returnToken;
00187                                 }
00188                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00189                                         mTRUE(true);
00190                                         theRetToken=_returnToken;
00191                                 }
00192                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00193                                         mSTRING(true);
00194                                         theRetToken=_returnToken;
00195                                 }
00196                         else {
00197                                 if (LA(1)==EOF_CHAR)
00198                                 {
00199                                         uponEOF();
00200                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00201                                 }
00202                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00203                         }
00204                         }
00205                         if ( !_returnToken )
00206                                 goto tryAgain; // found SKIP token
00207 
00208                         _ttype = _returnToken->getType();
00209                         _ttype = testLiteralsTable(_ttype);
00210                         _returnToken->setType(_ttype);
00211                         return _returnToken;
00212                 }
00213                 catch (antlr::RecognitionException& e) {
00214                                 throw antlr::TokenStreamRecognitionException(e);
00215                 }
00216                 catch (antlr::CharStreamIOException& csie) {
00217                         throw antlr::TokenStreamIOException(csie.io);
00218                 }
00219                 catch (antlr::CharStreamException& cse) {
00220                         throw antlr::TokenStreamException(cse.getMessage());
00221                 }
00222 tryAgain:;
00223         }
00224 }
00225 
00226 void SurfInvGaConfLexer::mEQUAL(bool _createToken) {
00227         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00228         _ttype = EQUAL;
00229         std::string::size_type _saveIndex;
00230         
00231         match('=' /* charlit */ );
00232         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00233            _token = makeToken(_ttype);
00234            _token->setText(text.substr(_begin, text.length()-_begin));
00235         }
00236         _returnToken = _token;
00237         _saveIndex=0;
00238 }
00239 
00240 void SurfInvGaConfLexer::mTRUE(bool _createToken) {
00241         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00242         _ttype = TRUE;
00243         std::string::size_type _saveIndex;
00244         
00245         match("true");
00246         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00247            _token = makeToken(_ttype);
00248            _token->setText(text.substr(_begin, text.length()-_begin));
00249         }
00250         _returnToken = _token;
00251         _saveIndex=0;
00252 }
00253 
00254 void SurfInvGaConfLexer::mFALSE(bool _createToken) {
00255         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00256         _ttype = FALSE;
00257         std::string::size_type _saveIndex;
00258         
00259         match("false");
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 SurfInvGaConfLexer::mWS(bool _createToken) {
00269         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00270         _ttype = WS;
00271         std::string::size_type _saveIndex;
00272         
00273         { // ( ... )+
00274         int _cnt126=0;
00275         for (;;) {
00276                 switch ( LA(1)) {
00277                 case 0x20 /* ' ' */ :
00278                 {
00279                         match(' ' /* charlit */ );
00280                         break;
00281                 }
00282                 case 0xa /* '\n' */ :
00283                 case 0xd /* '\r' */ :
00284                 {
00285                         mNEWLINE(false);
00286                         break;
00287                 }
00288                 case 0x9 /* '\t' */ :
00289                 {
00290                         match('\t' /* charlit */ );
00291                         break;
00292                 }
00293                 default:
00294                 {
00295                         if ( _cnt126>=1 ) { goto _loop126; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00296                 }
00297                 }
00298                 _cnt126++;
00299         }
00300         _loop126:;
00301         }  // ( ... )+
00302         if ( inputState->guessing==0 ) {
00303 #line 122 "SurfInvGaConf.g"
00304                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00305 #line 306 "SurfInvGaConfLexer.cpp"
00306         }
00307         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00308            _token = makeToken(_ttype);
00309            _token->setText(text.substr(_begin, text.length()-_begin));
00310         }
00311         _returnToken = _token;
00312         _saveIndex=0;
00313 }
00314 
00315 void SurfInvGaConfLexer::mNEWLINE(bool _createToken) {
00316         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00317         _ttype = NEWLINE;
00318         std::string::size_type _saveIndex;
00319         
00320         {
00321         switch ( LA(1)) {
00322         case 0xa /* '\n' */ :
00323         {
00324                 match('\n' /* charlit */ );
00325                 break;
00326         }
00327         case 0xd /* '\r' */ :
00328         {
00329                 match('\r' /* charlit */ );
00330                 match('\n' /* charlit */ );
00331                 break;
00332         }
00333         default:
00334         {
00335                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00336         }
00337         }
00338         }
00339         if ( inputState->guessing==0 ) {
00340 #line 148 "SurfInvGaConf.g"
00341                 newline();
00342 #line 343 "SurfInvGaConfLexer.cpp"
00343         }
00344         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00345            _token = makeToken(_ttype);
00346            _token->setText(text.substr(_begin, text.length()-_begin));
00347         }
00348         _returnToken = _token;
00349         _saveIndex=0;
00350 }
00351 
00352 void SurfInvGaConfLexer::mSTRING(bool _createToken) {
00353         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00354         _ttype = STRING;
00355         std::string::size_type _saveIndex;
00356         
00357         mCHAR(false);
00358         { // ( ... )*
00359         for (;;) {
00360                 switch ( LA(1)) {
00361                 case 0x61 /* 'a' */ :
00362                 case 0x62 /* 'b' */ :
00363                 case 0x63 /* 'c' */ :
00364                 case 0x64 /* 'd' */ :
00365                 case 0x65 /* 'e' */ :
00366                 case 0x66 /* 'f' */ :
00367                 case 0x67 /* 'g' */ :
00368                 case 0x68 /* 'h' */ :
00369                 case 0x69 /* 'i' */ :
00370                 case 0x6a /* 'j' */ :
00371                 case 0x6b /* 'k' */ :
00372                 case 0x6c /* 'l' */ :
00373                 case 0x6d /* 'm' */ :
00374                 case 0x6e /* 'n' */ :
00375                 case 0x6f /* 'o' */ :
00376                 case 0x70 /* 'p' */ :
00377                 case 0x71 /* 'q' */ :
00378                 case 0x72 /* 'r' */ :
00379                 case 0x73 /* 's' */ :
00380                 case 0x74 /* 't' */ :
00381                 case 0x75 /* 'u' */ :
00382                 case 0x76 /* 'v' */ :
00383                 case 0x77 /* 'w' */ :
00384                 case 0x78 /* 'x' */ :
00385                 case 0x79 /* 'y' */ :
00386                 case 0x7a /* 'z' */ :
00387                 {
00388                         mCHAR(false);
00389                         break;
00390                 }
00391                 case 0x30 /* '0' */ :
00392                 case 0x31 /* '1' */ :
00393                 case 0x32 /* '2' */ :
00394                 case 0x33 /* '3' */ :
00395                 case 0x34 /* '4' */ :
00396                 case 0x35 /* '5' */ :
00397                 case 0x36 /* '6' */ :
00398                 case 0x37 /* '7' */ :
00399                 case 0x38 /* '8' */ :
00400                 case 0x39 /* '9' */ :
00401                 {
00402                         mDIGIT(false);
00403                         break;
00404                 }
00405                 case 0x23 /* '#' */ :
00406                 case 0x24 /* '$' */ :
00407                 case 0x25 /* '%' */ :
00408                 case 0x26 /* '&' */ :
00409                 case 0x27 /* '\'' */ :
00410                 case 0x28 /* '(' */ :
00411                 case 0x29 /* ')' */ :
00412                 case 0x2a /* '*' */ :
00413                 case 0x2b /* '+' */ :
00414                 case 0x2c /* ',' */ :
00415                 case 0x2d /* '-' */ :
00416                 case 0x2e /* '.' */ :
00417                 case 0x2f /* '/' */ :
00418                 case 0x3a /* ':' */ :
00419                 case 0x3b /* ';' */ :
00420                 case 0x3c /* '<' */ :
00421                 case 0x3f /* '?' */ :
00422                 case 0x40 /* '@' */ :
00423                 case 0x5b /* '[' */ :
00424                 case 0x5d /* ']' */ :
00425                 case 0x5e /* '^' */ :
00426                 case 0x5f /* '_' */ :
00427                 case 0x7b /* '{' */ :
00428                 case 0x7c /* '|' */ :
00429                 case 0x7d /* '}' */ :
00430                 case 0x7e /* '~' */ :
00431                 {
00432                         mOTHER(false);
00433                         break;
00434                 }
00435                 default:
00436                 {
00437                         goto _loop129;
00438                 }
00439                 }
00440         }
00441         _loop129:;
00442         } // ( ... )*
00443         _ttype = testLiteralsTable(_ttype);
00444         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00445            _token = makeToken(_ttype);
00446            _token->setText(text.substr(_begin, text.length()-_begin));
00447         }
00448         _returnToken = _token;
00449         _saveIndex=0;
00450 }
00451 
00452 void SurfInvGaConfLexer::mCHAR(bool _createToken) {
00453         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00454         _ttype = CHAR;
00455         std::string::size_type _saveIndex;
00456         
00457         {
00458         matchRange('a','z');
00459         }
00460         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00461            _token = makeToken(_ttype);
00462            _token->setText(text.substr(_begin, text.length()-_begin));
00463         }
00464         _returnToken = _token;
00465         _saveIndex=0;
00466 }
00467 
00468 void SurfInvGaConfLexer::mDIGIT(bool _createToken) {
00469         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00470         _ttype = DIGIT;
00471         std::string::size_type _saveIndex;
00472         
00473         matchRange('0','9');
00474         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00475            _token = makeToken(_ttype);
00476            _token->setText(text.substr(_begin, text.length()-_begin));
00477         }
00478         _returnToken = _token;
00479         _saveIndex=0;
00480 }
00481 
00482 void SurfInvGaConfLexer::mOTHER(bool _createToken) {
00483         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00484         _ttype = OTHER;
00485         std::string::size_type _saveIndex;
00486         
00487         switch ( LA(1)) {
00488         case 0x27 /* '\'' */ :
00489         {
00490                 match('\'' /* charlit */ );
00491                 break;
00492         }
00493         case 0x23 /* '#' */ :
00494         {
00495                 match('#' /* charlit */ );
00496                 break;
00497         }
00498         case 0x24 /* '$' */ :
00499         {
00500                 match('$' /* charlit */ );
00501                 break;
00502         }
00503         case 0x25 /* '%' */ :
00504         {
00505                 match('%' /* charlit */ );
00506                 break;
00507         }
00508         case 0x26 /* '&' */ :
00509         {
00510                 match('&' /* charlit */ );
00511                 break;
00512         }
00513         case 0x28 /* '(' */ :
00514         {
00515                 match('(' /* charlit */ );
00516                 break;
00517         }
00518         case 0x29 /* ')' */ :
00519         {
00520                 match(')' /* charlit */ );
00521                 break;
00522         }
00523         case 0x2a /* '*' */ :
00524         {
00525                 match('*' /* charlit */ );
00526                 break;
00527         }
00528         case 0x2b /* '+' */ :
00529         {
00530                 match('+' /* charlit */ );
00531                 break;
00532         }
00533         case 0x2c /* ',' */ :
00534         {
00535                 match(',' /* charlit */ );
00536                 break;
00537         }
00538         case 0x2d /* '-' */ :
00539         {
00540                 match('-' /* charlit */ );
00541                 break;
00542         }
00543         case 0x2e /* '.' */ :
00544         {
00545                 match('.' /* charlit */ );
00546                 break;
00547         }
00548         case 0x2f /* '/' */ :
00549         {
00550                 match('/' /* charlit */ );
00551                 break;
00552         }
00553         case 0x3a /* ':' */ :
00554         {
00555                 match(':' /* charlit */ );
00556                 break;
00557         }
00558         case 0x3b /* ';' */ :
00559         {
00560                 match(';' /* charlit */ );
00561                 break;
00562         }
00563         case 0x3c /* '<' */ :
00564         {
00565                 match('<' /* charlit */ );
00566                 break;
00567         }
00568         case 0x3f /* '?' */ :
00569         {
00570                 match('?' /* charlit */ );
00571                 break;
00572         }
00573         case 0x40 /* '@' */ :
00574         {
00575                 match('@' /* charlit */ );
00576                 break;
00577         }
00578         case 0x5b /* '[' */ :
00579         {
00580                 match('[' /* charlit */ );
00581                 break;
00582         }
00583         case 0x5d /* ']' */ :
00584         {
00585                 match(']' /* charlit */ );
00586                 break;
00587         }
00588         case 0x5e /* '^' */ :
00589         {
00590                 match('^' /* charlit */ );
00591                 break;
00592         }
00593         case 0x5f /* '_' */ :
00594         {
00595                 match('_' /* charlit */ );
00596                 break;
00597         }
00598         case 0x7b /* '{' */ :
00599         {
00600                 match('{' /* charlit */ );
00601                 break;
00602         }
00603         case 0x7c /* '|' */ :
00604         {
00605                 match('|' /* charlit */ );
00606                 break;
00607         }
00608         case 0x7d /* '}' */ :
00609         {
00610                 match('}' /* charlit */ );
00611                 break;
00612         }
00613         case 0x7e /* '~' */ :
00614         {
00615                 match('~' /* charlit */ );
00616                 break;
00617         }
00618         default:
00619         {
00620                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00621         }
00622         }
00623         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00624            _token = makeToken(_ttype);
00625            _token->setText(text.substr(_begin, text.length()-_begin));
00626         }
00627         _returnToken = _token;
00628         _saveIndex=0;
00629 }
00630 
00631 void SurfInvGaConfLexer::mNUMBER(bool _createToken) {
00632         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00633         _ttype = NUMBER;
00634         std::string::size_type _saveIndex;
00635         
00636         {
00637         switch ( LA(1)) {
00638         case 0x2b /* '+' */ :
00639         {
00640                 match('+' /* charlit */ );
00641                 break;
00642         }
00643         case 0x2d /* '-' */ :
00644         {
00645                 match('-' /* charlit */ );
00646                 break;
00647         }
00648         case 0x2e /* '.' */ :
00649         case 0x30 /* '0' */ :
00650         case 0x31 /* '1' */ :
00651         case 0x32 /* '2' */ :
00652         case 0x33 /* '3' */ :
00653         case 0x34 /* '4' */ :
00654         case 0x35 /* '5' */ :
00655         case 0x36 /* '6' */ :
00656         case 0x37 /* '7' */ :
00657         case 0x38 /* '8' */ :
00658         case 0x39 /* '9' */ :
00659         {
00660                 break;
00661         }
00662         default:
00663         {
00664                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00665         }
00666         }
00667         }
00668         {
00669         bool synPredMatched134 = false;
00670         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00671                 int _m134 = mark();
00672                 synPredMatched134 = true;
00673                 inputState->guessing++;
00674                 try {
00675                         {
00676                         mREAL(false);
00677                         }
00678                 }
00679                 catch (antlr::RecognitionException& pe) {
00680                         synPredMatched134 = false;
00681                 }
00682                 rewind(_m134);
00683                 inputState->guessing--;
00684         }
00685         if ( synPredMatched134 ) {
00686                 mREAL(false);
00687         }
00688         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00689                 mINT(false);
00690         }
00691         else {
00692                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00693         }
00694         
00695         }
00696         {
00697         if ((LA(1) == 0x65 /* 'e' */ )) {
00698                 {
00699                 match('e' /* charlit */ );
00700                 }
00701                 {
00702                 switch ( LA(1)) {
00703                 case 0x2b /* '+' */ :
00704                 {
00705                         match('+' /* charlit */ );
00706                         break;
00707                 }
00708                 case 0x2d /* '-' */ :
00709                 {
00710                         match('-' /* charlit */ );
00711                         break;
00712                 }
00713                 case 0x30 /* '0' */ :
00714                 case 0x31 /* '1' */ :
00715                 case 0x32 /* '2' */ :
00716                 case 0x33 /* '3' */ :
00717                 case 0x34 /* '4' */ :
00718                 case 0x35 /* '5' */ :
00719                 case 0x36 /* '6' */ :
00720                 case 0x37 /* '7' */ :
00721                 case 0x38 /* '8' */ :
00722                 case 0x39 /* '9' */ :
00723                 {
00724                         break;
00725                 }
00726                 default:
00727                 {
00728                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00729                 }
00730                 }
00731                 }
00732                 mINT(false);
00733         }
00734         else {
00735         }
00736         
00737         }
00738         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00739            _token = makeToken(_ttype);
00740            _token->setText(text.substr(_begin, text.length()-_begin));
00741         }
00742         _returnToken = _token;
00743         _saveIndex=0;
00744 }
00745 
00746 void SurfInvGaConfLexer::mREAL(bool _createToken) {
00747         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00748         _ttype = REAL;
00749         std::string::size_type _saveIndex;
00750         
00751         {
00752         switch ( LA(1)) {
00753         case 0x2e /* '.' */ :
00754         {
00755                 match('.' /* charlit */ );
00756                 mINT(false);
00757                 break;
00758         }
00759         case 0x30 /* '0' */ :
00760         case 0x31 /* '1' */ :
00761         case 0x32 /* '2' */ :
00762         case 0x33 /* '3' */ :
00763         case 0x34 /* '4' */ :
00764         case 0x35 /* '5' */ :
00765         case 0x36 /* '6' */ :
00766         case 0x37 /* '7' */ :
00767         case 0x38 /* '8' */ :
00768         case 0x39 /* '9' */ :
00769         {
00770                 mINT(false);
00771                 match('.' /* charlit */ );
00772                 {
00773                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00774                         mINT(false);
00775                 }
00776                 else {
00777                 }
00778                 
00779                 }
00780                 break;
00781         }
00782         default:
00783         {
00784                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00785         }
00786         }
00787         }
00788         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00789            _token = makeToken(_ttype);
00790            _token->setText(text.substr(_begin, text.length()-_begin));
00791         }
00792         _returnToken = _token;
00793         _saveIndex=0;
00794 }
00795 
00796 void SurfInvGaConfLexer::mINT(bool _createToken) {
00797         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00798         _ttype = INT;
00799         std::string::size_type _saveIndex;
00800         
00801         { // ( ... )+
00802         int _cnt149=0;
00803         for (;;) {
00804                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00805                         mDIGIT(false);
00806                 }
00807                 else {
00808                         if ( _cnt149>=1 ) { goto _loop149; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00809                 }
00810                 
00811                 _cnt149++;
00812         }
00813         _loop149:;
00814         }  // ( ... )+
00815         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00816            _token = makeToken(_ttype);
00817            _token->setText(text.substr(_begin, text.length()-_begin));
00818         }
00819         _returnToken = _token;
00820         _saveIndex=0;
00821 }
00822 
00823 void SurfInvGaConfLexer::mCOMMENT(bool _createToken) {
00824         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00825         _ttype = COMMENT;
00826         std::string::size_type _saveIndex;
00827         
00828         match('/' /* charlit */ );
00829         match('/' /* charlit */ );
00830         { // ( ... )*
00831         for (;;) {
00832                 if ((_tokenSet_1.member(LA(1)))) {
00833                         {
00834                         match(_tokenSet_1);
00835                         }
00836                 }
00837                 else {
00838                         goto _loop141;
00839                 }
00840                 
00841         }
00842         _loop141:;
00843         } // ( ... )*
00844         mNEWLINE(false);
00845         if ( inputState->guessing==0 ) {
00846 #line 139 "SurfInvGaConf.g"
00847                 
00848                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00849                                 
00850 #line 851 "SurfInvGaConfLexer.cpp"
00851         }
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 SurfInvGaConfLexer::mVERBOSET(bool _createToken) {
00861         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00862         _ttype = VERBOSET;
00863         std::string::size_type _saveIndex;
00864         
00865         match("verbose");
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 SurfInvGaConfLexer::mUSEVREFMODELT(bool _createToken) {
00875         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00876         _ttype = USEVREFMODELT;
00877         std::string::size_type _saveIndex;
00878         
00879         match("usevrefmodel");
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 SurfInvGaConfLexer::mVREFMODELT(bool _createToken) {
00889         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00890         _ttype = VREFMODELT;
00891         std::string::size_type _saveIndex;
00892         
00893         match("vrefmodel");
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 SurfInvGaConfLexer::mFITEXPONENTT(bool _createToken) {
00903         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00904         _ttype = FITEXPONENTT;
00905         std::string::size_type _saveIndex;
00906         
00907         match("fitexponent");
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 SurfInvGaConfLexer::mPOPSIZET(bool _createToken) {
00917         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00918         _ttype = POPSIZET;
00919         std::string::size_type _saveIndex;
00920         
00921         match("popsize");
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 SurfInvGaConfLexer::mINITTEMPT(bool _createToken) {
00931         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00932         _ttype = INITTEMPT;
00933         std::string::size_type _saveIndex;
00934         
00935         match("inittemp");
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 SurfInvGaConfLexer::mCOOLINGRATIOT(bool _createToken) {
00945         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00946         _ttype = COOLINGRATIOT;
00947         std::string::size_type _saveIndex;
00948         
00949         match("coolingratio");
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 void SurfInvGaConfLexer::mGENERATIONST(bool _createToken) {
00959         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00960         _ttype = GENERATIONST;
00961         std::string::size_type _saveIndex;
00962         
00963         match("generations");
00964         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00965            _token = makeToken(_ttype);
00966            _token->setText(text.substr(_begin, text.length()-_begin));
00967         }
00968         _returnToken = _token;
00969         _saveIndex=0;
00970 }
00971 
00972 void SurfInvGaConfLexer::mMUTATIONPROBT(bool _createToken) {
00973         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00974         _ttype = MUTATIONPROBT;
00975         std::string::size_type _saveIndex;
00976         
00977         match("mutationprob");
00978         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00979            _token = makeToken(_ttype);
00980            _token->setText(text.substr(_begin, text.length()-_begin));
00981         }
00982         _returnToken = _token;
00983         _saveIndex=0;
00984 }
00985 
00986 void SurfInvGaConfLexer::mCROSSOVERPROBT(bool _createToken) {
00987         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00988         _ttype = CROSSOVERPROBT;
00989         std::string::size_type _saveIndex;
00990         
00991         match("crossoverprob");
00992         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00993            _token = makeToken(_ttype);
00994            _token->setText(text.substr(_begin, text.length()-_begin));
00995         }
00996         _returnToken = _token;
00997         _saveIndex=0;
00998 }
00999 
01000 void SurfInvGaConfLexer::mPOISSONT(bool _createToken) {
01001         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01002         _ttype = POISSONT;
01003         std::string::size_type _saveIndex;
01004         
01005         match("poisson");
01006         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01007            _token = makeToken(_ttype);
01008            _token->setText(text.substr(_begin, text.length()-_begin));
01009         }
01010         _returnToken = _token;
01011         _saveIndex=0;
01012 }
01013 
01014 void SurfInvGaConfLexer::mTHREADST(bool _createToken) {
01015         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01016         _ttype = THREADST;
01017         std::string::size_type _saveIndex;
01018         
01019         match("threads");
01020         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01021            _token = makeToken(_ttype);
01022            _token->setText(text.substr(_begin, text.length()-_begin));
01023         }
01024         _returnToken = _token;
01025         _saveIndex=0;
01026 }
01027 
01028 void SurfInvGaConfLexer::mERRORLEVELT(bool _createToken) {
01029         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01030         _ttype = ERRORLEVELT;
01031         std::string::size_type _saveIndex;
01032         
01033         match("errorlevel");
01034         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01035            _token = makeToken(_ttype);
01036            _token->setText(text.substr(_begin, text.length()-_begin));
01037         }
01038         _returnToken = _token;
01039         _saveIndex=0;
01040 }
01041 
01042 void SurfInvGaConfLexer::mGATYPET(bool _createToken) {
01043         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01044         _ttype = GATYPET;
01045         std::string::size_type _saveIndex;
01046         
01047         match("gatype");
01048         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01049            _token = makeToken(_ttype);
01050            _token->setText(text.substr(_begin, text.length()-_begin));
01051         }
01052         _returnToken = _token;
01053         _saveIndex=0;
01054 }
01055 
01056 void SurfInvGaConfLexer::mOUTPUTBASET(bool _createToken) {
01057         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01058         _ttype = OUTPUTBASET;
01059         std::string::size_type _saveIndex;
01060         
01061         match("outputbase");
01062         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01063            _token = makeToken(_ttype);
01064            _token->setText(text.substr(_begin, text.length()-_begin));
01065         }
01066         _returnToken = _token;
01067         _saveIndex=0;
01068 }
01069 
01070 void SurfInvGaConfLexer::mINPUTDATAT(bool _createToken) {
01071         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01072         _ttype = INPUTDATAT;
01073         std::string::size_type _saveIndex;
01074         
01075         match("inputdata");
01076         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01077            _token = makeToken(_ttype);
01078            _token->setText(text.substr(_begin, text.length()-_begin));
01079         }
01080         _returnToken = _token;
01081         _saveIndex=0;
01082 }
01083 
01084 void SurfInvGaConfLexer::mANNEALINGGENERATIONT(bool _createToken) {
01085         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01086         _ttype = ANNEALINGGENERATIONT;
01087         std::string::size_type _saveIndex;
01088         
01089         match("annealinggeneration");
01090         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01091            _token = makeToken(_ttype);
01092            _token->setText(text.substr(_begin, text.length()-_begin));
01093         }
01094         _returnToken = _token;
01095         _saveIndex=0;
01096 }
01097 
01098 void SurfInvGaConfLexer::mELITISTT(bool _createToken) {
01099         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01100         _ttype = ELITISTT;
01101         std::string::size_type _saveIndex;
01102         
01103         match("elitist");
01104         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01105            _token = makeToken(_ttype);
01106            _token->setText(text.substr(_begin, text.length()-_begin));
01107         }
01108         _returnToken = _token;
01109         _saveIndex=0;
01110 }
01111 
01112 void SurfInvGaConfLexer::mTHICKBASET(bool _createToken) {
01113         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01114         _ttype = THICKBASET;
01115         std::string::size_type _saveIndex;
01116         
01117         match("thickbase");
01118         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01119            _token = makeToken(_ttype);
01120            _token->setText(text.substr(_begin, text.length()-_begin));
01121         }
01122         _returnToken = _token;
01123         _saveIndex=0;
01124 }
01125 
01126 void SurfInvGaConfLexer::mTHICKSTEPT(bool _createToken) {
01127         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01128         _ttype = THICKSTEPT;
01129         std::string::size_type _saveIndex;
01130         
01131         match("thickstep");
01132         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01133            _token = makeToken(_ttype);
01134            _token->setText(text.substr(_begin, text.length()-_begin));
01135         }
01136         _returnToken = _token;
01137         _saveIndex=0;
01138 }
01139 
01140 void SurfInvGaConfLexer::mTHICKSIZEST(bool _createToken) {
01141         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01142         _ttype = THICKSIZEST;
01143         std::string::size_type _saveIndex;
01144         
01145         match("thicksizes");
01146         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01147            _token = makeToken(_ttype);
01148            _token->setText(text.substr(_begin, text.length()-_begin));
01149         }
01150         _returnToken = _token;
01151         _saveIndex=0;
01152 }
01153 
01154 void SurfInvGaConfLexer::mSVELBASET(bool _createToken) {
01155         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01156         _ttype = SVELBASET;
01157         std::string::size_type _saveIndex;
01158         
01159         match("svelbase");
01160         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01161            _token = makeToken(_ttype);
01162            _token->setText(text.substr(_begin, text.length()-_begin));
01163         }
01164         _returnToken = _token;
01165         _saveIndex=0;
01166 }
01167 
01168 void SurfInvGaConfLexer::mSVELSTEPT(bool _createToken) {
01169         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01170         _ttype = SVELSTEPT;
01171         std::string::size_type _saveIndex;
01172         
01173         match("svelstep");
01174         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01175            _token = makeToken(_ttype);
01176            _token->setText(text.substr(_begin, text.length()-_begin));
01177         }
01178         _returnToken = _token;
01179         _saveIndex=0;
01180 }
01181 
01182 void SurfInvGaConfLexer::mSVELSIZEST(bool _createToken) {
01183         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01184         _ttype = SVELSIZEST;
01185         std::string::size_type _saveIndex;
01186         
01187         match("svelsizes");
01188         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01189            _token = makeToken(_ttype);
01190            _token->setText(text.substr(_begin, text.length()-_begin));
01191         }
01192         _returnToken = _token;
01193         _saveIndex=0;
01194 }
01195 
01196 void SurfInvGaConfLexer::mWEIGHTST(bool _createToken) {
01197         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01198         _ttype = WEIGHTST;
01199         std::string::size_type _saveIndex;
01200         
01201         match("weights");
01202         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01203            _token = makeToken(_ttype);
01204            _token->setText(text.substr(_begin, text.length()-_begin));
01205         }
01206         _returnToken = _token;
01207         _saveIndex=0;
01208 }
01209 
01210 
01211 const unsigned long SurfInvGaConfLexer::_tokenSet_0_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL };
01212 const antlr::BitSet SurfInvGaConfLexer::_tokenSet_0(_tokenSet_0_data_,6);
01213 const unsigned long SurfInvGaConfLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
01214 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
01215 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
01216 // \" # $ % & \' ( ) 
01217 const antlr::BitSet SurfInvGaConfLexer::_tokenSet_1(_tokenSet_1_data_,8);
01218
Generated on Thu Nov 22 13:58:27 2007 for GPLIB++ by  doxygen 1.5.1