GPLIB++: C1dInvGaConfLexer.cpp Source File

00001 /* $ANTLR 2.7.6 (20070220): "C1dInvGaConf.g" -> "C1dInvGaConfLexer.cpp"$ */
00002 #include "C1dInvGaConfLexer.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 "C1dInvGaConf.g"
00012 #line 13 "C1dInvGaConfLexer.cpp"
00013 C1dInvGaConfLexer::C1dInvGaConfLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 C1dInvGaConfLexer::C1dInvGaConfLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 C1dInvGaConfLexer::C1dInvGaConfLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void C1dInvGaConfLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken C1dInvGaConfLexer::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) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x66 /* 'f' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x78 /* 'x' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00089                                         mMTFITEXPONENTT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x78 /* 'x' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
00093                                         mRECFITEXPONENTT(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 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' */ )) {
00097                                         mCOOLINGRATIOT(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 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' */ )) {
00101                                         mGENERATIONST(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 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' */ )) {
00105                                         mMUTATIONPROBT(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 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' */ )) {
00109                                         mCROSSOVERPROBT(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x72 /* 'r' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
00113                                         mTENSORERRORT(true);
00114                                         theRetToken=_returnToken;
00115                                 }
00116                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x72 /* 'r' */ )) {
00117                                         mPHASEERRORT(true);
00118                                         theRetToken=_returnToken;
00119                                 }
00120                                 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' */ )) {
00121                                         mOUTPUTBASET(true);
00122                                         theRetToken=_returnToken;
00123                                 }
00124                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x6e /* 'n' */ ) && (LA(5) == 0x70 /* 'p' */ ) && (LA(6) == 0x75 /* 'u' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x64 /* 'd' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00125                                         mMTINPUTDATAT(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x6e /* 'n' */ ) && (LA(6) == 0x70 /* 'p' */ ) && (LA(7) == 0x75 /* 'u' */ ) && (LA(8) == 0x74 /* 't' */ ) && (LA(9) == 0x64 /* 'd' */ ) && (LA(10) == 0x61 /* 'a' */ )) {
00129                                         mRECINPUTDATAT(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x66 /* 'f' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x76 /* 'v' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x6c /* 'l' */ ) && (LA(9) == 0x64 /* 'd' */ ) && (LA(10) == 0x61 /* 'a' */ )) {
00133                                         mRFABSVELDATAT(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 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' */ )) {
00137                                         mANNEALINGGENERATIONT(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 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' */ )) {
00141                                         mTHICKSIZEST(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x62 /* 'b' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x76 /* 'v' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x77 /* 'w' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x69 /* 'i' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
00145                                         mABSVELWEIGHTT(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 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)) {
00149                                         mVREFMODELT(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6d /* 'm' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00153                                         mSTARTTIMET(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x6d /* 'm' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x68 /* 'h' */ ) && (LA(8) == 0x6f /* 'o' */ ) && (LA(9) == 0x64 /* 'd' */ ) && (true)) {
00157                                         mRECMETHODT(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 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)) {
00161                                         mTHICKBASET(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 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)) {
00165                                         mTHICKSTEPT(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 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)) {
00169                                         mSVELSIZEST(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x77 /* 'w' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x67 /* 'g' */ ) && (LA(8) == 0x68 /* 'h' */ ) && (LA(9) == 0x74 /* 't' */ ) && (true)) {
00173                                         mRECWEIGHTT(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 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)) {
00177                                         mINITTEMPT(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 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)) {
00181                                         mSLOWNESST(true);
00182                                         theRetToken=_returnToken;
00183                                 }
00184                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (true) && (true)) {
00185                                         mRESERRORT(true);
00186                                         theRetToken=_returnToken;
00187                                 }
00188                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (true) && (true)) {
00189                                         mRECERRORT(true);
00190                                         theRetToken=_returnToken;
00191                                 }
00192                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x7a /* 'z' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x73 /* 's' */ ) && (true) && (true)) {
00193                                         mRESSIZEST(true);
00194                                         theRetToken=_returnToken;
00195                                 }
00196                                 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)) {
00197                                         mSVELBASET(true);
00198                                         theRetToken=_returnToken;
00199                                 }
00200                                 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)) {
00201                                         mSVELSTEPT(true);
00202                                         theRetToken=_returnToken;
00203                                 }
00204                                 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)) {
00205                                         mVERBOSET(true);
00206                                         theRetToken=_returnToken;
00207                                 }
00208                                 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)) {
00209                                         mPOPSIZET(true);
00210                                         theRetToken=_returnToken;
00211                                 }
00212                                 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)) {
00213                                         mPOISSONT(true);
00214                                         theRetToken=_returnToken;
00215                                 }
00216                                 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)) {
00217                                         mTHREADST(true);
00218                                         theRetToken=_returnToken;
00219                                 }
00220                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x6d /* 'm' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00221                                         mENDTIMET(true);
00222                                         theRetToken=_returnToken;
00223                                 }
00224                                 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)) {
00225                                         mELITISTT(true);
00226                                         theRetToken=_returnToken;
00227                                 }
00228                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00229                                         mRESBASET(true);
00230                                         theRetToken=_returnToken;
00231                                 }
00232                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x70 /* 'p' */ ) && (true) && (true) && (true)) {
00233                                         mRESSTEPT(true);
00234                                         theRetToken=_returnToken;
00235                                 }
00236                                 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)) {
00237                                         mWEIGHTST(true);
00238                                         theRetToken=_returnToken;
00239                                 }
00240                                 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)) {
00241                                         mGATYPET(true);
00242                                         theRetToken=_returnToken;
00243                                 }
00244                                 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)) {
00245                                         mFALSE(true);
00246                                         theRetToken=_returnToken;
00247                                 }
00248                                 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)) {
00249                                         mOMEGAT(true);
00250                                         theRetToken=_returnToken;
00251                                 }
00252                                 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)) {
00253                                         mSIGMAT(true);
00254                                         theRetToken=_returnToken;
00255                                 }
00256                                 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)) {
00257                                         mSHIFTT(true);
00258                                         theRetToken=_returnToken;
00259                                 }
00260                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x66 /* 'f' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true)) {
00261                                         mMTFITT(true);
00262                                         theRetToken=_returnToken;
00263                                 }
00264                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00265                                         mTRUE(true);
00266                                         theRetToken=_returnToken;
00267                                 }
00268                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00269                                         mMODET(true);
00270                                         theRetToken=_returnToken;
00271                                 }
00272                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x63 /* 'c' */ ) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00273                                         mCCT(true);
00274                                         theRetToken=_returnToken;
00275                                 }
00276                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00277                                         mSTRING(true);
00278                                         theRetToken=_returnToken;
00279                                 }
00280                         else {
00281                                 if (LA(1)==EOF_CHAR)
00282                                 {
00283                                         uponEOF();
00284                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00285                                 }
00286                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00287                         }
00288                         }
00289                         if ( !_returnToken )
00290                                 goto tryAgain; // found SKIP token
00291 
00292                         _ttype = _returnToken->getType();
00293                         _ttype = testLiteralsTable(_ttype);
00294                         _returnToken->setType(_ttype);
00295                         return _returnToken;
00296                 }
00297                 catch (antlr::RecognitionException& e) {
00298                                 throw antlr::TokenStreamRecognitionException(e);
00299                 }
00300                 catch (antlr::CharStreamIOException& csie) {
00301                         throw antlr::TokenStreamIOException(csie.io);
00302                 }
00303                 catch (antlr::CharStreamException& cse) {
00304                         throw antlr::TokenStreamException(cse.getMessage());
00305                 }
00306 tryAgain:;
00307         }
00308 }
00309 
00310 void C1dInvGaConfLexer::mEQUAL(bool _createToken) {
00311         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00312         _ttype = EQUAL;
00313         std::string::size_type _saveIndex;
00314         
00315         match('=' /* charlit */ );
00316         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00317            _token = makeToken(_ttype);
00318            _token->setText(text.substr(_begin, text.length()-_begin));
00319         }
00320         _returnToken = _token;
00321         _saveIndex=0;
00322 }
00323 
00324 void C1dInvGaConfLexer::mTRUE(bool _createToken) {
00325         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00326         _ttype = TRUE;
00327         std::string::size_type _saveIndex;
00328         
00329         match("true");
00330         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00331            _token = makeToken(_ttype);
00332            _token->setText(text.substr(_begin, text.length()-_begin));
00333         }
00334         _returnToken = _token;
00335         _saveIndex=0;
00336 }
00337 
00338 void C1dInvGaConfLexer::mFALSE(bool _createToken) {
00339         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00340         _ttype = FALSE;
00341         std::string::size_type _saveIndex;
00342         
00343         match("false");
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 C1dInvGaConfLexer::mWS(bool _createToken) {
00353         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00354         _ttype = WS;
00355         std::string::size_type _saveIndex;
00356         
00357         { // ( ... )+
00358         int _cnt216=0;
00359         for (;;) {
00360                 switch ( LA(1)) {
00361                 case 0x20 /* ' ' */ :
00362                 {
00363                         match(' ' /* charlit */ );
00364                         break;
00365                 }
00366                 case 0xa /* '\n' */ :
00367                 case 0xd /* '\r' */ :
00368                 {
00369                         mNEWLINE(false);
00370                         break;
00371                 }
00372                 case 0x9 /* '\t' */ :
00373                 {
00374                         match('\t' /* charlit */ );
00375                         break;
00376                 }
00377                 default:
00378                 {
00379                         if ( _cnt216>=1 ) { goto _loop216; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00380                 }
00381                 }
00382                 _cnt216++;
00383         }
00384         _loop216:;
00385         }  // ( ... )+
00386         if ( inputState->guessing==0 ) {
00387 #line 168 "C1dInvGaConf.g"
00388                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00389 #line 390 "C1dInvGaConfLexer.cpp"
00390         }
00391         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00392            _token = makeToken(_ttype);
00393            _token->setText(text.substr(_begin, text.length()-_begin));
00394         }
00395         _returnToken = _token;
00396         _saveIndex=0;
00397 }
00398 
00399 void C1dInvGaConfLexer::mNEWLINE(bool _createToken) {
00400         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00401         _ttype = NEWLINE;
00402         std::string::size_type _saveIndex;
00403         
00404         {
00405         switch ( LA(1)) {
00406         case 0xa /* '\n' */ :
00407         {
00408                 match('\n' /* charlit */ );
00409                 break;
00410         }
00411         case 0xd /* '\r' */ :
00412         {
00413                 match('\r' /* charlit */ );
00414                 match('\n' /* charlit */ );
00415                 break;
00416         }
00417         default:
00418         {
00419                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00420         }
00421         }
00422         }
00423         if ( inputState->guessing==0 ) {
00424 #line 194 "C1dInvGaConf.g"
00425                 newline();
00426 #line 427 "C1dInvGaConfLexer.cpp"
00427         }
00428         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00429            _token = makeToken(_ttype);
00430            _token->setText(text.substr(_begin, text.length()-_begin));
00431         }
00432         _returnToken = _token;
00433         _saveIndex=0;
00434 }
00435 
00436 void C1dInvGaConfLexer::mSTRING(bool _createToken) {
00437         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00438         _ttype = STRING;
00439         std::string::size_type _saveIndex;
00440         
00441         mCHAR(false);
00442         { // ( ... )*
00443         for (;;) {
00444                 switch ( LA(1)) {
00445                 case 0x61 /* 'a' */ :
00446                 case 0x62 /* 'b' */ :
00447                 case 0x63 /* 'c' */ :
00448                 case 0x64 /* 'd' */ :
00449                 case 0x65 /* 'e' */ :
00450                 case 0x66 /* 'f' */ :
00451                 case 0x67 /* 'g' */ :
00452                 case 0x68 /* 'h' */ :
00453                 case 0x69 /* 'i' */ :
00454                 case 0x6a /* 'j' */ :
00455                 case 0x6b /* 'k' */ :
00456                 case 0x6c /* 'l' */ :
00457                 case 0x6d /* 'm' */ :
00458                 case 0x6e /* 'n' */ :
00459                 case 0x6f /* 'o' */ :
00460                 case 0x70 /* 'p' */ :
00461                 case 0x71 /* 'q' */ :
00462                 case 0x72 /* 'r' */ :
00463                 case 0x73 /* 's' */ :
00464                 case 0x74 /* 't' */ :
00465                 case 0x75 /* 'u' */ :
00466                 case 0x76 /* 'v' */ :
00467                 case 0x77 /* 'w' */ :
00468                 case 0x78 /* 'x' */ :
00469                 case 0x79 /* 'y' */ :
00470                 case 0x7a /* 'z' */ :
00471                 {
00472                         mCHAR(false);
00473                         break;
00474                 }
00475                 case 0x30 /* '0' */ :
00476                 case 0x31 /* '1' */ :
00477                 case 0x32 /* '2' */ :
00478                 case 0x33 /* '3' */ :
00479                 case 0x34 /* '4' */ :
00480                 case 0x35 /* '5' */ :
00481                 case 0x36 /* '6' */ :
00482                 case 0x37 /* '7' */ :
00483                 case 0x38 /* '8' */ :
00484                 case 0x39 /* '9' */ :
00485                 {
00486                         mDIGIT(false);
00487                         break;
00488                 }
00489                 case 0x23 /* '#' */ :
00490                 case 0x24 /* '$' */ :
00491                 case 0x25 /* '%' */ :
00492                 case 0x26 /* '&' */ :
00493                 case 0x27 /* '\'' */ :
00494                 case 0x28 /* '(' */ :
00495                 case 0x29 /* ')' */ :
00496                 case 0x2a /* '*' */ :
00497                 case 0x2b /* '+' */ :
00498                 case 0x2c /* ',' */ :
00499                 case 0x2d /* '-' */ :
00500                 case 0x2e /* '.' */ :
00501                 case 0x2f /* '/' */ :
00502                 case 0x3a /* ':' */ :
00503                 case 0x3b /* ';' */ :
00504                 case 0x3c /* '<' */ :
00505                 case 0x3f /* '?' */ :
00506                 case 0x40 /* '@' */ :
00507                 case 0x5b /* '[' */ :
00508                 case 0x5d /* ']' */ :
00509                 case 0x5e /* '^' */ :
00510                 case 0x5f /* '_' */ :
00511                 case 0x7b /* '{' */ :
00512                 case 0x7c /* '|' */ :
00513                 case 0x7d /* '}' */ :
00514                 case 0x7e /* '~' */ :
00515                 {
00516                         mOTHER(false);
00517                         break;
00518                 }
00519                 default:
00520                 {
00521                         goto _loop219;
00522                 }
00523                 }
00524         }
00525         _loop219:;
00526         } // ( ... )*
00527         _ttype = testLiteralsTable(_ttype);
00528         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00529            _token = makeToken(_ttype);
00530            _token->setText(text.substr(_begin, text.length()-_begin));
00531         }
00532         _returnToken = _token;
00533         _saveIndex=0;
00534 }
00535 
00536 void C1dInvGaConfLexer::mCHAR(bool _createToken) {
00537         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00538         _ttype = CHAR;
00539         std::string::size_type _saveIndex;
00540         
00541         {
00542         matchRange('a','z');
00543         }
00544         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00545            _token = makeToken(_ttype);
00546            _token->setText(text.substr(_begin, text.length()-_begin));
00547         }
00548         _returnToken = _token;
00549         _saveIndex=0;
00550 }
00551 
00552 void C1dInvGaConfLexer::mDIGIT(bool _createToken) {
00553         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00554         _ttype = DIGIT;
00555         std::string::size_type _saveIndex;
00556         
00557         matchRange('0','9');
00558         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00559            _token = makeToken(_ttype);
00560            _token->setText(text.substr(_begin, text.length()-_begin));
00561         }
00562         _returnToken = _token;
00563         _saveIndex=0;
00564 }
00565 
00566 void C1dInvGaConfLexer::mOTHER(bool _createToken) {
00567         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00568         _ttype = OTHER;
00569         std::string::size_type _saveIndex;
00570         
00571         switch ( LA(1)) {
00572         case 0x27 /* '\'' */ :
00573         {
00574                 match('\'' /* charlit */ );
00575                 break;
00576         }
00577         case 0x23 /* '#' */ :
00578         {
00579                 match('#' /* charlit */ );
00580                 break;
00581         }
00582         case 0x24 /* '$' */ :
00583         {
00584                 match('$' /* charlit */ );
00585                 break;
00586         }
00587         case 0x25 /* '%' */ :
00588         {
00589                 match('%' /* charlit */ );
00590                 break;
00591         }
00592         case 0x26 /* '&' */ :
00593         {
00594                 match('&' /* charlit */ );
00595                 break;
00596         }
00597         case 0x28 /* '(' */ :
00598         {
00599                 match('(' /* charlit */ );
00600                 break;
00601         }
00602         case 0x29 /* ')' */ :
00603         {
00604                 match(')' /* charlit */ );
00605                 break;
00606         }
00607         case 0x2a /* '*' */ :
00608         {
00609                 match('*' /* charlit */ );
00610                 break;
00611         }
00612         case 0x2b /* '+' */ :
00613         {
00614                 match('+' /* charlit */ );
00615                 break;
00616         }
00617         case 0x2c /* ',' */ :
00618         {
00619                 match(',' /* charlit */ );
00620                 break;
00621         }
00622         case 0x2d /* '-' */ :
00623         {
00624                 match('-' /* charlit */ );
00625                 break;
00626         }
00627         case 0x2e /* '.' */ :
00628         {
00629                 match('.' /* charlit */ );
00630                 break;
00631         }
00632         case 0x2f /* '/' */ :
00633         {
00634                 match('/' /* charlit */ );
00635                 break;
00636         }
00637         case 0x3a /* ':' */ :
00638         {
00639                 match(':' /* charlit */ );
00640                 break;
00641         }
00642         case 0x3b /* ';' */ :
00643         {
00644                 match(';' /* charlit */ );
00645                 break;
00646         }
00647         case 0x3c /* '<' */ :
00648         {
00649                 match('<' /* charlit */ );
00650                 break;
00651         }
00652         case 0x3f /* '?' */ :
00653         {
00654                 match('?' /* charlit */ );
00655                 break;
00656         }
00657         case 0x40 /* '@' */ :
00658         {
00659                 match('@' /* charlit */ );
00660                 break;
00661         }
00662         case 0x5b /* '[' */ :
00663         {
00664                 match('[' /* charlit */ );
00665                 break;
00666         }
00667         case 0x5d /* ']' */ :
00668         {
00669                 match(']' /* charlit */ );
00670                 break;
00671         }
00672         case 0x5e /* '^' */ :
00673         {
00674                 match('^' /* charlit */ );
00675                 break;
00676         }
00677         case 0x5f /* '_' */ :
00678         {
00679                 match('_' /* charlit */ );
00680                 break;
00681         }
00682         case 0x7b /* '{' */ :
00683         {
00684                 match('{' /* charlit */ );
00685                 break;
00686         }
00687         case 0x7c /* '|' */ :
00688         {
00689                 match('|' /* charlit */ );
00690                 break;
00691         }
00692         case 0x7d /* '}' */ :
00693         {
00694                 match('}' /* charlit */ );
00695                 break;
00696         }
00697         case 0x7e /* '~' */ :
00698         {
00699                 match('~' /* charlit */ );
00700                 break;
00701         }
00702         default:
00703         {
00704                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00705         }
00706         }
00707         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00708            _token = makeToken(_ttype);
00709            _token->setText(text.substr(_begin, text.length()-_begin));
00710         }
00711         _returnToken = _token;
00712         _saveIndex=0;
00713 }
00714 
00715 void C1dInvGaConfLexer::mNUMBER(bool _createToken) {
00716         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00717         _ttype = NUMBER;
00718         std::string::size_type _saveIndex;
00719         
00720         {
00721         switch ( LA(1)) {
00722         case 0x2b /* '+' */ :
00723         {
00724                 match('+' /* charlit */ );
00725                 break;
00726         }
00727         case 0x2d /* '-' */ :
00728         {
00729                 match('-' /* charlit */ );
00730                 break;
00731         }
00732         case 0x2e /* '.' */ :
00733         case 0x30 /* '0' */ :
00734         case 0x31 /* '1' */ :
00735         case 0x32 /* '2' */ :
00736         case 0x33 /* '3' */ :
00737         case 0x34 /* '4' */ :
00738         case 0x35 /* '5' */ :
00739         case 0x36 /* '6' */ :
00740         case 0x37 /* '7' */ :
00741         case 0x38 /* '8' */ :
00742         case 0x39 /* '9' */ :
00743         {
00744                 break;
00745         }
00746         default:
00747         {
00748                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00749         }
00750         }
00751         }
00752         {
00753         bool synPredMatched224 = false;
00754         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00755                 int _m224 = mark();
00756                 synPredMatched224 = true;
00757                 inputState->guessing++;
00758                 try {
00759                         {
00760                         mREAL(false);
00761                         }
00762                 }
00763                 catch (antlr::RecognitionException& pe) {
00764                         synPredMatched224 = false;
00765                 }
00766                 rewind(_m224);
00767                 inputState->guessing--;
00768         }
00769         if ( synPredMatched224 ) {
00770                 mREAL(false);
00771         }
00772         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00773                 mINT(false);
00774         }
00775         else {
00776                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00777         }
00778         
00779         }
00780         {
00781         if ((LA(1) == 0x65 /* 'e' */ )) {
00782                 {
00783                 match('e' /* charlit */ );
00784                 }
00785                 {
00786                 switch ( LA(1)) {
00787                 case 0x2b /* '+' */ :
00788                 {
00789                         match('+' /* charlit */ );
00790                         break;
00791                 }
00792                 case 0x2d /* '-' */ :
00793                 {
00794                         match('-' /* charlit */ );
00795                         break;
00796                 }
00797                 case 0x30 /* '0' */ :
00798                 case 0x31 /* '1' */ :
00799                 case 0x32 /* '2' */ :
00800                 case 0x33 /* '3' */ :
00801                 case 0x34 /* '4' */ :
00802                 case 0x35 /* '5' */ :
00803                 case 0x36 /* '6' */ :
00804                 case 0x37 /* '7' */ :
00805                 case 0x38 /* '8' */ :
00806                 case 0x39 /* '9' */ :
00807                 {
00808                         break;
00809                 }
00810                 default:
00811                 {
00812                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00813                 }
00814                 }
00815                 }
00816                 mINT(false);
00817         }
00818         else {
00819         }
00820         
00821         }
00822         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00823            _token = makeToken(_ttype);
00824            _token->setText(text.substr(_begin, text.length()-_begin));
00825         }
00826         _returnToken = _token;
00827         _saveIndex=0;
00828 }
00829 
00830 void C1dInvGaConfLexer::mREAL(bool _createToken) {
00831         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00832         _ttype = REAL;
00833         std::string::size_type _saveIndex;
00834         
00835         {
00836         switch ( LA(1)) {
00837         case 0x2e /* '.' */ :
00838         {
00839                 match('.' /* charlit */ );
00840                 mINT(false);
00841                 break;
00842         }
00843         case 0x30 /* '0' */ :
00844         case 0x31 /* '1' */ :
00845         case 0x32 /* '2' */ :
00846         case 0x33 /* '3' */ :
00847         case 0x34 /* '4' */ :
00848         case 0x35 /* '5' */ :
00849         case 0x36 /* '6' */ :
00850         case 0x37 /* '7' */ :
00851         case 0x38 /* '8' */ :
00852         case 0x39 /* '9' */ :
00853         {
00854                 mINT(false);
00855                 match('.' /* charlit */ );
00856                 {
00857                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00858                         mINT(false);
00859                 }
00860                 else {
00861                 }
00862                 
00863                 }
00864                 break;
00865         }
00866         default:
00867         {
00868                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00869         }
00870         }
00871         }
00872         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00873            _token = makeToken(_ttype);
00874            _token->setText(text.substr(_begin, text.length()-_begin));
00875         }
00876         _returnToken = _token;
00877         _saveIndex=0;
00878 }
00879 
00880 void C1dInvGaConfLexer::mINT(bool _createToken) {
00881         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00882         _ttype = INT;
00883         std::string::size_type _saveIndex;
00884         
00885         { // ( ... )+
00886         int _cnt239=0;
00887         for (;;) {
00888                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00889                         mDIGIT(false);
00890                 }
00891                 else {
00892                         if ( _cnt239>=1 ) { goto _loop239; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00893                 }
00894                 
00895                 _cnt239++;
00896         }
00897         _loop239:;
00898         }  // ( ... )+
00899         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00900            _token = makeToken(_ttype);
00901            _token->setText(text.substr(_begin, text.length()-_begin));
00902         }
00903         _returnToken = _token;
00904         _saveIndex=0;
00905 }
00906 
00907 void C1dInvGaConfLexer::mCOMMENT(bool _createToken) {
00908         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00909         _ttype = COMMENT;
00910         std::string::size_type _saveIndex;
00911         
00912         match('/' /* charlit */ );
00913         match('/' /* charlit */ );
00914         { // ( ... )*
00915         for (;;) {
00916                 if ((_tokenSet_1.member(LA(1)))) {
00917                         {
00918                         match(_tokenSet_1);
00919                         }
00920                 }
00921                 else {
00922                         goto _loop231;
00923                 }
00924                 
00925         }
00926         _loop231:;
00927         } // ( ... )*
00928         mNEWLINE(false);
00929         if ( inputState->guessing==0 ) {
00930 #line 185 "C1dInvGaConf.g"
00931                 
00932                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00933                                 
00934 #line 935 "C1dInvGaConfLexer.cpp"
00935         }
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 C1dInvGaConfLexer::mVERBOSET(bool _createToken) {
00945         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00946         _ttype = VERBOSET;
00947         std::string::size_type _saveIndex;
00948         
00949         match("verbose");
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 C1dInvGaConfLexer::mUSEVREFMODELT(bool _createToken) {
00959         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00960         _ttype = USEVREFMODELT;
00961         std::string::size_type _saveIndex;
00962         
00963         match("usevrefmodel");
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 C1dInvGaConfLexer::mVREFMODELT(bool _createToken) {
00973         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00974         _ttype = VREFMODELT;
00975         std::string::size_type _saveIndex;
00976         
00977         match("vrefmodel");
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 C1dInvGaConfLexer::mMTFITEXPONENTT(bool _createToken) {
00987         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00988         _ttype = MTFITEXPONENTT;
00989         std::string::size_type _saveIndex;
00990         
00991         match("mtfitexponent");
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 C1dInvGaConfLexer::mRECFITEXPONENTT(bool _createToken) {
01001         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01002         _ttype = RECFITEXPONENTT;
01003         std::string::size_type _saveIndex;
01004         
01005         match("recfitexponent");
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 C1dInvGaConfLexer::mPOPSIZET(bool _createToken) {
01015         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01016         _ttype = POPSIZET;
01017         std::string::size_type _saveIndex;
01018         
01019         match("popsize");
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 C1dInvGaConfLexer::mINITTEMPT(bool _createToken) {
01029         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01030         _ttype = INITTEMPT;
01031         std::string::size_type _saveIndex;
01032         
01033         match("inittemp");
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 C1dInvGaConfLexer::mCOOLINGRATIOT(bool _createToken) {
01043         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01044         _ttype = COOLINGRATIOT;
01045         std::string::size_type _saveIndex;
01046         
01047         match("coolingratio");
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 C1dInvGaConfLexer::mGENERATIONST(bool _createToken) {
01057         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01058         _ttype = GENERATIONST;
01059         std::string::size_type _saveIndex;
01060         
01061         match("generations");
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 C1dInvGaConfLexer::mMUTATIONPROBT(bool _createToken) {
01071         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01072         _ttype = MUTATIONPROBT;
01073         std::string::size_type _saveIndex;
01074         
01075         match("mutationprob");
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 C1dInvGaConfLexer::mCROSSOVERPROBT(bool _createToken) {
01085         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01086         _ttype = CROSSOVERPROBT;
01087         std::string::size_type _saveIndex;
01088         
01089         match("crossoverprob");
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 C1dInvGaConfLexer::mSLOWNESST(bool _createToken) {
01099         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01100         _ttype = SLOWNESST;
01101         std::string::size_type _saveIndex;
01102         
01103         match("slowness");
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 C1dInvGaConfLexer::mOMEGAT(bool _createToken) {
01113         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01114         _ttype = OMEGAT;
01115         std::string::size_type _saveIndex;
01116         
01117         match("omega");
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 C1dInvGaConfLexer::mSIGMAT(bool _createToken) {
01127         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01128         _ttype = SIGMAT;
01129         std::string::size_type _saveIndex;
01130         
01131         match("sigma");
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 C1dInvGaConfLexer::mSHIFTT(bool _createToken) {
01141         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01142         _ttype = SHIFTT;
01143         std::string::size_type _saveIndex;
01144         
01145         match("shift");
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 C1dInvGaConfLexer::mCCT(bool _createToken) {
01155         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01156         _ttype = CCT;
01157         std::string::size_type _saveIndex;
01158         
01159         match("cc");
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 C1dInvGaConfLexer::mPOISSONT(bool _createToken) {
01169         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01170         _ttype = POISSONT;
01171         std::string::size_type _saveIndex;
01172         
01173         match("poisson");
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 C1dInvGaConfLexer::mTHREADST(bool _createToken) {
01183         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01184         _ttype = THREADST;
01185         std::string::size_type _saveIndex;
01186         
01187         match("threads");
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 C1dInvGaConfLexer::mSTARTTIMET(bool _createToken) {
01197         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01198         _ttype = STARTTIMET;
01199         std::string::size_type _saveIndex;
01200         
01201         match("starttime");
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 void C1dInvGaConfLexer::mENDTIMET(bool _createToken) {
01211         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01212         _ttype = ENDTIMET;
01213         std::string::size_type _saveIndex;
01214         
01215         match("endtime");
01216         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01217            _token = makeToken(_ttype);
01218            _token->setText(text.substr(_begin, text.length()-_begin));
01219         }
01220         _returnToken = _token;
01221         _saveIndex=0;
01222 }
01223 
01224 void C1dInvGaConfLexer::mTENSORERRORT(bool _createToken) {
01225         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01226         _ttype = TENSORERRORT;
01227         std::string::size_type _saveIndex;
01228         
01229         match("tensorerror");
01230         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01231            _token = makeToken(_ttype);
01232            _token->setText(text.substr(_begin, text.length()-_begin));
01233         }
01234         _returnToken = _token;
01235         _saveIndex=0;
01236 }
01237 
01238 void C1dInvGaConfLexer::mRESERRORT(bool _createToken) {
01239         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01240         _ttype = RESERRORT;
01241         std::string::size_type _saveIndex;
01242         
01243         match("reserror");
01244         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01245            _token = makeToken(_ttype);
01246            _token->setText(text.substr(_begin, text.length()-_begin));
01247         }
01248         _returnToken = _token;
01249         _saveIndex=0;
01250 }
01251 
01252 void C1dInvGaConfLexer::mPHASEERRORT(bool _createToken) {
01253         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01254         _ttype = PHASEERRORT;
01255         std::string::size_type _saveIndex;
01256         
01257         match("phaseerror");
01258         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01259            _token = makeToken(_ttype);
01260            _token->setText(text.substr(_begin, text.length()-_begin));
01261         }
01262         _returnToken = _token;
01263         _saveIndex=0;
01264 }
01265 
01266 void C1dInvGaConfLexer::mRECERRORT(bool _createToken) {
01267         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01268         _ttype = RECERRORT;
01269         std::string::size_type _saveIndex;
01270         
01271         match("recerror");
01272         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01273            _token = makeToken(_ttype);
01274            _token->setText(text.substr(_begin, text.length()-_begin));
01275         }
01276         _returnToken = _token;
01277         _saveIndex=0;
01278 }
01279 
01280 void C1dInvGaConfLexer::mRECMETHODT(bool _createToken) {
01281         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01282         _ttype = RECMETHODT;
01283         std::string::size_type _saveIndex;
01284         
01285         match("recmethod");
01286         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01287            _token = makeToken(_ttype);
01288            _token->setText(text.substr(_begin, text.length()-_begin));
01289         }
01290         _returnToken = _token;
01291         _saveIndex=0;
01292 }
01293 
01294 void C1dInvGaConfLexer::mGATYPET(bool _createToken) {
01295         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01296         _ttype = GATYPET;
01297         std::string::size_type _saveIndex;
01298         
01299         match("gatype");
01300         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01301            _token = makeToken(_ttype);
01302            _token->setText(text.substr(_begin, text.length()-_begin));
01303         }
01304         _returnToken = _token;
01305         _saveIndex=0;
01306 }
01307 
01308 void C1dInvGaConfLexer::mOUTPUTBASET(bool _createToken) {
01309         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01310         _ttype = OUTPUTBASET;
01311         std::string::size_type _saveIndex;
01312         
01313         match("outputbase");
01314         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01315            _token = makeToken(_ttype);
01316            _token->setText(text.substr(_begin, text.length()-_begin));
01317         }
01318         _returnToken = _token;
01319         _saveIndex=0;
01320 }
01321 
01322 void C1dInvGaConfLexer::mMODET(bool _createToken) {
01323         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01324         _ttype = MODET;
01325         std::string::size_type _saveIndex;
01326         
01327         match("mode");
01328         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01329            _token = makeToken(_ttype);
01330            _token->setText(text.substr(_begin, text.length()-_begin));
01331         }
01332         _returnToken = _token;
01333         _saveIndex=0;
01334 }
01335 
01336 void C1dInvGaConfLexer::mMTFITT(bool _createToken) {
01337         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01338         _ttype = MTFITT;
01339         std::string::size_type _saveIndex;
01340         
01341         match("mtfit");
01342         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01343            _token = makeToken(_ttype);
01344            _token->setText(text.substr(_begin, text.length()-_begin));
01345         }
01346         _returnToken = _token;
01347         _saveIndex=0;
01348 }
01349 
01350 void C1dInvGaConfLexer::mMTINPUTDATAT(bool _createToken) {
01351         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01352         _ttype = MTINPUTDATAT;
01353         std::string::size_type _saveIndex;
01354         
01355         match("mtinputdata");
01356         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01357            _token = makeToken(_ttype);
01358            _token->setText(text.substr(_begin, text.length()-_begin));
01359         }
01360         _returnToken = _token;
01361         _saveIndex=0;
01362 }
01363 
01364 void C1dInvGaConfLexer::mRECINPUTDATAT(bool _createToken) {
01365         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01366         _ttype = RECINPUTDATAT;
01367         std::string::size_type _saveIndex;
01368         
01369         match("recinputdata");
01370         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01371            _token = makeToken(_ttype);
01372            _token->setText(text.substr(_begin, text.length()-_begin));
01373         }
01374         _returnToken = _token;
01375         _saveIndex=0;
01376 }
01377 
01378 void C1dInvGaConfLexer::mRFABSVELDATAT(bool _createToken) {
01379         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01380         _ttype = RFABSVELDATAT;
01381         std::string::size_type _saveIndex;
01382         
01383         match("rfabsveldata");
01384         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01385            _token = makeToken(_ttype);
01386            _token->setText(text.substr(_begin, text.length()-_begin));
01387         }
01388         _returnToken = _token;
01389         _saveIndex=0;
01390 }
01391 
01392 void C1dInvGaConfLexer::mANNEALINGGENERATIONT(bool _createToken) {
01393         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01394         _ttype = ANNEALINGGENERATIONT;
01395         std::string::size_type _saveIndex;
01396         
01397         match("annealinggeneration");
01398         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01399            _token = makeToken(_ttype);
01400            _token->setText(text.substr(_begin, text.length()-_begin));
01401         }
01402         _returnToken = _token;
01403         _saveIndex=0;
01404 }
01405 
01406 void C1dInvGaConfLexer::mELITISTT(bool _createToken) {
01407         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01408         _ttype = ELITISTT;
01409         std::string::size_type _saveIndex;
01410         
01411         match("elitist");
01412         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01413            _token = makeToken(_ttype);
01414            _token->setText(text.substr(_begin, text.length()-_begin));
01415         }
01416         _returnToken = _token;
01417         _saveIndex=0;
01418 }
01419 
01420 void C1dInvGaConfLexer::mTHICKBASET(bool _createToken) {
01421         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01422         _ttype = THICKBASET;
01423         std::string::size_type _saveIndex;
01424         
01425         match("thickbase");
01426         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01427            _token = makeToken(_ttype);
01428            _token->setText(text.substr(_begin, text.length()-_begin));
01429         }
01430         _returnToken = _token;
01431         _saveIndex=0;
01432 }
01433 
01434 void C1dInvGaConfLexer::mTHICKSTEPT(bool _createToken) {
01435         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01436         _ttype = THICKSTEPT;
01437         std::string::size_type _saveIndex;
01438         
01439         match("thickstep");
01440         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01441            _token = makeToken(_ttype);
01442            _token->setText(text.substr(_begin, text.length()-_begin));
01443         }
01444         _returnToken = _token;
01445         _saveIndex=0;
01446 }
01447 
01448 void C1dInvGaConfLexer::mTHICKSIZEST(bool _createToken) {
01449         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01450         _ttype = THICKSIZEST;
01451         std::string::size_type _saveIndex;
01452         
01453         match("thicksizes");
01454         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01455            _token = makeToken(_ttype);
01456            _token->setText(text.substr(_begin, text.length()-_begin));
01457         }
01458         _returnToken = _token;
01459         _saveIndex=0;
01460 }
01461 
01462 void C1dInvGaConfLexer::mRESBASET(bool _createToken) {
01463         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01464         _ttype = RESBASET;
01465         std::string::size_type _saveIndex;
01466         
01467         match("resbase");
01468         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01469            _token = makeToken(_ttype);
01470            _token->setText(text.substr(_begin, text.length()-_begin));
01471         }
01472         _returnToken = _token;
01473         _saveIndex=0;
01474 }
01475 
01476 void C1dInvGaConfLexer::mRESSTEPT(bool _createToken) {
01477         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01478         _ttype = RESSTEPT;
01479         std::string::size_type _saveIndex;
01480         
01481         match("resstep");
01482         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01483            _token = makeToken(_ttype);
01484            _token->setText(text.substr(_begin, text.length()-_begin));
01485         }
01486         _returnToken = _token;
01487         _saveIndex=0;
01488 }
01489 
01490 void C1dInvGaConfLexer::mRESSIZEST(bool _createToken) {
01491         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01492         _ttype = RESSIZEST;
01493         std::string::size_type _saveIndex;
01494         
01495         match("ressizes");
01496         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01497            _token = makeToken(_ttype);
01498            _token->setText(text.substr(_begin, text.length()-_begin));
01499         }
01500         _returnToken = _token;
01501         _saveIndex=0;
01502 }
01503 
01504 void C1dInvGaConfLexer::mSVELBASET(bool _createToken) {
01505         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01506         _ttype = SVELBASET;
01507         std::string::size_type _saveIndex;
01508         
01509         match("svelbase");
01510         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01511            _token = makeToken(_ttype);
01512            _token->setText(text.substr(_begin, text.length()-_begin));
01513         }
01514         _returnToken = _token;
01515         _saveIndex=0;
01516 }
01517 
01518 void C1dInvGaConfLexer::mSVELSTEPT(bool _createToken) {
01519         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01520         _ttype = SVELSTEPT;
01521         std::string::size_type _saveIndex;
01522         
01523         match("svelstep");
01524         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01525            _token = makeToken(_ttype);
01526            _token->setText(text.substr(_begin, text.length()-_begin));
01527         }
01528         _returnToken = _token;
01529         _saveIndex=0;
01530 }
01531 
01532 void C1dInvGaConfLexer::mSVELSIZEST(bool _createToken) {
01533         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01534         _ttype = SVELSIZEST;
01535         std::string::size_type _saveIndex;
01536         
01537         match("svelsizes");
01538         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01539            _token = makeToken(_ttype);
01540            _token->setText(text.substr(_begin, text.length()-_begin));
01541         }
01542         _returnToken = _token;
01543         _saveIndex=0;
01544 }
01545 
01546 void C1dInvGaConfLexer::mWEIGHTST(bool _createToken) {
01547         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01548         _ttype = WEIGHTST;
01549         std::string::size_type _saveIndex;
01550         
01551         match("weights");
01552         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01553            _token = makeToken(_ttype);
01554            _token->setText(text.substr(_begin, text.length()-_begin));
01555         }
01556         _returnToken = _token;
01557         _saveIndex=0;
01558 }
01559 
01560 void C1dInvGaConfLexer::mRECWEIGHTT(bool _createToken) {
01561         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01562         _ttype = RECWEIGHTT;
01563         std::string::size_type _saveIndex;
01564         
01565         match("recweight");
01566         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01567            _token = makeToken(_ttype);
01568            _token->setText(text.substr(_begin, text.length()-_begin));
01569         }
01570         _returnToken = _token;
01571         _saveIndex=0;
01572 }
01573 
01574 void C1dInvGaConfLexer::mABSVELWEIGHTT(bool _createToken) {
01575         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01576         _ttype = ABSVELWEIGHTT;
01577         std::string::size_type _saveIndex;
01578         
01579         match("absvelweight");
01580         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01581            _token = makeToken(_ttype);
01582            _token->setText(text.substr(_begin, text.length()-_begin));
01583         }
01584         _returnToken = _token;
01585         _saveIndex=0;
01586 }
01587 
01588 
01589 const unsigned long C1dInvGaConfLexer::_tokenSet_0_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL };
01590 // . 0 1 2 3 4 5 6 7 8 9 
01591 const antlr::BitSet C1dInvGaConfLexer::_tokenSet_0(_tokenSet_0_data_,6);
01592 const unsigned long C1dInvGaConfLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
01593 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
01594 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
01595 // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > 
01596 const antlr::BitSet C1dInvGaConfLexer::_tokenSet_1(_tokenSet_1_data_,8);
01597