MT Tools » 1DMT

MTAnisoGAConfLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.6 (20070220): "MTAnisoGAConf.g" -> "MTAnisoGAConfLexer.cpp"$ */
00002 #include "MTAnisoGAConfLexer.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 "MTAnisoGAConf.g"
00012 #line 13 "MTAnisoGAConfLexer.cpp"
00013 MTAnisoGAConfLexer::MTAnisoGAConfLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 MTAnisoGAConfLexer::MTAnisoGAConfLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 MTAnisoGAConfLexer::MTAnisoGAConfLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void MTAnisoGAConfLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken MTAnisoGAConfLexer::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) == 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' */ )) {
00085                                         mMTFITEXPONENTT(true);
00086                                         theRetToken=_returnToken;
00087                                 }
00088                                 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' */ )) {
00089                                         mCOOLINGRATIOT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 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' */ )) {
00093                                         mGENERATIONST(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 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' */ )) {
00097                                         mMUTATIONPROBT(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 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' */ )) {
00101                                         mCROSSOVERPROBT(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 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' */ )) {
00105                                         mTENSORERRORT(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 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' */ )) {
00109                                         mPHASEERRORT(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) == 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' */ )) {
00117                                         mMTINPUTDATAT(true);
00118                                         theRetToken=_returnToken;
00119                                 }
00120                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6e /* 'n' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (LA(8) == 0x64 /* 'd' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00121                                         mPTENSORDATAT(true);
00122                                         theRetToken=_returnToken;
00123                                 }
00124                                 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' */ )) {
00125                                         mANNEALINGGENERATIONT(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 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' */ )) {
00129                                         mTHICKSIZEST(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x7a /* 'z' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x73 /* 's' */ )) {
00133                                         mANISOSIZEST(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x62 /* 'b' */ ) && (LA(8) == 0x61 /* 'a' */ ) && (LA(9) == 0x73 /* 's' */ ) && (LA(10) == 0x65 /* 'e' */ )) {
00137                                         mSTRIKEBASET(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x74 /* 't' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x70 /* 'p' */ )) {
00141                                         mSTRIKESTEPT(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x7a /* 'z' */ ) && (LA(10) == 0x65 /* 'e' */ )) {
00145                                         mSTRIKESIZEST(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x64 /* 'd' */ ) && (LA(5) == 0x64 /* 'd' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x66 /* 'f' */ ) && (LA(8) == 0x66 /* 'f' */ ) && (LA(9) == 0x77 /* 'w' */ ) && (LA(10) == 0x65 /* 'e' */ )) {
00149                                         mCONDDIFFWEIGHTT(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (LA(8) == 0x6f /* 'o' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (LA(10) == 0x79 /* 'y' */ )) {
00153                                         mANISOTROPYWEIGHTT(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x64 /* 'd' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x66 /* 'f' */ ) && (LA(10) == 0x66 /* 'f' */ )) {
00157                                         mSTRIKEDIFFWEIGHTT(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 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)) {
00161                                         mSTARTTIMET(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) == 0x62 /* 'b' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x73 /* 's' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00165                                         mTHICKBASET(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 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)) {
00169                                         mTHICKSTEPT(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x62 /* 'b' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x73 /* 's' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00173                                         mANISOBASET(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (true)) {
00177                                         mANISOSTEPT(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 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)) {
00181                                         mINITTEMPT(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) == 0x73 /* 's' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x7a /* 'z' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x73 /* 's' */ ) && (true) && (true)) {
00189                                         mRESSIZEST(true);
00190                                         theRetToken=_returnToken;
00191                                 }
00192                                 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)) {
00193                                         mVERBOSET(true);
00194                                         theRetToken=_returnToken;
00195                                 }
00196                                 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)) {
00197                                         mPOPSIZET(true);
00198                                         theRetToken=_returnToken;
00199                                 }
00200                                 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)) {
00201                                         mTHREADST(true);
00202                                         theRetToken=_returnToken;
00203                                 }
00204                                 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)) {
00205                                         mENDTIMET(true);
00206                                         theRetToken=_returnToken;
00207                                 }
00208                                 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)) {
00209                                         mELITISTT(true);
00210                                         theRetToken=_returnToken;
00211                                 }
00212                                 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)) {
00213                                         mRESBASET(true);
00214                                         theRetToken=_returnToken;
00215                                 }
00216                                 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)) {
00217                                         mRESSTEPT(true);
00218                                         theRetToken=_returnToken;
00219                                 }
00220                                 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)) {
00221                                         mWEIGHTST(true);
00222                                         theRetToken=_returnToken;
00223                                 }
00224                                 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)) {
00225                                         mGATYPET(true);
00226                                         theRetToken=_returnToken;
00227                                 }
00228                                 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)) {
00229                                         mFALSE(true);
00230                                         theRetToken=_returnToken;
00231                                 }
00232                                 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)) {
00233                                         mMTFITT(true);
00234                                         theRetToken=_returnToken;
00235                                 }
00236                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00237                                         mTRUE(true);
00238                                         theRetToken=_returnToken;
00239                                 }
00240                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00241                                         mMODET(true);
00242                                         theRetToken=_returnToken;
00243                                 }
00244                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00245                                         mSTRING(true);
00246                                         theRetToken=_returnToken;
00247                                 }
00248                         else {
00249                                 if (LA(1)==EOF_CHAR)
00250                                 {
00251                                         uponEOF();
00252                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00253                                 }
00254                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00255                         }
00256                         }
00257                         if ( !_returnToken )
00258                                 goto tryAgain; // found SKIP token
00259 
00260                         _ttype = _returnToken->getType();
00261                         _ttype = testLiteralsTable(_ttype);
00262                         _returnToken->setType(_ttype);
00263                         return _returnToken;
00264                 }
00265                 catch (antlr::RecognitionException& e) {
00266                                 throw antlr::TokenStreamRecognitionException(e);
00267                 }
00268                 catch (antlr::CharStreamIOException& csie) {
00269                         throw antlr::TokenStreamIOException(csie.io);
00270                 }
00271                 catch (antlr::CharStreamException& cse) {
00272                         throw antlr::TokenStreamException(cse.getMessage());
00273                 }
00274 tryAgain:;
00275         }
00276 }
00277 
00278 void MTAnisoGAConfLexer::mEQUAL(bool _createToken) {
00279         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00280         _ttype = EQUAL;
00281         std::string::size_type _saveIndex;
00282         
00283         match('=' /* charlit */ );
00284         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00285            _token = makeToken(_ttype);
00286            _token->setText(text.substr(_begin, text.length()-_begin));
00287         }
00288         _returnToken = _token;
00289         _saveIndex=0;
00290 }
00291 
00292 void MTAnisoGAConfLexer::mTRUE(bool _createToken) {
00293         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00294         _ttype = TRUE;
00295         std::string::size_type _saveIndex;
00296         
00297         match("true");
00298         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00299            _token = makeToken(_ttype);
00300            _token->setText(text.substr(_begin, text.length()-_begin));
00301         }
00302         _returnToken = _token;
00303         _saveIndex=0;
00304 }
00305 
00306 void MTAnisoGAConfLexer::mFALSE(bool _createToken) {
00307         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00308         _ttype = FALSE;
00309         std::string::size_type _saveIndex;
00310         
00311         match("false");
00312         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00313            _token = makeToken(_ttype);
00314            _token->setText(text.substr(_begin, text.length()-_begin));
00315         }
00316         _returnToken = _token;
00317         _saveIndex=0;
00318 }
00319 
00320 void MTAnisoGAConfLexer::mWS(bool _createToken) {
00321         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00322         _ttype = WS;
00323         std::string::size_type _saveIndex;
00324         
00325         { // ( ... )+
00326         int _cnt192=0;
00327         for (;;) {
00328                 switch ( LA(1)) {
00329                 case 0x20 /* ' ' */ :
00330                 {
00331                         match(' ' /* charlit */ );
00332                         break;
00333                 }
00334                 case 0xa /* '\n' */ :
00335                 case 0xd /* '\r' */ :
00336                 {
00337                         mNEWLINE(false);
00338                         break;
00339                 }
00340                 case 0x9 /* '\t' */ :
00341                 {
00342                         match('\t' /* charlit */ );
00343                         break;
00344                 }
00345                 default:
00346                 {
00347                         if ( _cnt192>=1 ) { goto _loop192; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00348                 }
00349                 }
00350                 _cnt192++;
00351         }
00352         _loop192:;
00353         }  // ( ... )+
00354         if ( inputState->guessing==0 ) {
00355 #line 156 "MTAnisoGAConf.g"
00356                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00357 #line 358 "MTAnisoGAConfLexer.cpp"
00358         }
00359         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00360            _token = makeToken(_ttype);
00361            _token->setText(text.substr(_begin, text.length()-_begin));
00362         }
00363         _returnToken = _token;
00364         _saveIndex=0;
00365 }
00366 
00367 void MTAnisoGAConfLexer::mNEWLINE(bool _createToken) {
00368         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00369         _ttype = NEWLINE;
00370         std::string::size_type _saveIndex;
00371         
00372         {
00373         switch ( LA(1)) {
00374         case 0xa /* '\n' */ :
00375         {
00376                 match('\n' /* charlit */ );
00377                 break;
00378         }
00379         case 0xd /* '\r' */ :
00380         {
00381                 match('\r' /* charlit */ );
00382                 match('\n' /* charlit */ );
00383                 break;
00384         }
00385         default:
00386         {
00387                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00388         }
00389         }
00390         }
00391         if ( inputState->guessing==0 ) {
00392 #line 182 "MTAnisoGAConf.g"
00393                 newline();
00394 #line 395 "MTAnisoGAConfLexer.cpp"
00395         }
00396         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00397            _token = makeToken(_ttype);
00398            _token->setText(text.substr(_begin, text.length()-_begin));
00399         }
00400         _returnToken = _token;
00401         _saveIndex=0;
00402 }
00403 
00404 void MTAnisoGAConfLexer::mSTRING(bool _createToken) {
00405         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00406         _ttype = STRING;
00407         std::string::size_type _saveIndex;
00408         
00409         mCHAR(false);
00410         { // ( ... )*
00411         for (;;) {
00412                 switch ( LA(1)) {
00413                 case 0x61 /* 'a' */ :
00414                 case 0x62 /* 'b' */ :
00415                 case 0x63 /* 'c' */ :
00416                 case 0x64 /* 'd' */ :
00417                 case 0x65 /* 'e' */ :
00418                 case 0x66 /* 'f' */ :
00419                 case 0x67 /* 'g' */ :
00420                 case 0x68 /* 'h' */ :
00421                 case 0x69 /* 'i' */ :
00422                 case 0x6a /* 'j' */ :
00423                 case 0x6b /* 'k' */ :
00424                 case 0x6c /* 'l' */ :
00425                 case 0x6d /* 'm' */ :
00426                 case 0x6e /* 'n' */ :
00427                 case 0x6f /* 'o' */ :
00428                 case 0x70 /* 'p' */ :
00429                 case 0x71 /* 'q' */ :
00430                 case 0x72 /* 'r' */ :
00431                 case 0x73 /* 's' */ :
00432                 case 0x74 /* 't' */ :
00433                 case 0x75 /* 'u' */ :
00434                 case 0x76 /* 'v' */ :
00435                 case 0x77 /* 'w' */ :
00436                 case 0x78 /* 'x' */ :
00437                 case 0x79 /* 'y' */ :
00438                 case 0x7a /* 'z' */ :
00439                 {
00440                         mCHAR(false);
00441                         break;
00442                 }
00443                 case 0x30 /* '0' */ :
00444                 case 0x31 /* '1' */ :
00445                 case 0x32 /* '2' */ :
00446                 case 0x33 /* '3' */ :
00447                 case 0x34 /* '4' */ :
00448                 case 0x35 /* '5' */ :
00449                 case 0x36 /* '6' */ :
00450                 case 0x37 /* '7' */ :
00451                 case 0x38 /* '8' */ :
00452                 case 0x39 /* '9' */ :
00453                 {
00454                         mDIGIT(false);
00455                         break;
00456                 }
00457                 case 0x23 /* '#' */ :
00458                 case 0x24 /* '$' */ :
00459                 case 0x25 /* '%' */ :
00460                 case 0x26 /* '&' */ :
00461                 case 0x27 /* '\'' */ :
00462                 case 0x28 /* '(' */ :
00463                 case 0x29 /* ')' */ :
00464                 case 0x2a /* '*' */ :
00465                 case 0x2b /* '+' */ :
00466                 case 0x2c /* ',' */ :
00467                 case 0x2d /* '-' */ :
00468                 case 0x2e /* '.' */ :
00469                 case 0x2f /* '/' */ :
00470                 case 0x3a /* ':' */ :
00471                 case 0x3b /* ';' */ :
00472                 case 0x3c /* '<' */ :
00473                 case 0x3f /* '?' */ :
00474                 case 0x40 /* '@' */ :
00475                 case 0x5b /* '[' */ :
00476                 case 0x5d /* ']' */ :
00477                 case 0x5e /* '^' */ :
00478                 case 0x5f /* '_' */ :
00479                 case 0x7b /* '{' */ :
00480                 case 0x7c /* '|' */ :
00481                 case 0x7d /* '}' */ :
00482                 case 0x7e /* '~' */ :
00483                 {
00484                         mOTHER(false);
00485                         break;
00486                 }
00487                 default:
00488                 {
00489                         goto _loop195;
00490                 }
00491                 }
00492         }
00493         _loop195:;
00494         } // ( ... )*
00495         _ttype = testLiteralsTable(_ttype);
00496         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00497            _token = makeToken(_ttype);
00498            _token->setText(text.substr(_begin, text.length()-_begin));
00499         }
00500         _returnToken = _token;
00501         _saveIndex=0;
00502 }
00503 
00504 void MTAnisoGAConfLexer::mCHAR(bool _createToken) {
00505         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00506         _ttype = CHAR;
00507         std::string::size_type _saveIndex;
00508         
00509         {
00510         matchRange('a','z');
00511         }
00512         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00513            _token = makeToken(_ttype);
00514            _token->setText(text.substr(_begin, text.length()-_begin));
00515         }
00516         _returnToken = _token;
00517         _saveIndex=0;
00518 }
00519 
00520 void MTAnisoGAConfLexer::mDIGIT(bool _createToken) {
00521         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00522         _ttype = DIGIT;
00523         std::string::size_type _saveIndex;
00524         
00525         matchRange('0','9');
00526         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00527            _token = makeToken(_ttype);
00528            _token->setText(text.substr(_begin, text.length()-_begin));
00529         }
00530         _returnToken = _token;
00531         _saveIndex=0;
00532 }
00533 
00534 void MTAnisoGAConfLexer::mOTHER(bool _createToken) {
00535         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00536         _ttype = OTHER;
00537         std::string::size_type _saveIndex;
00538         
00539         switch ( LA(1)) {
00540         case 0x27 /* '\'' */ :
00541         {
00542                 match('\'' /* charlit */ );
00543                 break;
00544         }
00545         case 0x23 /* '#' */ :
00546         {
00547                 match('#' /* charlit */ );
00548                 break;
00549         }
00550         case 0x24 /* '$' */ :
00551         {
00552                 match('$' /* charlit */ );
00553                 break;
00554         }
00555         case 0x25 /* '%' */ :
00556         {
00557                 match('%' /* charlit */ );
00558                 break;
00559         }
00560         case 0x26 /* '&' */ :
00561         {
00562                 match('&' /* charlit */ );
00563                 break;
00564         }
00565         case 0x28 /* '(' */ :
00566         {
00567                 match('(' /* charlit */ );
00568                 break;
00569         }
00570         case 0x29 /* ')' */ :
00571         {
00572                 match(')' /* charlit */ );
00573                 break;
00574         }
00575         case 0x2a /* '*' */ :
00576         {
00577                 match('*' /* charlit */ );
00578                 break;
00579         }
00580         case 0x2b /* '+' */ :
00581         {
00582                 match('+' /* charlit */ );
00583                 break;
00584         }
00585         case 0x2c /* ',' */ :
00586         {
00587                 match(',' /* charlit */ );
00588                 break;
00589         }
00590         case 0x2d /* '-' */ :
00591         {
00592                 match('-' /* charlit */ );
00593                 break;
00594         }
00595         case 0x2e /* '.' */ :
00596         {
00597                 match('.' /* charlit */ );
00598                 break;
00599         }
00600         case 0x2f /* '/' */ :
00601         {
00602                 match('/' /* charlit */ );
00603                 break;
00604         }
00605         case 0x3a /* ':' */ :
00606         {
00607                 match(':' /* charlit */ );
00608                 break;
00609         }
00610         case 0x3b /* ';' */ :
00611         {
00612                 match(';' /* charlit */ );
00613                 break;
00614         }
00615         case 0x3c /* '<' */ :
00616         {
00617                 match('<' /* charlit */ );
00618                 break;
00619         }
00620         case 0x3f /* '?' */ :
00621         {
00622                 match('?' /* charlit */ );
00623                 break;
00624         }
00625         case 0x40 /* '@' */ :
00626         {
00627                 match('@' /* charlit */ );
00628                 break;
00629         }
00630         case 0x5b /* '[' */ :
00631         {
00632                 match('[' /* charlit */ );
00633                 break;
00634         }
00635         case 0x5d /* ']' */ :
00636         {
00637                 match(']' /* charlit */ );
00638                 break;
00639         }
00640         case 0x5e /* '^' */ :
00641         {
00642                 match('^' /* charlit */ );
00643                 break;
00644         }
00645         case 0x5f /* '_' */ :
00646         {
00647                 match('_' /* charlit */ );
00648                 break;
00649         }
00650         case 0x7b /* '{' */ :
00651         {
00652                 match('{' /* charlit */ );
00653                 break;
00654         }
00655         case 0x7c /* '|' */ :
00656         {
00657                 match('|' /* charlit */ );
00658                 break;
00659         }
00660         case 0x7d /* '}' */ :
00661         {
00662                 match('}' /* charlit */ );
00663                 break;
00664         }
00665         case 0x7e /* '~' */ :
00666         {
00667                 match('~' /* charlit */ );
00668                 break;
00669         }
00670         default:
00671         {
00672                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00673         }
00674         }
00675         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00676            _token = makeToken(_ttype);
00677            _token->setText(text.substr(_begin, text.length()-_begin));
00678         }
00679         _returnToken = _token;
00680         _saveIndex=0;
00681 }
00682 
00683 void MTAnisoGAConfLexer::mNUMBER(bool _createToken) {
00684         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00685         _ttype = NUMBER;
00686         std::string::size_type _saveIndex;
00687         
00688         {
00689         switch ( LA(1)) {
00690         case 0x2b /* '+' */ :
00691         {
00692                 match('+' /* charlit */ );
00693                 break;
00694         }
00695         case 0x2d /* '-' */ :
00696         {
00697                 match('-' /* charlit */ );
00698                 break;
00699         }
00700         case 0x2e /* '.' */ :
00701         case 0x30 /* '0' */ :
00702         case 0x31 /* '1' */ :
00703         case 0x32 /* '2' */ :
00704         case 0x33 /* '3' */ :
00705         case 0x34 /* '4' */ :
00706         case 0x35 /* '5' */ :
00707         case 0x36 /* '6' */ :
00708         case 0x37 /* '7' */ :
00709         case 0x38 /* '8' */ :
00710         case 0x39 /* '9' */ :
00711         {
00712                 break;
00713         }
00714         default:
00715         {
00716                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00717         }
00718         }
00719         }
00720         {
00721         bool synPredMatched200 = false;
00722         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00723                 int _m200 = mark();
00724                 synPredMatched200 = true;
00725                 inputState->guessing++;
00726                 try {
00727                         {
00728                         mREAL(false);
00729                         }
00730                 }
00731                 catch (antlr::RecognitionException& pe) {
00732                         synPredMatched200 = false;
00733                 }
00734                 rewind(_m200);
00735                 inputState->guessing--;
00736         }
00737         if ( synPredMatched200 ) {
00738                 mREAL(false);
00739         }
00740         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00741                 mINT(false);
00742         }
00743         else {
00744                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00745         }
00746         
00747         }
00748         {
00749         if ((LA(1) == 0x65 /* 'e' */ )) {
00750                 {
00751                 match('e' /* charlit */ );
00752                 }
00753                 {
00754                 switch ( LA(1)) {
00755                 case 0x2b /* '+' */ :
00756                 {
00757                         match('+' /* charlit */ );
00758                         break;
00759                 }
00760                 case 0x2d /* '-' */ :
00761                 {
00762                         match('-' /* charlit */ );
00763                         break;
00764                 }
00765                 case 0x30 /* '0' */ :
00766                 case 0x31 /* '1' */ :
00767                 case 0x32 /* '2' */ :
00768                 case 0x33 /* '3' */ :
00769                 case 0x34 /* '4' */ :
00770                 case 0x35 /* '5' */ :
00771                 case 0x36 /* '6' */ :
00772                 case 0x37 /* '7' */ :
00773                 case 0x38 /* '8' */ :
00774                 case 0x39 /* '9' */ :
00775                 {
00776                         break;
00777                 }
00778                 default:
00779                 {
00780                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00781                 }
00782                 }
00783                 }
00784                 mINT(false);
00785         }
00786         else {
00787         }
00788         
00789         }
00790         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00791            _token = makeToken(_ttype);
00792            _token->setText(text.substr(_begin, text.length()-_begin));
00793         }
00794         _returnToken = _token;
00795         _saveIndex=0;
00796 }
00797 
00798 void MTAnisoGAConfLexer::mREAL(bool _createToken) {
00799         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00800         _ttype = REAL;
00801         std::string::size_type _saveIndex;
00802         
00803         {
00804         switch ( LA(1)) {
00805         case 0x2e /* '.' */ :
00806         {
00807                 match('.' /* charlit */ );
00808                 mINT(false);
00809                 break;
00810         }
00811         case 0x30 /* '0' */ :
00812         case 0x31 /* '1' */ :
00813         case 0x32 /* '2' */ :
00814         case 0x33 /* '3' */ :
00815         case 0x34 /* '4' */ :
00816         case 0x35 /* '5' */ :
00817         case 0x36 /* '6' */ :
00818         case 0x37 /* '7' */ :
00819         case 0x38 /* '8' */ :
00820         case 0x39 /* '9' */ :
00821         {
00822                 mINT(false);
00823                 match('.' /* charlit */ );
00824                 {
00825                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00826                         mINT(false);
00827                 }
00828                 else {
00829                 }
00830                 
00831                 }
00832                 break;
00833         }
00834         default:
00835         {
00836                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00837         }
00838         }
00839         }
00840         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00841            _token = makeToken(_ttype);
00842            _token->setText(text.substr(_begin, text.length()-_begin));
00843         }
00844         _returnToken = _token;
00845         _saveIndex=0;
00846 }
00847 
00848 void MTAnisoGAConfLexer::mINT(bool _createToken) {
00849         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00850         _ttype = INT;
00851         std::string::size_type _saveIndex;
00852         
00853         { // ( ... )+
00854         int _cnt215=0;
00855         for (;;) {
00856                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00857                         mDIGIT(false);
00858                 }
00859                 else {
00860                         if ( _cnt215>=1 ) { goto _loop215; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00861                 }
00862                 
00863                 _cnt215++;
00864         }
00865         _loop215:;
00866         }  // ( ... )+
00867         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00868            _token = makeToken(_ttype);
00869            _token->setText(text.substr(_begin, text.length()-_begin));
00870         }
00871         _returnToken = _token;
00872         _saveIndex=0;
00873 }
00874 
00875 void MTAnisoGAConfLexer::mCOMMENT(bool _createToken) {
00876         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00877         _ttype = COMMENT;
00878         std::string::size_type _saveIndex;
00879         
00880         match('/' /* charlit */ );
00881         match('/' /* charlit */ );
00882         { // ( ... )*
00883         for (;;) {
00884                 if ((_tokenSet_1.member(LA(1)))) {
00885                         {
00886                         match(_tokenSet_1);
00887                         }
00888                 }
00889                 else {
00890                         goto _loop207;
00891                 }
00892                 
00893         }
00894         _loop207:;
00895         } // ( ... )*
00896         mNEWLINE(false);
00897         if ( inputState->guessing==0 ) {
00898 #line 173 "MTAnisoGAConf.g"
00899                 
00900                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00901                                 
00902 #line 903 "MTAnisoGAConfLexer.cpp"
00903         }
00904         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00905            _token = makeToken(_ttype);
00906            _token->setText(text.substr(_begin, text.length()-_begin));
00907         }
00908         _returnToken = _token;
00909         _saveIndex=0;
00910 }
00911 
00912 void MTAnisoGAConfLexer::mVERBOSET(bool _createToken) {
00913         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00914         _ttype = VERBOSET;
00915         std::string::size_type _saveIndex;
00916         
00917         match("verbose");
00918         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00919            _token = makeToken(_ttype);
00920            _token->setText(text.substr(_begin, text.length()-_begin));
00921         }
00922         _returnToken = _token;
00923         _saveIndex=0;
00924 }
00925 
00926 void MTAnisoGAConfLexer::mMTFITEXPONENTT(bool _createToken) {
00927         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00928         _ttype = MTFITEXPONENTT;
00929         std::string::size_type _saveIndex;
00930         
00931         match("mtfitexponent");
00932         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00933            _token = makeToken(_ttype);
00934            _token->setText(text.substr(_begin, text.length()-_begin));
00935         }
00936         _returnToken = _token;
00937         _saveIndex=0;
00938 }
00939 
00940 void MTAnisoGAConfLexer::mPOPSIZET(bool _createToken) {
00941         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00942         _ttype = POPSIZET;
00943         std::string::size_type _saveIndex;
00944         
00945         match("popsize");
00946         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00947            _token = makeToken(_ttype);
00948            _token->setText(text.substr(_begin, text.length()-_begin));
00949         }
00950         _returnToken = _token;
00951         _saveIndex=0;
00952 }
00953 
00954 void MTAnisoGAConfLexer::mINITTEMPT(bool _createToken) {
00955         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00956         _ttype = INITTEMPT;
00957         std::string::size_type _saveIndex;
00958         
00959         match("inittemp");
00960         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00961            _token = makeToken(_ttype);
00962            _token->setText(text.substr(_begin, text.length()-_begin));
00963         }
00964         _returnToken = _token;
00965         _saveIndex=0;
00966 }
00967 
00968 void MTAnisoGAConfLexer::mCOOLINGRATIOT(bool _createToken) {
00969         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00970         _ttype = COOLINGRATIOT;
00971         std::string::size_type _saveIndex;
00972         
00973         match("coolingratio");
00974         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00975            _token = makeToken(_ttype);
00976            _token->setText(text.substr(_begin, text.length()-_begin));
00977         }
00978         _returnToken = _token;
00979         _saveIndex=0;
00980 }
00981 
00982 void MTAnisoGAConfLexer::mGENERATIONST(bool _createToken) {
00983         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00984         _ttype = GENERATIONST;
00985         std::string::size_type _saveIndex;
00986         
00987         match("generations");
00988         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00989            _token = makeToken(_ttype);
00990            _token->setText(text.substr(_begin, text.length()-_begin));
00991         }
00992         _returnToken = _token;
00993         _saveIndex=0;
00994 }
00995 
00996 void MTAnisoGAConfLexer::mMUTATIONPROBT(bool _createToken) {
00997         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00998         _ttype = MUTATIONPROBT;
00999         std::string::size_type _saveIndex;
01000         
01001         match("mutationprob");
01002         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01003            _token = makeToken(_ttype);
01004            _token->setText(text.substr(_begin, text.length()-_begin));
01005         }
01006         _returnToken = _token;
01007         _saveIndex=0;
01008 }
01009 
01010 void MTAnisoGAConfLexer::mCROSSOVERPROBT(bool _createToken) {
01011         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01012         _ttype = CROSSOVERPROBT;
01013         std::string::size_type _saveIndex;
01014         
01015         match("crossoverprob");
01016         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01017            _token = makeToken(_ttype);
01018            _token->setText(text.substr(_begin, text.length()-_begin));
01019         }
01020         _returnToken = _token;
01021         _saveIndex=0;
01022 }
01023 
01024 void MTAnisoGAConfLexer::mTHREADST(bool _createToken) {
01025         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01026         _ttype = THREADST;
01027         std::string::size_type _saveIndex;
01028         
01029         match("threads");
01030         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01031            _token = makeToken(_ttype);
01032            _token->setText(text.substr(_begin, text.length()-_begin));
01033         }
01034         _returnToken = _token;
01035         _saveIndex=0;
01036 }
01037 
01038 void MTAnisoGAConfLexer::mSTARTTIMET(bool _createToken) {
01039         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01040         _ttype = STARTTIMET;
01041         std::string::size_type _saveIndex;
01042         
01043         match("starttime");
01044         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01045            _token = makeToken(_ttype);
01046            _token->setText(text.substr(_begin, text.length()-_begin));
01047         }
01048         _returnToken = _token;
01049         _saveIndex=0;
01050 }
01051 
01052 void MTAnisoGAConfLexer::mENDTIMET(bool _createToken) {
01053         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01054         _ttype = ENDTIMET;
01055         std::string::size_type _saveIndex;
01056         
01057         match("endtime");
01058         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01059            _token = makeToken(_ttype);
01060            _token->setText(text.substr(_begin, text.length()-_begin));
01061         }
01062         _returnToken = _token;
01063         _saveIndex=0;
01064 }
01065 
01066 void MTAnisoGAConfLexer::mTENSORERRORT(bool _createToken) {
01067         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01068         _ttype = TENSORERRORT;
01069         std::string::size_type _saveIndex;
01070         
01071         match("tensorerror");
01072         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01073            _token = makeToken(_ttype);
01074            _token->setText(text.substr(_begin, text.length()-_begin));
01075         }
01076         _returnToken = _token;
01077         _saveIndex=0;
01078 }
01079 
01080 void MTAnisoGAConfLexer::mRESERRORT(bool _createToken) {
01081         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01082         _ttype = RESERRORT;
01083         std::string::size_type _saveIndex;
01084         
01085         match("reserror");
01086         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01087            _token = makeToken(_ttype);
01088            _token->setText(text.substr(_begin, text.length()-_begin));
01089         }
01090         _returnToken = _token;
01091         _saveIndex=0;
01092 }
01093 
01094 void MTAnisoGAConfLexer::mPHASEERRORT(bool _createToken) {
01095         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01096         _ttype = PHASEERRORT;
01097         std::string::size_type _saveIndex;
01098         
01099         match("phaseerror");
01100         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01101            _token = makeToken(_ttype);
01102            _token->setText(text.substr(_begin, text.length()-_begin));
01103         }
01104         _returnToken = _token;
01105         _saveIndex=0;
01106 }
01107 
01108 void MTAnisoGAConfLexer::mGATYPET(bool _createToken) {
01109         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01110         _ttype = GATYPET;
01111         std::string::size_type _saveIndex;
01112         
01113         match("gatype");
01114         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01115            _token = makeToken(_ttype);
01116            _token->setText(text.substr(_begin, text.length()-_begin));
01117         }
01118         _returnToken = _token;
01119         _saveIndex=0;
01120 }
01121 
01122 void MTAnisoGAConfLexer::mOUTPUTBASET(bool _createToken) {
01123         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01124         _ttype = OUTPUTBASET;
01125         std::string::size_type _saveIndex;
01126         
01127         match("outputbase");
01128         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01129            _token = makeToken(_ttype);
01130            _token->setText(text.substr(_begin, text.length()-_begin));
01131         }
01132         _returnToken = _token;
01133         _saveIndex=0;
01134 }
01135 
01136 void MTAnisoGAConfLexer::mMODET(bool _createToken) {
01137         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01138         _ttype = MODET;
01139         std::string::size_type _saveIndex;
01140         
01141         match("mode");
01142         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01143            _token = makeToken(_ttype);
01144            _token->setText(text.substr(_begin, text.length()-_begin));
01145         }
01146         _returnToken = _token;
01147         _saveIndex=0;
01148 }
01149 
01150 void MTAnisoGAConfLexer::mMTFITT(bool _createToken) {
01151         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01152         _ttype = MTFITT;
01153         std::string::size_type _saveIndex;
01154         
01155         match("mtfit");
01156         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01157            _token = makeToken(_ttype);
01158            _token->setText(text.substr(_begin, text.length()-_begin));
01159         }
01160         _returnToken = _token;
01161         _saveIndex=0;
01162 }
01163 
01164 void MTAnisoGAConfLexer::mMTINPUTDATAT(bool _createToken) {
01165         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01166         _ttype = MTINPUTDATAT;
01167         std::string::size_type _saveIndex;
01168         
01169         match("mtinputdata");
01170         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01171            _token = makeToken(_ttype);
01172            _token->setText(text.substr(_begin, text.length()-_begin));
01173         }
01174         _returnToken = _token;
01175         _saveIndex=0;
01176 }
01177 
01178 void MTAnisoGAConfLexer::mPTENSORDATAT(bool _createToken) {
01179         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01180         _ttype = PTENSORDATAT;
01181         std::string::size_type _saveIndex;
01182         
01183         match("ptensordata");
01184         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01185            _token = makeToken(_ttype);
01186            _token->setText(text.substr(_begin, text.length()-_begin));
01187         }
01188         _returnToken = _token;
01189         _saveIndex=0;
01190 }
01191 
01192 void MTAnisoGAConfLexer::mANNEALINGGENERATIONT(bool _createToken) {
01193         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01194         _ttype = ANNEALINGGENERATIONT;
01195         std::string::size_type _saveIndex;
01196         
01197         match("annealinggeneration");
01198         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01199            _token = makeToken(_ttype);
01200            _token->setText(text.substr(_begin, text.length()-_begin));
01201         }
01202         _returnToken = _token;
01203         _saveIndex=0;
01204 }
01205 
01206 void MTAnisoGAConfLexer::mELITISTT(bool _createToken) {
01207         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01208         _ttype = ELITISTT;
01209         std::string::size_type _saveIndex;
01210         
01211         match("elitist");
01212         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01213            _token = makeToken(_ttype);
01214            _token->setText(text.substr(_begin, text.length()-_begin));
01215         }
01216         _returnToken = _token;
01217         _saveIndex=0;
01218 }
01219 
01220 void MTAnisoGAConfLexer::mTHICKBASET(bool _createToken) {
01221         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01222         _ttype = THICKBASET;
01223         std::string::size_type _saveIndex;
01224         
01225         match("thickbase");
01226         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01227            _token = makeToken(_ttype);
01228            _token->setText(text.substr(_begin, text.length()-_begin));
01229         }
01230         _returnToken = _token;
01231         _saveIndex=0;
01232 }
01233 
01234 void MTAnisoGAConfLexer::mTHICKSTEPT(bool _createToken) {
01235         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01236         _ttype = THICKSTEPT;
01237         std::string::size_type _saveIndex;
01238         
01239         match("thickstep");
01240         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01241            _token = makeToken(_ttype);
01242            _token->setText(text.substr(_begin, text.length()-_begin));
01243         }
01244         _returnToken = _token;
01245         _saveIndex=0;
01246 }
01247 
01248 void MTAnisoGAConfLexer::mTHICKSIZEST(bool _createToken) {
01249         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01250         _ttype = THICKSIZEST;
01251         std::string::size_type _saveIndex;
01252         
01253         match("thicksizes");
01254         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01255            _token = makeToken(_ttype);
01256            _token->setText(text.substr(_begin, text.length()-_begin));
01257         }
01258         _returnToken = _token;
01259         _saveIndex=0;
01260 }
01261 
01262 void MTAnisoGAConfLexer::mRESBASET(bool _createToken) {
01263         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01264         _ttype = RESBASET;
01265         std::string::size_type _saveIndex;
01266         
01267         match("resbase");
01268         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01269            _token = makeToken(_ttype);
01270            _token->setText(text.substr(_begin, text.length()-_begin));
01271         }
01272         _returnToken = _token;
01273         _saveIndex=0;
01274 }
01275 
01276 void MTAnisoGAConfLexer::mRESSTEPT(bool _createToken) {
01277         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01278         _ttype = RESSTEPT;
01279         std::string::size_type _saveIndex;
01280         
01281         match("resstep");
01282         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01283            _token = makeToken(_ttype);
01284            _token->setText(text.substr(_begin, text.length()-_begin));
01285         }
01286         _returnToken = _token;
01287         _saveIndex=0;
01288 }
01289 
01290 void MTAnisoGAConfLexer::mRESSIZEST(bool _createToken) {
01291         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01292         _ttype = RESSIZEST;
01293         std::string::size_type _saveIndex;
01294         
01295         match("ressizes");
01296         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01297            _token = makeToken(_ttype);
01298            _token->setText(text.substr(_begin, text.length()-_begin));
01299         }
01300         _returnToken = _token;
01301         _saveIndex=0;
01302 }
01303 
01304 void MTAnisoGAConfLexer::mANISOBASET(bool _createToken) {
01305         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01306         _ttype = ANISOBASET;
01307         std::string::size_type _saveIndex;
01308         
01309         match("anisobase");
01310         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01311            _token = makeToken(_ttype);
01312            _token->setText(text.substr(_begin, text.length()-_begin));
01313         }
01314         _returnToken = _token;
01315         _saveIndex=0;
01316 }
01317 
01318 void MTAnisoGAConfLexer::mANISOSTEPT(bool _createToken) {
01319         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01320         _ttype = ANISOSTEPT;
01321         std::string::size_type _saveIndex;
01322         
01323         match("anisostep");
01324         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01325            _token = makeToken(_ttype);
01326            _token->setText(text.substr(_begin, text.length()-_begin));
01327         }
01328         _returnToken = _token;
01329         _saveIndex=0;
01330 }
01331 
01332 void MTAnisoGAConfLexer::mANISOSIZEST(bool _createToken) {
01333         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01334         _ttype = ANISOSIZEST;
01335         std::string::size_type _saveIndex;
01336         
01337         match("anisosizes");
01338         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01339            _token = makeToken(_ttype);
01340            _token->setText(text.substr(_begin, text.length()-_begin));
01341         }
01342         _returnToken = _token;
01343         _saveIndex=0;
01344 }
01345 
01346 void MTAnisoGAConfLexer::mSTRIKEBASET(bool _createToken) {
01347         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01348         _ttype = STRIKEBASET;
01349         std::string::size_type _saveIndex;
01350         
01351         match("strikebase");
01352         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01353            _token = makeToken(_ttype);
01354            _token->setText(text.substr(_begin, text.length()-_begin));
01355         }
01356         _returnToken = _token;
01357         _saveIndex=0;
01358 }
01359 
01360 void MTAnisoGAConfLexer::mSTRIKESTEPT(bool _createToken) {
01361         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01362         _ttype = STRIKESTEPT;
01363         std::string::size_type _saveIndex;
01364         
01365         match("strikestep");
01366         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01367            _token = makeToken(_ttype);
01368            _token->setText(text.substr(_begin, text.length()-_begin));
01369         }
01370         _returnToken = _token;
01371         _saveIndex=0;
01372 }
01373 
01374 void MTAnisoGAConfLexer::mSTRIKESIZEST(bool _createToken) {
01375         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01376         _ttype = STRIKESIZEST;
01377         std::string::size_type _saveIndex;
01378         
01379         match("strikesizes");
01380         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01381            _token = makeToken(_ttype);
01382            _token->setText(text.substr(_begin, text.length()-_begin));
01383         }
01384         _returnToken = _token;
01385         _saveIndex=0;
01386 }
01387 
01388 void MTAnisoGAConfLexer::mWEIGHTST(bool _createToken) {
01389         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01390         _ttype = WEIGHTST;
01391         std::string::size_type _saveIndex;
01392         
01393         match("weights");
01394         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01395            _token = makeToken(_ttype);
01396            _token->setText(text.substr(_begin, text.length()-_begin));
01397         }
01398         _returnToken = _token;
01399         _saveIndex=0;
01400 }
01401 
01402 void MTAnisoGAConfLexer::mCONDDIFFWEIGHTT(bool _createToken) {
01403         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01404         _ttype = CONDDIFFWEIGHTT;
01405         std::string::size_type _saveIndex;
01406         
01407         match("conddiffweight");
01408         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01409            _token = makeToken(_ttype);
01410            _token->setText(text.substr(_begin, text.length()-_begin));
01411         }
01412         _returnToken = _token;
01413         _saveIndex=0;
01414 }
01415 
01416 void MTAnisoGAConfLexer::mANISOTROPYWEIGHTT(bool _createToken) {
01417         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01418         _ttype = ANISOTROPYWEIGHTT;
01419         std::string::size_type _saveIndex;
01420         
01421         match("anisotropyweight");
01422         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01423            _token = makeToken(_ttype);
01424            _token->setText(text.substr(_begin, text.length()-_begin));
01425         }
01426         _returnToken = _token;
01427         _saveIndex=0;
01428 }
01429 
01430 void MTAnisoGAConfLexer::mSTRIKEDIFFWEIGHTT(bool _createToken) {
01431         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01432         _ttype = STRIKEDIFFWEIGHTT;
01433         std::string::size_type _saveIndex;
01434         
01435         match("strikediffweight");
01436         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01437            _token = makeToken(_ttype);
01438            _token->setText(text.substr(_begin, text.length()-_begin));
01439         }
01440         _returnToken = _token;
01441         _saveIndex=0;
01442 }
01443 
01444 
01445 const unsigned long MTAnisoGAConfLexer::_tokenSet_0_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL };
01446 // . 0 1 2 3 4 5 6 
01447 const antlr::BitSet MTAnisoGAConfLexer::_tokenSet_0(_tokenSet_0_data_,6);
01448 const unsigned long MTAnisoGAConfLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
01449 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
01450 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
01451 // \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 
01452 const antlr::BitSet MTAnisoGAConfLexer::_tokenSet_1(_tokenSet_1_data_,8);
01453
Generated on Thu Nov 22 13:58:26 2007 for GPLIB++ by  doxygen 1.5.1