GPLIB++: MTAnisoGAConfLexer Class Reference

MTAnisoGAConfLexer::MTAnisoGAConfLexer ( std::istream & in )

Definition at line 13 of file MTAnisoGAConfLexer.cpp.

00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }

MTAnisoGAConfLexer::MTAnisoGAConfLexer ( antlr::InputBuffer & ib )

Definition at line 19 of file MTAnisoGAConfLexer.cpp.

00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }

MTAnisoGAConfLexer::MTAnisoGAConfLexer ( const antlr::LexerSharedInputState & state )

Definition at line 25 of file MTAnisoGAConfLexer.cpp.

00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }

bool MTAnisoGAConfLexer::getCaseSensitiveLiterals ( ) const [inline]

Definition at line 25 of file MTAnisoGAConfLexer.hpp.

00026         {
00027                 return true;
00028         }

antlr::RefToken MTAnisoGAConfLexer::nextToken ( )

Definition at line 35 of file MTAnisoGAConfLexer.cpp.

References mANISOBASET(), mANISOSIZEST(), mANISOSTEPT(), mANISOTROPYWEIGHTT(), mANNEALINGGENERATIONT(), mCOMMENT(), mCONDDIFFWEIGHTT(), mCOOLINGRATIOT(), mCROSSOVERPROBT(), mELITISTT(), mENDTIMET(), mEQUAL(), mFALSE(), mGATYPET(), mGENERATIONST(), mINITTEMPT(), mMODET(), mMTFITEXPONENTT(), mMTFITT(), mMTINPUTDATAT(), mMUTATIONPROBT(), mNUMBER(), mOUTPUTBASET(), mPHASEERRORT(), mPOPSIZET(), mPTENSORDATAT(), mRESBASET(), mRESERRORT(), mRESSIZEST(), mRESSTEPT(), mSTARTTIMET(), mSTRIKEBASET(), mSTRIKEDIFFWEIGHTT(), mSTRIKESIZEST(), mSTRIKESTEPT(), mSTRING(), mTENSORERRORT(), mTHICKBASET(), mTHICKSIZEST(), mTHICKSTEPT(), mTHREADST(), mTRUE(), mVERBOSET(), mWEIGHTST(), and mWS().

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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mEQUAL ( bool _createToken )

Definition at line 278 of file MTAnisoGAConfLexer.cpp.

References EQUAL.

Referenced by nextToken().

00278                                                  {
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 }

void MTAnisoGAConfLexer::mTRUE ( bool _createToken )

Definition at line 292 of file MTAnisoGAConfLexer.cpp.

References TRUE.

Referenced by nextToken().

00292                                                 {
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 }

void MTAnisoGAConfLexer::mFALSE ( bool _createToken )

Definition at line 306 of file MTAnisoGAConfLexer.cpp.

References FALSE.

Referenced by nextToken().

00306                                                  {
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 }

void MTAnisoGAConfLexer::mWS ( bool _createToken )

Definition at line 320 of file MTAnisoGAConfLexer.cpp.

References mNEWLINE(), and WS.

Referenced by nextToken().

00320                                               {
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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mNEWLINE ( bool _createToken ) [protected]

Definition at line 367 of file MTAnisoGAConfLexer.cpp.

References NEWLINE.

Referenced by mCOMMENT(), and mWS().

00367                                                    {
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 }

void MTAnisoGAConfLexer::mSTRING ( bool _createToken )

Definition at line 404 of file MTAnisoGAConfLexer.cpp.

References mCHAR(), mDIGIT(), mOTHER(), and STRING.

Referenced by nextToken().

00404                                                   {
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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mCHAR ( bool _createToken ) [protected]

Definition at line 504 of file MTAnisoGAConfLexer.cpp.

References CHAR.

Referenced by mSTRING().

00504                                                 {
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 }

void MTAnisoGAConfLexer::mDIGIT ( bool _createToken ) [protected]

Definition at line 520 of file MTAnisoGAConfLexer.cpp.

References DIGIT.

Referenced by mINT(), and mSTRING().

00520                                                  {
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 }

void MTAnisoGAConfLexer::mOTHER ( bool _createToken ) [protected]

Definition at line 534 of file MTAnisoGAConfLexer.cpp.

References OTHER.

Referenced by mSTRING().

00534                                                  {
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 }

void MTAnisoGAConfLexer::mNUMBER ( bool _createToken )

Definition at line 683 of file MTAnisoGAConfLexer.cpp.

References mINT(), mREAL(), and NUMBER.

Referenced by nextToken().

00683                                                   {
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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mREAL ( bool _createToken ) [protected]

Definition at line 798 of file MTAnisoGAConfLexer.cpp.

References mINT(), and REAL.

Referenced by mNUMBER().

00798                                                 {
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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mINT ( bool _createToken ) [protected]

Definition at line 848 of file MTAnisoGAConfLexer.cpp.

References INT, and mDIGIT().

Referenced by mNUMBER(), and mREAL().

00848                                                {
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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mCOMMENT ( bool _createToken )

Definition at line 875 of file MTAnisoGAConfLexer.cpp.

References COMMENT, and mNEWLINE().

Referenced by nextToken().

00875                                                    {
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 }

Here is the call graph for this function:

void MTAnisoGAConfLexer::mVERBOSET ( bool _createToken )

Definition at line 912 of file MTAnisoGAConfLexer.cpp.

References VERBOSET.

Referenced by nextToken().

00912                                                     {
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 }

void MTAnisoGAConfLexer::mMTFITEXPONENTT ( bool _createToken )

Definition at line 926 of file MTAnisoGAConfLexer.cpp.

References MTFITEXPONENTT.

Referenced by nextToken().

00926                                                           {
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 }

void MTAnisoGAConfLexer::mPOPSIZET ( bool _createToken )

Definition at line 940 of file MTAnisoGAConfLexer.cpp.

References POPSIZET.

Referenced by nextToken().

00940                                                     {
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 }

void MTAnisoGAConfLexer::mINITTEMPT ( bool _createToken )

Definition at line 954 of file MTAnisoGAConfLexer.cpp.

References INITTEMPT.

Referenced by nextToken().

00954                                                      {
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 }

void MTAnisoGAConfLexer::mCOOLINGRATIOT ( bool _createToken )

Definition at line 968 of file MTAnisoGAConfLexer.cpp.

References COOLINGRATIOT.

Referenced by nextToken().

00968                                                          {
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 }

void MTAnisoGAConfLexer::mGENERATIONST ( bool _createToken )

Definition at line 982 of file MTAnisoGAConfLexer.cpp.

References GENERATIONST.

Referenced by nextToken().

00982                                                         {
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 }

void MTAnisoGAConfLexer::mMUTATIONPROBT ( bool _createToken )

Definition at line 996 of file MTAnisoGAConfLexer.cpp.

References MUTATIONPROBT.

Referenced by nextToken().

00996                                                          {
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 }

void MTAnisoGAConfLexer::mCROSSOVERPROBT ( bool _createToken )

Definition at line 1010 of file MTAnisoGAConfLexer.cpp.

References CROSSOVERPROBT.

Referenced by nextToken().

01010                                                           {
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 }

void MTAnisoGAConfLexer::mTHREADST ( bool _createToken )

Definition at line 1024 of file MTAnisoGAConfLexer.cpp.

References THREADST.

Referenced by nextToken().

01024                                                     {
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 }

void MTAnisoGAConfLexer::mSTARTTIMET ( bool _createToken )

Definition at line 1038 of file MTAnisoGAConfLexer.cpp.

References STARTTIMET.

Referenced by nextToken().

01038                                                       {
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 }

void MTAnisoGAConfLexer::mENDTIMET ( bool _createToken )

Definition at line 1052 of file MTAnisoGAConfLexer.cpp.

References ENDTIMET.

Referenced by nextToken().

01052                                                     {
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 }

void MTAnisoGAConfLexer::mTENSORERRORT ( bool _createToken )

Definition at line 1066 of file MTAnisoGAConfLexer.cpp.

References TENSORERRORT.

Referenced by nextToken().

01066                                                         {
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 }

void MTAnisoGAConfLexer::mRESERRORT ( bool _createToken )

Definition at line 1080 of file MTAnisoGAConfLexer.cpp.

References RESERRORT.

Referenced by nextToken().

01080                                                      {
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 }

void MTAnisoGAConfLexer::mPHASEERRORT ( bool _createToken )

Definition at line 1094 of file MTAnisoGAConfLexer.cpp.

References PHASEERRORT.

Referenced by nextToken().

01094                                                        {
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 }

void MTAnisoGAConfLexer::mGATYPET ( bool _createToken )

Definition at line 1108 of file MTAnisoGAConfLexer.cpp.

References GATYPET.

Referenced by nextToken().

01108                                                    {
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 }

void MTAnisoGAConfLexer::mOUTPUTBASET ( bool _createToken )

Definition at line 1122 of file MTAnisoGAConfLexer.cpp.

References OUTPUTBASET.

Referenced by nextToken().

01122                                                        {
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 }

void MTAnisoGAConfLexer::mMODET ( bool _createToken )

Definition at line 1136 of file MTAnisoGAConfLexer.cpp.

References MODET.

Referenced by nextToken().

01136                                                  {
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 }

void MTAnisoGAConfLexer::mMTFITT ( bool _createToken )

Definition at line 1150 of file MTAnisoGAConfLexer.cpp.

References MTFITT.

Referenced by nextToken().

01150                                                   {
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 }

void MTAnisoGAConfLexer::mMTINPUTDATAT ( bool _createToken )

Definition at line 1164 of file MTAnisoGAConfLexer.cpp.

References MTINPUTDATAT.

Referenced by nextToken().

01164                                                         {
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 }

void MTAnisoGAConfLexer::mPTENSORDATAT ( bool _createToken )

Definition at line 1178 of file MTAnisoGAConfLexer.cpp.

References PTENSORDATAT.

Referenced by nextToken().

01178                                                         {
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 }

void MTAnisoGAConfLexer::mANNEALINGGENERATIONT ( bool _createToken )

Definition at line 1192 of file MTAnisoGAConfLexer.cpp.

References ANNEALINGGENERATIONT.

Referenced by nextToken().

01192                                                                 {
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 }

void MTAnisoGAConfLexer::mELITISTT ( bool _createToken )

Definition at line 1206 of file MTAnisoGAConfLexer.cpp.

References ELITISTT.

Referenced by nextToken().

01206                                                     {
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 }

void MTAnisoGAConfLexer::mTHICKBASET ( bool _createToken )

Definition at line 1220 of file MTAnisoGAConfLexer.cpp.

References THICKBASET.

Referenced by nextToken().

01220                                                       {
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 }

void MTAnisoGAConfLexer::mTHICKSTEPT ( bool _createToken )

Definition at line 1234 of file MTAnisoGAConfLexer.cpp.

References THICKSTEPT.

Referenced by nextToken().

01234                                                       {
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 }

void MTAnisoGAConfLexer::mTHICKSIZEST ( bool _createToken )

Definition at line 1248 of file MTAnisoGAConfLexer.cpp.

References THICKSIZEST.

Referenced by nextToken().

01248                                                        {
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 }

void MTAnisoGAConfLexer::mRESBASET ( bool _createToken )

Definition at line 1262 of file MTAnisoGAConfLexer.cpp.

References RESBASET.

Referenced by nextToken().

01262                                                     {
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 }

void MTAnisoGAConfLexer::mRESSTEPT ( bool _createToken )

Definition at line 1276 of file MTAnisoGAConfLexer.cpp.

References RESSTEPT.

Referenced by nextToken().

01276                                                     {
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 }

void MTAnisoGAConfLexer::mRESSIZEST ( bool _createToken )

Definition at line 1290 of file MTAnisoGAConfLexer.cpp.

References RESSIZEST.

Referenced by nextToken().

01290                                                      {
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 }

void MTAnisoGAConfLexer::mANISOBASET ( bool _createToken )

Definition at line 1304 of file MTAnisoGAConfLexer.cpp.

References ANISOBASET.

Referenced by nextToken().

01304                                                       {
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 }

void MTAnisoGAConfLexer::mANISOSTEPT ( bool _createToken )

Definition at line 1318 of file MTAnisoGAConfLexer.cpp.

References ANISOSTEPT.

Referenced by nextToken().

01318                                                       {
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 }

void MTAnisoGAConfLexer::mANISOSIZEST ( bool _createToken )

Definition at line 1332 of file MTAnisoGAConfLexer.cpp.

References ANISOSIZEST.

Referenced by nextToken().

01332                                                        {
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 }

void MTAnisoGAConfLexer::mSTRIKEBASET ( bool _createToken )

Definition at line 1346 of file MTAnisoGAConfLexer.cpp.

References STRIKEBASET.

Referenced by nextToken().

01346                                                        {
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 }

void MTAnisoGAConfLexer::mSTRIKESTEPT ( bool _createToken )

Definition at line 1360 of file MTAnisoGAConfLexer.cpp.

References STRIKESTEPT.

Referenced by nextToken().

01360                                                        {
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 }

void MTAnisoGAConfLexer::mSTRIKESIZEST ( bool _createToken )

Definition at line 1374 of file MTAnisoGAConfLexer.cpp.

References STRIKESIZEST.

Referenced by nextToken().

01374                                                         {
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 }

void MTAnisoGAConfLexer::mWEIGHTST ( bool _createToken )

Definition at line 1388 of file MTAnisoGAConfLexer.cpp.

References WEIGHTST.

Referenced by nextToken().

01388                                                     {
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 }

void MTAnisoGAConfLexer::mCONDDIFFWEIGHTT ( bool _createToken )

Definition at line 1402 of file MTAnisoGAConfLexer.cpp.

References CONDDIFFWEIGHTT.

Referenced by nextToken().

01402                                                            {
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 }

void MTAnisoGAConfLexer::mANISOTROPYWEIGHTT ( bool _createToken )

Definition at line 1416 of file MTAnisoGAConfLexer.cpp.

References ANISOTROPYWEIGHTT.

Referenced by nextToken().

01416                                                              {
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 }

void MTAnisoGAConfLexer::mSTRIKEDIFFWEIGHTT ( bool _createToken )

Definition at line 1430 of file MTAnisoGAConfLexer.cpp.

References STRIKEDIFFWEIGHTT.

Referenced by nextToken().

01430                                                              {
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 }


Public Member Functions
bool	getCaseSensitiveLiterals () const
	MTAnisoGAConfLexer (std::istream &in)
	MTAnisoGAConfLexer (antlr::InputBuffer &ib)
	MTAnisoGAConfLexer (const antlr::LexerSharedInputState &state)
antlr::RefToken	nextToken ()
void	mEQUAL (bool _createToken)
void	mTRUE (bool _createToken)
void	mFALSE (bool _createToken)
void	mWS (bool _createToken)
void	mSTRING (bool _createToken)
void	mNUMBER (bool _createToken)
void	mCOMMENT (bool _createToken)
void	mVERBOSET (bool _createToken)
void	mMTFITEXPONENTT (bool _createToken)
void	mPOPSIZET (bool _createToken)
void	mINITTEMPT (bool _createToken)
void	mCOOLINGRATIOT (bool _createToken)
void	mGENERATIONST (bool _createToken)
void	mMUTATIONPROBT (bool _createToken)
void	mCROSSOVERPROBT (bool _createToken)
void	mTHREADST (bool _createToken)
void	mSTARTTIMET (bool _createToken)
void	mENDTIMET (bool _createToken)
void	mTENSORERRORT (bool _createToken)
void	mRESERRORT (bool _createToken)
void	mPHASEERRORT (bool _createToken)
void	mGATYPET (bool _createToken)
void	mOUTPUTBASET (bool _createToken)
void	mMODET (bool _createToken)
void	mMTFITT (bool _createToken)
void	mMTINPUTDATAT (bool _createToken)
void	mPTENSORDATAT (bool _createToken)
void	mANNEALINGGENERATIONT (bool _createToken)
void	mELITISTT (bool _createToken)
void	mTHICKBASET (bool _createToken)
void	mTHICKSTEPT (bool _createToken)
void	mTHICKSIZEST (bool _createToken)
void	mRESBASET (bool _createToken)
void	mRESSTEPT (bool _createToken)
void	mRESSIZEST (bool _createToken)
void	mANISOBASET (bool _createToken)
void	mANISOSTEPT (bool _createToken)
void	mANISOSIZEST (bool _createToken)
void	mSTRIKEBASET (bool _createToken)
void	mSTRIKESTEPT (bool _createToken)
void	mSTRIKESIZEST (bool _createToken)
void	mWEIGHTST (bool _createToken)
void	mCONDDIFFWEIGHTT (bool _createToken)
void	mANISOTROPYWEIGHTT (bool _createToken)
void	mSTRIKEDIFFWEIGHTT (bool _createToken)
Protected Member Functions
void	mNEWLINE (bool _createToken)
void	mCHAR (bool _createToken)
void	mDIGIT (bool _createToken)
void	mOTHER (bool _createToken)
void	mREAL (bool _createToken)
void	mINT (bool _createToken)

MTAnisoGAConfLexer Class Reference

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation