GPLIB++: C1dInvGaConfLexer Class Reference

C1dInvGaConfLexer::C1dInvGaConfLexer ( std::istream & in )

Definition at line 13 of file C1dInvGaConfLexer.cpp.

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

C1dInvGaConfLexer::C1dInvGaConfLexer ( antlr::InputBuffer & ib )

Definition at line 19 of file C1dInvGaConfLexer.cpp.

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

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

Definition at line 25 of file C1dInvGaConfLexer.cpp.

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

bool C1dInvGaConfLexer::getCaseSensitiveLiterals ( ) const [inline]

Definition at line 25 of file C1dInvGaConfLexer.hpp.

00026         {
00027                 return true;
00028         }

antlr::RefToken C1dInvGaConfLexer::nextToken ( )

Definition at line 35 of file C1dInvGaConfLexer.cpp.

References mABSVELWEIGHTT(), mANNEALINGGENERATIONT(), mCCT(), mCOMMENT(), mCOOLINGRATIOT(), mCROSSOVERPROBT(), mELITISTT(), mENDTIMET(), mEQUAL(), mFALSE(), mGATYPET(), mGENERATIONST(), mINITTEMPT(), mMODET(), mMTFITEXPONENTT(), mMTFITT(), mMTINPUTDATAT(), mMUTATIONPROBT(), mNUMBER(), mOMEGAT(), mOUTPUTBASET(), mPHASEERRORT(), mPOISSONT(), mPOPSIZET(), mRECERRORT(), mRECFITEXPONENTT(), mRECINPUTDATAT(), mRECMETHODT(), mRECWEIGHTT(), mRESBASET(), mRESERRORT(), mRESSIZEST(), mRESSTEPT(), mRFABSVELDATAT(), mSHIFTT(), mSIGMAT(), mSLOWNESST(), mSTARTTIMET(), mSTRING(), mSVELBASET(), mSVELSIZEST(), mSVELSTEPT(), mTENSORERRORT(), mTHICKBASET(), mTHICKSIZEST(), mTHICKSTEPT(), mTHREADST(), mTRUE(), mUSEVREFMODELT(), mVERBOSET(), mVREFMODELT(), 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) == 0x75 /* 'u' */ ) && (LA(2) == 0x73 /* 's' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x76 /* 'v' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x66 /* 'f' */ ) && (LA(8) == 0x6d /* 'm' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x64 /* 'd' */ )) {
00085                                         mUSEVREFMODELT(true);
00086                                         theRetToken=_returnToken;
00087                                 }
00088                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x66 /* 'f' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x78 /* 'x' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00089                                         mMTFITEXPONENTT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x78 /* 'x' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
00093                                         mRECFITEXPONENTT(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x6e /* 'n' */ ) && (LA(7) == 0x67 /* 'g' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00097                                         mCOOLINGRATIOT(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 else if ((LA(1) == 0x67 /* 'g' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00101                                         mGENERATIONST(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x61 /* 'a' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (LA(10) == 0x72 /* 'r' */ )) {
00105                                         mMUTATIONPROBT(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x76 /* 'v' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x72 /* 'r' */ ) && (LA(10) == 0x70 /* 'p' */ )) {
00109                                         mCROSSOVERPROBT(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x72 /* 'r' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
00113                                         mTENSORERRORT(true);
00114                                         theRetToken=_returnToken;
00115                                 }
00116                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x72 /* 'r' */ )) {
00117                                         mPHASEERRORT(true);
00118                                         theRetToken=_returnToken;
00119                                 }
00120                                 else if ((LA(1) == 0x6f /* 'o' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x70 /* 'p' */ ) && (LA(5) == 0x75 /* 'u' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x62 /* 'b' */ ) && (LA(8) == 0x61 /* 'a' */ ) && (LA(9) == 0x73 /* 's' */ ) && (LA(10) == 0x65 /* 'e' */ )) {
00121                                         mOUTPUTBASET(true);
00122                                         theRetToken=_returnToken;
00123                                 }
00124                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x6e /* 'n' */ ) && (LA(5) == 0x70 /* 'p' */ ) && (LA(6) == 0x75 /* 'u' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x64 /* 'd' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00125                                         mMTINPUTDATAT(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x6e /* 'n' */ ) && (LA(6) == 0x70 /* 'p' */ ) && (LA(7) == 0x75 /* 'u' */ ) && (LA(8) == 0x74 /* 't' */ ) && (LA(9) == 0x64 /* 'd' */ ) && (LA(10) == 0x61 /* 'a' */ )) {
00129                                         mRECINPUTDATAT(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x66 /* 'f' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x76 /* 'v' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x6c /* 'l' */ ) && (LA(9) == 0x64 /* 'd' */ ) && (LA(10) == 0x61 /* 'a' */ )) {
00133                                         mRFABSVELDATAT(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x67 /* 'g' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
00137                                         mANNEALINGGENERATIONT(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x7a /* 'z' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x73 /* 's' */ )) {
00141                                         mTHICKSIZEST(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x62 /* 'b' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x76 /* 'v' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x77 /* 'w' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x69 /* 'i' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
00145                                         mABSVELWEIGHTT(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 else if ((LA(1) == 0x76 /* 'v' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x6d /* 'm' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x64 /* 'd' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x6c /* 'l' */ ) && (true)) {
00149                                         mVREFMODELT(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6d /* 'm' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00153                                         mSTARTTIMET(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x6d /* 'm' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x68 /* 'h' */ ) && (LA(8) == 0x6f /* 'o' */ ) && (LA(9) == 0x64 /* 'd' */ ) && (true)) {
00157                                         mRECMETHODT(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x62 /* 'b' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x73 /* 's' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00161                                         mTHICKBASET(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (true)) {
00165                                         mTHICKSTEPT(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x7a /* 'z' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x73 /* 's' */ ) && (true)) {
00169                                         mSVELSIZEST(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x77 /* 'w' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x67 /* 'g' */ ) && (LA(8) == 0x68 /* 'h' */ ) && (LA(9) == 0x74 /* 't' */ ) && (true)) {
00173                                         mRECWEIGHTT(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if ((LA(1) == 0x69 /* 'i' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x6d /* 'm' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (true) && (true)) {
00177                                         mINITTEMPT(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x77 /* 'w' */ ) && (LA(5) == 0x6e /* 'n' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x73 /* 's' */ ) && (true) && (true)) {
00181                                         mSLOWNESST(true);
00182                                         theRetToken=_returnToken;
00183                                 }
00184                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (true) && (true)) {
00185                                         mRESERRORT(true);
00186                                         theRetToken=_returnToken;
00187                                 }
00188                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x63 /* 'c' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (true) && (true)) {
00189                                         mRECERRORT(true);
00190                                         theRetToken=_returnToken;
00191                                 }
00192                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x7a /* 'z' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x73 /* 's' */ ) && (true) && (true)) {
00193                                         mRESSIZEST(true);
00194                                         theRetToken=_returnToken;
00195                                 }
00196                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x62 /* 'b' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (true) && (true)) {
00197                                         mSVELBASET(true);
00198                                         theRetToken=_returnToken;
00199                                 }
00200                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (true) && (true)) {
00201                                         mSVELSTEPT(true);
00202                                         theRetToken=_returnToken;
00203                                 }
00204                                 else if ((LA(1) == 0x76 /* 'v' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00205                                         mVERBOSET(true);
00206                                         theRetToken=_returnToken;
00207                                 }
00208                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x70 /* 'p' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x7a /* 'z' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00209                                         mPOPSIZET(true);
00210                                         theRetToken=_returnToken;
00211                                 }
00212                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x6e /* 'n' */ ) && (true) && (true) && (true)) {
00213                                         mPOISSONT(true);
00214                                         theRetToken=_returnToken;
00215                                 }
00216                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x64 /* 'd' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00217                                         mTHREADST(true);
00218                                         theRetToken=_returnToken;
00219                                 }
00220                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x6d /* 'm' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00221                                         mENDTIMET(true);
00222                                         theRetToken=_returnToken;
00223                                 }
00224                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (true) && (true) && (true)) {
00225                                         mELITISTT(true);
00226                                         theRetToken=_returnToken;
00227                                 }
00228                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00229                                         mRESBASET(true);
00230                                         theRetToken=_returnToken;
00231                                 }
00232                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x73 /* 's' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x70 /* 'p' */ ) && (true) && (true) && (true)) {
00233                                         mRESSTEPT(true);
00234                                         theRetToken=_returnToken;
00235                                 }
00236                                 else if ((LA(1) == 0x77 /* 'w' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x67 /* 'g' */ ) && (LA(5) == 0x68 /* 'h' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00237                                         mWEIGHTST(true);
00238                                         theRetToken=_returnToken;
00239                                 }
00240                                 else if ((LA(1) == 0x67 /* 'g' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x79 /* 'y' */ ) && (LA(5) == 0x70 /* 'p' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true)) {
00241                                         mGATYPET(true);
00242                                         theRetToken=_returnToken;
00243                                 }
00244                                 else if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true)) {
00245                                         mFALSE(true);
00246                                         theRetToken=_returnToken;
00247                                 }
00248                                 else if ((LA(1) == 0x6f /* 'o' */ ) && (LA(2) == 0x6d /* 'm' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x67 /* 'g' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (true) && (true) && (true) && (true) && (true)) {
00249                                         mOMEGAT(true);
00250                                         theRetToken=_returnToken;
00251                                 }
00252                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x67 /* 'g' */ ) && (LA(4) == 0x6d /* 'm' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (true) && (true) && (true) && (true) && (true)) {
00253                                         mSIGMAT(true);
00254                                         theRetToken=_returnToken;
00255                                 }
00256                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true)) {
00257                                         mSHIFTT(true);
00258                                         theRetToken=_returnToken;
00259                                 }
00260                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x66 /* 'f' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true)) {
00261                                         mMTFITT(true);
00262                                         theRetToken=_returnToken;
00263                                 }
00264                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00265                                         mTRUE(true);
00266                                         theRetToken=_returnToken;
00267                                 }
00268                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00269                                         mMODET(true);
00270                                         theRetToken=_returnToken;
00271                                 }
00272                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x63 /* 'c' */ ) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00273                                         mCCT(true);
00274                                         theRetToken=_returnToken;
00275                                 }
00276                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00277                                         mSTRING(true);
00278                                         theRetToken=_returnToken;
00279                                 }
00280                         else {
00281                                 if (LA(1)==EOF_CHAR)
00282                                 {
00283                                         uponEOF();
00284                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00285                                 }
00286                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00287                         }
00288                         }
00289                         if ( !_returnToken )
00290                                 goto tryAgain; // found SKIP token
00291 
00292                         _ttype = _returnToken->getType();
00293                         _ttype = testLiteralsTable(_ttype);
00294                         _returnToken->setType(_ttype);
00295                         return _returnToken;
00296                 }
00297                 catch (antlr::RecognitionException& e) {
00298                                 throw antlr::TokenStreamRecognitionException(e);
00299                 }
00300                 catch (antlr::CharStreamIOException& csie) {
00301                         throw antlr::TokenStreamIOException(csie.io);
00302                 }
00303                 catch (antlr::CharStreamException& cse) {
00304                         throw antlr::TokenStreamException(cse.getMessage());
00305                 }
00306 tryAgain:;
00307         }
00308 }

Here is the call graph for this function:

void C1dInvGaConfLexer::mEQUAL ( bool _createToken )

Definition at line 310 of file C1dInvGaConfLexer.cpp.

References EQUAL.

Referenced by nextToken().

00310                                                 {
00311         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00312         _ttype = EQUAL;
00313         std::string::size_type _saveIndex;
00314         
00315         match('=' /* charlit */ );
00316         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00317            _token = makeToken(_ttype);
00318            _token->setText(text.substr(_begin, text.length()-_begin));
00319         }
00320         _returnToken = _token;
00321         _saveIndex=0;
00322 }

void C1dInvGaConfLexer::mTRUE ( bool _createToken )

Definition at line 324 of file C1dInvGaConfLexer.cpp.

References TRUE.

Referenced by nextToken().

00324                                                {
00325         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00326         _ttype = TRUE;
00327         std::string::size_type _saveIndex;
00328         
00329         match("true");
00330         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00331            _token = makeToken(_ttype);
00332            _token->setText(text.substr(_begin, text.length()-_begin));
00333         }
00334         _returnToken = _token;
00335         _saveIndex=0;
00336 }

void C1dInvGaConfLexer::mFALSE ( bool _createToken )

Definition at line 338 of file C1dInvGaConfLexer.cpp.

References FALSE.

Referenced by nextToken().

00338                                                 {
00339         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00340         _ttype = FALSE;
00341         std::string::size_type _saveIndex;
00342         
00343         match("false");
00344         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00345            _token = makeToken(_ttype);
00346            _token->setText(text.substr(_begin, text.length()-_begin));
00347         }
00348         _returnToken = _token;
00349         _saveIndex=0;
00350 }

void C1dInvGaConfLexer::mWS ( bool _createToken )

Definition at line 352 of file C1dInvGaConfLexer.cpp.

References mNEWLINE(), and WS.

Referenced by nextToken().

00352                                              {
00353         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00354         _ttype = WS;
00355         std::string::size_type _saveIndex;
00356         
00357         { // ( ... )+
00358         int _cnt216=0;
00359         for (;;) {
00360                 switch ( LA(1)) {
00361                 case 0x20 /* ' ' */ :
00362                 {
00363                         match(' ' /* charlit */ );
00364                         break;
00365                 }
00366                 case 0xa /* '\n' */ :
00367                 case 0xd /* '\r' */ :
00368                 {
00369                         mNEWLINE(false);
00370                         break;
00371                 }
00372                 case 0x9 /* '\t' */ :
00373                 {
00374                         match('\t' /* charlit */ );
00375                         break;
00376                 }
00377                 default:
00378                 {
00379                         if ( _cnt216>=1 ) { goto _loop216; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00380                 }
00381                 }
00382                 _cnt216++;
00383         }
00384         _loop216:;
00385         }  // ( ... )+
00386         if ( inputState->guessing==0 ) {
00387 #line 168 "C1dInvGaConf.g"
00388                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00389 #line 390 "C1dInvGaConfLexer.cpp"
00390         }
00391         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00392            _token = makeToken(_ttype);
00393            _token->setText(text.substr(_begin, text.length()-_begin));
00394         }
00395         _returnToken = _token;
00396         _saveIndex=0;
00397 }

Here is the call graph for this function:

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

Definition at line 399 of file C1dInvGaConfLexer.cpp.

References NEWLINE.

Referenced by mCOMMENT(), and mWS().

00399                                                   {
00400         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00401         _ttype = NEWLINE;
00402         std::string::size_type _saveIndex;
00403         
00404         {
00405         switch ( LA(1)) {
00406         case 0xa /* '\n' */ :
00407         {
00408                 match('\n' /* charlit */ );
00409                 break;
00410         }
00411         case 0xd /* '\r' */ :
00412         {
00413                 match('\r' /* charlit */ );
00414                 match('\n' /* charlit */ );
00415                 break;
00416         }
00417         default:
00418         {
00419                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00420         }
00421         }
00422         }
00423         if ( inputState->guessing==0 ) {
00424 #line 194 "C1dInvGaConf.g"
00425                 newline();
00426 #line 427 "C1dInvGaConfLexer.cpp"
00427         }
00428         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00429            _token = makeToken(_ttype);
00430            _token->setText(text.substr(_begin, text.length()-_begin));
00431         }
00432         _returnToken = _token;
00433         _saveIndex=0;
00434 }

void C1dInvGaConfLexer::mSTRING ( bool _createToken )

Definition at line 436 of file C1dInvGaConfLexer.cpp.

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

Referenced by nextToken().

00436                                                  {
00437         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00438         _ttype = STRING;
00439         std::string::size_type _saveIndex;
00440         
00441         mCHAR(false);
00442         { // ( ... )*
00443         for (;;) {
00444                 switch ( LA(1)) {
00445                 case 0x61 /* 'a' */ :
00446                 case 0x62 /* 'b' */ :
00447                 case 0x63 /* 'c' */ :
00448                 case 0x64 /* 'd' */ :
00449                 case 0x65 /* 'e' */ :
00450                 case 0x66 /* 'f' */ :
00451                 case 0x67 /* 'g' */ :
00452                 case 0x68 /* 'h' */ :
00453                 case 0x69 /* 'i' */ :
00454                 case 0x6a /* 'j' */ :
00455                 case 0x6b /* 'k' */ :
00456                 case 0x6c /* 'l' */ :
00457                 case 0x6d /* 'm' */ :
00458                 case 0x6e /* 'n' */ :
00459                 case 0x6f /* 'o' */ :
00460                 case 0x70 /* 'p' */ :
00461                 case 0x71 /* 'q' */ :
00462                 case 0x72 /* 'r' */ :
00463                 case 0x73 /* 's' */ :
00464                 case 0x74 /* 't' */ :
00465                 case 0x75 /* 'u' */ :
00466                 case 0x76 /* 'v' */ :
00467                 case 0x77 /* 'w' */ :
00468                 case 0x78 /* 'x' */ :
00469                 case 0x79 /* 'y' */ :
00470                 case 0x7a /* 'z' */ :
00471                 {
00472                         mCHAR(false);
00473                         break;
00474                 }
00475                 case 0x30 /* '0' */ :
00476                 case 0x31 /* '1' */ :
00477                 case 0x32 /* '2' */ :
00478                 case 0x33 /* '3' */ :
00479                 case 0x34 /* '4' */ :
00480                 case 0x35 /* '5' */ :
00481                 case 0x36 /* '6' */ :
00482                 case 0x37 /* '7' */ :
00483                 case 0x38 /* '8' */ :
00484                 case 0x39 /* '9' */ :
00485                 {
00486                         mDIGIT(false);
00487                         break;
00488                 }
00489                 case 0x23 /* '#' */ :
00490                 case 0x24 /* '$' */ :
00491                 case 0x25 /* '%' */ :
00492                 case 0x26 /* '&' */ :
00493                 case 0x27 /* '\'' */ :
00494                 case 0x28 /* '(' */ :
00495                 case 0x29 /* ')' */ :
00496                 case 0x2a /* '*' */ :
00497                 case 0x2b /* '+' */ :
00498                 case 0x2c /* ',' */ :
00499                 case 0x2d /* '-' */ :
00500                 case 0x2e /* '.' */ :
00501                 case 0x2f /* '/' */ :
00502                 case 0x3a /* ':' */ :
00503                 case 0x3b /* ';' */ :
00504                 case 0x3c /* '<' */ :
00505                 case 0x3f /* '?' */ :
00506                 case 0x40 /* '@' */ :
00507                 case 0x5b /* '[' */ :
00508                 case 0x5d /* ']' */ :
00509                 case 0x5e /* '^' */ :
00510                 case 0x5f /* '_' */ :
00511                 case 0x7b /* '{' */ :
00512                 case 0x7c /* '|' */ :
00513                 case 0x7d /* '}' */ :
00514                 case 0x7e /* '~' */ :
00515                 {
00516                         mOTHER(false);
00517                         break;
00518                 }
00519                 default:
00520                 {
00521                         goto _loop219;
00522                 }
00523                 }
00524         }
00525         _loop219:;
00526         } // ( ... )*
00527         _ttype = testLiteralsTable(_ttype);
00528         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00529            _token = makeToken(_ttype);
00530            _token->setText(text.substr(_begin, text.length()-_begin));
00531         }
00532         _returnToken = _token;
00533         _saveIndex=0;
00534 }

Here is the call graph for this function:

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

Definition at line 536 of file C1dInvGaConfLexer.cpp.

References CHAR.

Referenced by mSTRING().

00536                                                {
00537         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00538         _ttype = CHAR;
00539         std::string::size_type _saveIndex;
00540         
00541         {
00542         matchRange('a','z');
00543         }
00544         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00545            _token = makeToken(_ttype);
00546            _token->setText(text.substr(_begin, text.length()-_begin));
00547         }
00548         _returnToken = _token;
00549         _saveIndex=0;
00550 }

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

Definition at line 552 of file C1dInvGaConfLexer.cpp.

References DIGIT.

Referenced by mINT(), and mSTRING().

00552                                                 {
00553         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00554         _ttype = DIGIT;
00555         std::string::size_type _saveIndex;
00556         
00557         matchRange('0','9');
00558         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00559            _token = makeToken(_ttype);
00560            _token->setText(text.substr(_begin, text.length()-_begin));
00561         }
00562         _returnToken = _token;
00563         _saveIndex=0;
00564 }

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

Definition at line 566 of file C1dInvGaConfLexer.cpp.

References OTHER.

Referenced by mSTRING().

00566                                                 {
00567         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00568         _ttype = OTHER;
00569         std::string::size_type _saveIndex;
00570         
00571         switch ( LA(1)) {
00572         case 0x27 /* '\'' */ :
00573         {
00574                 match('\'' /* charlit */ );
00575                 break;
00576         }
00577         case 0x23 /* '#' */ :
00578         {
00579                 match('#' /* charlit */ );
00580                 break;
00581         }
00582         case 0x24 /* '$' */ :
00583         {
00584                 match('$' /* charlit */ );
00585                 break;
00586         }
00587         case 0x25 /* '%' */ :
00588         {
00589                 match('%' /* charlit */ );
00590                 break;
00591         }
00592         case 0x26 /* '&' */ :
00593         {
00594                 match('&' /* charlit */ );
00595                 break;
00596         }
00597         case 0x28 /* '(' */ :
00598         {
00599                 match('(' /* charlit */ );
00600                 break;
00601         }
00602         case 0x29 /* ')' */ :
00603         {
00604                 match(')' /* charlit */ );
00605                 break;
00606         }
00607         case 0x2a /* '*' */ :
00608         {
00609                 match('*' /* charlit */ );
00610                 break;
00611         }
00612         case 0x2b /* '+' */ :
00613         {
00614                 match('+' /* charlit */ );
00615                 break;
00616         }
00617         case 0x2c /* ',' */ :
00618         {
00619                 match(',' /* charlit */ );
00620                 break;
00621         }
00622         case 0x2d /* '-' */ :
00623         {
00624                 match('-' /* charlit */ );
00625                 break;
00626         }
00627         case 0x2e /* '.' */ :
00628         {
00629                 match('.' /* charlit */ );
00630                 break;
00631         }
00632         case 0x2f /* '/' */ :
00633         {
00634                 match('/' /* charlit */ );
00635                 break;
00636         }
00637         case 0x3a /* ':' */ :
00638         {
00639                 match(':' /* charlit */ );
00640                 break;
00641         }
00642         case 0x3b /* ';' */ :
00643         {
00644                 match(';' /* charlit */ );
00645                 break;
00646         }
00647         case 0x3c /* '<' */ :
00648         {
00649                 match('<' /* charlit */ );
00650                 break;
00651         }
00652         case 0x3f /* '?' */ :
00653         {
00654                 match('?' /* charlit */ );
00655                 break;
00656         }
00657         case 0x40 /* '@' */ :
00658         {
00659                 match('@' /* charlit */ );
00660                 break;
00661         }
00662         case 0x5b /* '[' */ :
00663         {
00664                 match('[' /* charlit */ );
00665                 break;
00666         }
00667         case 0x5d /* ']' */ :
00668         {
00669                 match(']' /* charlit */ );
00670                 break;
00671         }
00672         case 0x5e /* '^' */ :
00673         {
00674                 match('^' /* charlit */ );
00675                 break;
00676         }
00677         case 0x5f /* '_' */ :
00678         {
00679                 match('_' /* charlit */ );
00680                 break;
00681         }
00682         case 0x7b /* '{' */ :
00683         {
00684                 match('{' /* charlit */ );
00685                 break;
00686         }
00687         case 0x7c /* '|' */ :
00688         {
00689                 match('|' /* charlit */ );
00690                 break;
00691         }
00692         case 0x7d /* '}' */ :
00693         {
00694                 match('}' /* charlit */ );
00695                 break;
00696         }
00697         case 0x7e /* '~' */ :
00698         {
00699                 match('~' /* charlit */ );
00700                 break;
00701         }
00702         default:
00703         {
00704                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00705         }
00706         }
00707         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00708            _token = makeToken(_ttype);
00709            _token->setText(text.substr(_begin, text.length()-_begin));
00710         }
00711         _returnToken = _token;
00712         _saveIndex=0;
00713 }

void C1dInvGaConfLexer::mNUMBER ( bool _createToken )

Definition at line 715 of file C1dInvGaConfLexer.cpp.

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

Referenced by nextToken().

00715                                                  {
00716         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00717         _ttype = NUMBER;
00718         std::string::size_type _saveIndex;
00719         
00720         {
00721         switch ( LA(1)) {
00722         case 0x2b /* '+' */ :
00723         {
00724                 match('+' /* charlit */ );
00725                 break;
00726         }
00727         case 0x2d /* '-' */ :
00728         {
00729                 match('-' /* charlit */ );
00730                 break;
00731         }
00732         case 0x2e /* '.' */ :
00733         case 0x30 /* '0' */ :
00734         case 0x31 /* '1' */ :
00735         case 0x32 /* '2' */ :
00736         case 0x33 /* '3' */ :
00737         case 0x34 /* '4' */ :
00738         case 0x35 /* '5' */ :
00739         case 0x36 /* '6' */ :
00740         case 0x37 /* '7' */ :
00741         case 0x38 /* '8' */ :
00742         case 0x39 /* '9' */ :
00743         {
00744                 break;
00745         }
00746         default:
00747         {
00748                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00749         }
00750         }
00751         }
00752         {
00753         bool synPredMatched224 = false;
00754         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00755                 int _m224 = mark();
00756                 synPredMatched224 = true;
00757                 inputState->guessing++;
00758                 try {
00759                         {
00760                         mREAL(false);
00761                         }
00762                 }
00763                 catch (antlr::RecognitionException& pe) {
00764                         synPredMatched224 = false;
00765                 }
00766                 rewind(_m224);
00767                 inputState->guessing--;
00768         }
00769         if ( synPredMatched224 ) {
00770                 mREAL(false);
00771         }
00772         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00773                 mINT(false);
00774         }
00775         else {
00776                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00777         }
00778         
00779         }
00780         {
00781         if ((LA(1) == 0x65 /* 'e' */ )) {
00782                 {
00783                 match('e' /* charlit */ );
00784                 }
00785                 {
00786                 switch ( LA(1)) {
00787                 case 0x2b /* '+' */ :
00788                 {
00789                         match('+' /* charlit */ );
00790                         break;
00791                 }
00792                 case 0x2d /* '-' */ :
00793                 {
00794                         match('-' /* charlit */ );
00795                         break;
00796                 }
00797                 case 0x30 /* '0' */ :
00798                 case 0x31 /* '1' */ :
00799                 case 0x32 /* '2' */ :
00800                 case 0x33 /* '3' */ :
00801                 case 0x34 /* '4' */ :
00802                 case 0x35 /* '5' */ :
00803                 case 0x36 /* '6' */ :
00804                 case 0x37 /* '7' */ :
00805                 case 0x38 /* '8' */ :
00806                 case 0x39 /* '9' */ :
00807                 {
00808                         break;
00809                 }
00810                 default:
00811                 {
00812                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00813                 }
00814                 }
00815                 }
00816                 mINT(false);
00817         }
00818         else {
00819         }
00820         
00821         }
00822         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00823            _token = makeToken(_ttype);
00824            _token->setText(text.substr(_begin, text.length()-_begin));
00825         }
00826         _returnToken = _token;
00827         _saveIndex=0;
00828 }

Here is the call graph for this function:

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

Definition at line 830 of file C1dInvGaConfLexer.cpp.

References mINT(), and REAL.

Referenced by mNUMBER().

00830                                                {
00831         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00832         _ttype = REAL;
00833         std::string::size_type _saveIndex;
00834         
00835         {
00836         switch ( LA(1)) {
00837         case 0x2e /* '.' */ :
00838         {
00839                 match('.' /* charlit */ );
00840                 mINT(false);
00841                 break;
00842         }
00843         case 0x30 /* '0' */ :
00844         case 0x31 /* '1' */ :
00845         case 0x32 /* '2' */ :
00846         case 0x33 /* '3' */ :
00847         case 0x34 /* '4' */ :
00848         case 0x35 /* '5' */ :
00849         case 0x36 /* '6' */ :
00850         case 0x37 /* '7' */ :
00851         case 0x38 /* '8' */ :
00852         case 0x39 /* '9' */ :
00853         {
00854                 mINT(false);
00855                 match('.' /* charlit */ );
00856                 {
00857                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00858                         mINT(false);
00859                 }
00860                 else {
00861                 }
00862                 
00863                 }
00864                 break;
00865         }
00866         default:
00867         {
00868                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00869         }
00870         }
00871         }
00872         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00873            _token = makeToken(_ttype);
00874            _token->setText(text.substr(_begin, text.length()-_begin));
00875         }
00876         _returnToken = _token;
00877         _saveIndex=0;
00878 }

Here is the call graph for this function:

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

Definition at line 880 of file C1dInvGaConfLexer.cpp.

References INT, and mDIGIT().

Referenced by mNUMBER(), and mREAL().

00880                                               {
00881         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00882         _ttype = INT;
00883         std::string::size_type _saveIndex;
00884         
00885         { // ( ... )+
00886         int _cnt239=0;
00887         for (;;) {
00888                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00889                         mDIGIT(false);
00890                 }
00891                 else {
00892                         if ( _cnt239>=1 ) { goto _loop239; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00893                 }
00894                 
00895                 _cnt239++;
00896         }
00897         _loop239:;
00898         }  // ( ... )+
00899         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00900            _token = makeToken(_ttype);
00901            _token->setText(text.substr(_begin, text.length()-_begin));
00902         }
00903         _returnToken = _token;
00904         _saveIndex=0;
00905 }

Here is the call graph for this function:

void C1dInvGaConfLexer::mCOMMENT ( bool _createToken )

Definition at line 907 of file C1dInvGaConfLexer.cpp.

References COMMENT, and mNEWLINE().

Referenced by nextToken().

00907                                                   {
00908         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00909         _ttype = COMMENT;
00910         std::string::size_type _saveIndex;
00911         
00912         match('/' /* charlit */ );
00913         match('/' /* charlit */ );
00914         { // ( ... )*
00915         for (;;) {
00916                 if ((_tokenSet_1.member(LA(1)))) {
00917                         {
00918                         match(_tokenSet_1);
00919                         }
00920                 }
00921                 else {
00922                         goto _loop231;
00923                 }
00924                 
00925         }
00926         _loop231:;
00927         } // ( ... )*
00928         mNEWLINE(false);
00929         if ( inputState->guessing==0 ) {
00930 #line 185 "C1dInvGaConf.g"
00931                 
00932                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00933                                 
00934 #line 935 "C1dInvGaConfLexer.cpp"
00935         }
00936         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00937            _token = makeToken(_ttype);
00938            _token->setText(text.substr(_begin, text.length()-_begin));
00939         }
00940         _returnToken = _token;
00941         _saveIndex=0;
00942 }

Here is the call graph for this function:

void C1dInvGaConfLexer::mVERBOSET ( bool _createToken )

Definition at line 944 of file C1dInvGaConfLexer.cpp.

References VERBOSET.

Referenced by nextToken().

00944                                                    {
00945         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00946         _ttype = VERBOSET;
00947         std::string::size_type _saveIndex;
00948         
00949         match("verbose");
00950         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00951            _token = makeToken(_ttype);
00952            _token->setText(text.substr(_begin, text.length()-_begin));
00953         }
00954         _returnToken = _token;
00955         _saveIndex=0;
00956 }

void C1dInvGaConfLexer::mUSEVREFMODELT ( bool _createToken )

Definition at line 958 of file C1dInvGaConfLexer.cpp.

References USEVREFMODELT.

Referenced by nextToken().

00958                                                         {
00959         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00960         _ttype = USEVREFMODELT;
00961         std::string::size_type _saveIndex;
00962         
00963         match("usevrefmodel");
00964         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00965            _token = makeToken(_ttype);
00966            _token->setText(text.substr(_begin, text.length()-_begin));
00967         }
00968         _returnToken = _token;
00969         _saveIndex=0;
00970 }

void C1dInvGaConfLexer::mVREFMODELT ( bool _createToken )

Definition at line 972 of file C1dInvGaConfLexer.cpp.

References VREFMODELT.

Referenced by nextToken().

00972                                                      {
00973         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00974         _ttype = VREFMODELT;
00975         std::string::size_type _saveIndex;
00976         
00977         match("vrefmodel");
00978         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00979            _token = makeToken(_ttype);
00980            _token->setText(text.substr(_begin, text.length()-_begin));
00981         }
00982         _returnToken = _token;
00983         _saveIndex=0;
00984 }

void C1dInvGaConfLexer::mMTFITEXPONENTT ( bool _createToken )

Definition at line 986 of file C1dInvGaConfLexer.cpp.

References MTFITEXPONENTT.

Referenced by nextToken().

00986                                                          {
00987         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00988         _ttype = MTFITEXPONENTT;
00989         std::string::size_type _saveIndex;
00990         
00991         match("mtfitexponent");
00992         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00993            _token = makeToken(_ttype);
00994            _token->setText(text.substr(_begin, text.length()-_begin));
00995         }
00996         _returnToken = _token;
00997         _saveIndex=0;
00998 }

void C1dInvGaConfLexer::mRECFITEXPONENTT ( bool _createToken )

Definition at line 1000 of file C1dInvGaConfLexer.cpp.

References RECFITEXPONENTT.

Referenced by nextToken().

01000                                                           {
01001         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01002         _ttype = RECFITEXPONENTT;
01003         std::string::size_type _saveIndex;
01004         
01005         match("recfitexponent");
01006         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01007            _token = makeToken(_ttype);
01008            _token->setText(text.substr(_begin, text.length()-_begin));
01009         }
01010         _returnToken = _token;
01011         _saveIndex=0;
01012 }

void C1dInvGaConfLexer::mPOPSIZET ( bool _createToken )

Definition at line 1014 of file C1dInvGaConfLexer.cpp.

References POPSIZET.

Referenced by nextToken().

01014                                                    {
01015         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01016         _ttype = POPSIZET;
01017         std::string::size_type _saveIndex;
01018         
01019         match("popsize");
01020         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01021            _token = makeToken(_ttype);
01022            _token->setText(text.substr(_begin, text.length()-_begin));
01023         }
01024         _returnToken = _token;
01025         _saveIndex=0;
01026 }

void C1dInvGaConfLexer::mINITTEMPT ( bool _createToken )

Definition at line 1028 of file C1dInvGaConfLexer.cpp.

References INITTEMPT.

Referenced by nextToken().

01028                                                     {
01029         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01030         _ttype = INITTEMPT;
01031         std::string::size_type _saveIndex;
01032         
01033         match("inittemp");
01034         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01035            _token = makeToken(_ttype);
01036            _token->setText(text.substr(_begin, text.length()-_begin));
01037         }
01038         _returnToken = _token;
01039         _saveIndex=0;
01040 }

void C1dInvGaConfLexer::mCOOLINGRATIOT ( bool _createToken )

Definition at line 1042 of file C1dInvGaConfLexer.cpp.

References COOLINGRATIOT.

Referenced by nextToken().

01042                                                         {
01043         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01044         _ttype = COOLINGRATIOT;
01045         std::string::size_type _saveIndex;
01046         
01047         match("coolingratio");
01048         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01049            _token = makeToken(_ttype);
01050            _token->setText(text.substr(_begin, text.length()-_begin));
01051         }
01052         _returnToken = _token;
01053         _saveIndex=0;
01054 }

void C1dInvGaConfLexer::mGENERATIONST ( bool _createToken )

Definition at line 1056 of file C1dInvGaConfLexer.cpp.

References GENERATIONST.

Referenced by nextToken().

01056                                                        {
01057         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01058         _ttype = GENERATIONST;
01059         std::string::size_type _saveIndex;
01060         
01061         match("generations");
01062         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01063            _token = makeToken(_ttype);
01064            _token->setText(text.substr(_begin, text.length()-_begin));
01065         }
01066         _returnToken = _token;
01067         _saveIndex=0;
01068 }

void C1dInvGaConfLexer::mMUTATIONPROBT ( bool _createToken )

Definition at line 1070 of file C1dInvGaConfLexer.cpp.

References MUTATIONPROBT.

Referenced by nextToken().

01070                                                         {
01071         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01072         _ttype = MUTATIONPROBT;
01073         std::string::size_type _saveIndex;
01074         
01075         match("mutationprob");
01076         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01077            _token = makeToken(_ttype);
01078            _token->setText(text.substr(_begin, text.length()-_begin));
01079         }
01080         _returnToken = _token;
01081         _saveIndex=0;
01082 }

void C1dInvGaConfLexer::mCROSSOVERPROBT ( bool _createToken )

Definition at line 1084 of file C1dInvGaConfLexer.cpp.

References CROSSOVERPROBT.

Referenced by nextToken().

01084                                                          {
01085         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01086         _ttype = CROSSOVERPROBT;
01087         std::string::size_type _saveIndex;
01088         
01089         match("crossoverprob");
01090         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01091            _token = makeToken(_ttype);
01092            _token->setText(text.substr(_begin, text.length()-_begin));
01093         }
01094         _returnToken = _token;
01095         _saveIndex=0;
01096 }

void C1dInvGaConfLexer::mSLOWNESST ( bool _createToken )

Definition at line 1098 of file C1dInvGaConfLexer.cpp.

References SLOWNESST.

Referenced by nextToken().

01098                                                     {
01099         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01100         _ttype = SLOWNESST;
01101         std::string::size_type _saveIndex;
01102         
01103         match("slowness");
01104         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01105            _token = makeToken(_ttype);
01106            _token->setText(text.substr(_begin, text.length()-_begin));
01107         }
01108         _returnToken = _token;
01109         _saveIndex=0;
01110 }

void C1dInvGaConfLexer::mOMEGAT ( bool _createToken )

Definition at line 1112 of file C1dInvGaConfLexer.cpp.

References OMEGAT.

Referenced by nextToken().

01112                                                  {
01113         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01114         _ttype = OMEGAT;
01115         std::string::size_type _saveIndex;
01116         
01117         match("omega");
01118         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01119            _token = makeToken(_ttype);
01120            _token->setText(text.substr(_begin, text.length()-_begin));
01121         }
01122         _returnToken = _token;
01123         _saveIndex=0;
01124 }

void C1dInvGaConfLexer::mSIGMAT ( bool _createToken )

Definition at line 1126 of file C1dInvGaConfLexer.cpp.

References SIGMAT.

Referenced by nextToken().

01126                                                  {
01127         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01128         _ttype = SIGMAT;
01129         std::string::size_type _saveIndex;
01130         
01131         match("sigma");
01132         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01133            _token = makeToken(_ttype);
01134            _token->setText(text.substr(_begin, text.length()-_begin));
01135         }
01136         _returnToken = _token;
01137         _saveIndex=0;
01138 }

void C1dInvGaConfLexer::mSHIFTT ( bool _createToken )

Definition at line 1140 of file C1dInvGaConfLexer.cpp.

References SHIFTT.

Referenced by nextToken().

01140                                                  {
01141         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01142         _ttype = SHIFTT;
01143         std::string::size_type _saveIndex;
01144         
01145         match("shift");
01146         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01147            _token = makeToken(_ttype);
01148            _token->setText(text.substr(_begin, text.length()-_begin));
01149         }
01150         _returnToken = _token;
01151         _saveIndex=0;
01152 }

void C1dInvGaConfLexer::mCCT ( bool _createToken )

Definition at line 1154 of file C1dInvGaConfLexer.cpp.

References CCT.

Referenced by nextToken().

01154                                               {
01155         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01156         _ttype = CCT;
01157         std::string::size_type _saveIndex;
01158         
01159         match("cc");
01160         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01161            _token = makeToken(_ttype);
01162            _token->setText(text.substr(_begin, text.length()-_begin));
01163         }
01164         _returnToken = _token;
01165         _saveIndex=0;
01166 }

void C1dInvGaConfLexer::mPOISSONT ( bool _createToken )

Definition at line 1168 of file C1dInvGaConfLexer.cpp.

References POISSONT.

Referenced by nextToken().

01168                                                    {
01169         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01170         _ttype = POISSONT;
01171         std::string::size_type _saveIndex;
01172         
01173         match("poisson");
01174         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01175            _token = makeToken(_ttype);
01176            _token->setText(text.substr(_begin, text.length()-_begin));
01177         }
01178         _returnToken = _token;
01179         _saveIndex=0;
01180 }

void C1dInvGaConfLexer::mTHREADST ( bool _createToken )

Definition at line 1182 of file C1dInvGaConfLexer.cpp.

References THREADST.

Referenced by nextToken().

01182                                                    {
01183         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01184         _ttype = THREADST;
01185         std::string::size_type _saveIndex;
01186         
01187         match("threads");
01188         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01189            _token = makeToken(_ttype);
01190            _token->setText(text.substr(_begin, text.length()-_begin));
01191         }
01192         _returnToken = _token;
01193         _saveIndex=0;
01194 }

void C1dInvGaConfLexer::mSTARTTIMET ( bool _createToken )

Definition at line 1196 of file C1dInvGaConfLexer.cpp.

References STARTTIMET.

Referenced by nextToken().

01196                                                      {
01197         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01198         _ttype = STARTTIMET;
01199         std::string::size_type _saveIndex;
01200         
01201         match("starttime");
01202         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01203            _token = makeToken(_ttype);
01204            _token->setText(text.substr(_begin, text.length()-_begin));
01205         }
01206         _returnToken = _token;
01207         _saveIndex=0;
01208 }

void C1dInvGaConfLexer::mENDTIMET ( bool _createToken )

Definition at line 1210 of file C1dInvGaConfLexer.cpp.

References ENDTIMET.

Referenced by nextToken().

01210                                                    {
01211         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01212         _ttype = ENDTIMET;
01213         std::string::size_type _saveIndex;
01214         
01215         match("endtime");
01216         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01217            _token = makeToken(_ttype);
01218            _token->setText(text.substr(_begin, text.length()-_begin));
01219         }
01220         _returnToken = _token;
01221         _saveIndex=0;
01222 }

void C1dInvGaConfLexer::mTENSORERRORT ( bool _createToken )

Definition at line 1224 of file C1dInvGaConfLexer.cpp.

References TENSORERRORT.

Referenced by nextToken().

01224                                                        {
01225         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01226         _ttype = TENSORERRORT;
01227         std::string::size_type _saveIndex;
01228         
01229         match("tensorerror");
01230         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01231            _token = makeToken(_ttype);
01232            _token->setText(text.substr(_begin, text.length()-_begin));
01233         }
01234         _returnToken = _token;
01235         _saveIndex=0;
01236 }

void C1dInvGaConfLexer::mRESERRORT ( bool _createToken )

Definition at line 1238 of file C1dInvGaConfLexer.cpp.

References RESERRORT.

Referenced by nextToken().

01238                                                     {
01239         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01240         _ttype = RESERRORT;
01241         std::string::size_type _saveIndex;
01242         
01243         match("reserror");
01244         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01245            _token = makeToken(_ttype);
01246            _token->setText(text.substr(_begin, text.length()-_begin));
01247         }
01248         _returnToken = _token;
01249         _saveIndex=0;
01250 }

void C1dInvGaConfLexer::mPHASEERRORT ( bool _createToken )

Definition at line 1252 of file C1dInvGaConfLexer.cpp.

References PHASEERRORT.

Referenced by nextToken().

01252                                                       {
01253         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01254         _ttype = PHASEERRORT;
01255         std::string::size_type _saveIndex;
01256         
01257         match("phaseerror");
01258         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01259            _token = makeToken(_ttype);
01260            _token->setText(text.substr(_begin, text.length()-_begin));
01261         }
01262         _returnToken = _token;
01263         _saveIndex=0;
01264 }

void C1dInvGaConfLexer::mRECERRORT ( bool _createToken )

Definition at line 1266 of file C1dInvGaConfLexer.cpp.

References RECERRORT.

Referenced by nextToken().

01266                                                     {
01267         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01268         _ttype = RECERRORT;
01269         std::string::size_type _saveIndex;
01270         
01271         match("recerror");
01272         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01273            _token = makeToken(_ttype);
01274            _token->setText(text.substr(_begin, text.length()-_begin));
01275         }
01276         _returnToken = _token;
01277         _saveIndex=0;
01278 }

void C1dInvGaConfLexer::mRECMETHODT ( bool _createToken )

Definition at line 1280 of file C1dInvGaConfLexer.cpp.

References RECMETHODT.

Referenced by nextToken().

01280                                                      {
01281         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01282         _ttype = RECMETHODT;
01283         std::string::size_type _saveIndex;
01284         
01285         match("recmethod");
01286         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01287            _token = makeToken(_ttype);
01288            _token->setText(text.substr(_begin, text.length()-_begin));
01289         }
01290         _returnToken = _token;
01291         _saveIndex=0;
01292 }

void C1dInvGaConfLexer::mGATYPET ( bool _createToken )

Definition at line 1294 of file C1dInvGaConfLexer.cpp.

References GATYPET.

Referenced by nextToken().

01294                                                   {
01295         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01296         _ttype = GATYPET;
01297         std::string::size_type _saveIndex;
01298         
01299         match("gatype");
01300         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01301            _token = makeToken(_ttype);
01302            _token->setText(text.substr(_begin, text.length()-_begin));
01303         }
01304         _returnToken = _token;
01305         _saveIndex=0;
01306 }

void C1dInvGaConfLexer::mOUTPUTBASET ( bool _createToken )

Definition at line 1308 of file C1dInvGaConfLexer.cpp.

References OUTPUTBASET.

Referenced by nextToken().

01308                                                       {
01309         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01310         _ttype = OUTPUTBASET;
01311         std::string::size_type _saveIndex;
01312         
01313         match("outputbase");
01314         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01315            _token = makeToken(_ttype);
01316            _token->setText(text.substr(_begin, text.length()-_begin));
01317         }
01318         _returnToken = _token;
01319         _saveIndex=0;
01320 }

void C1dInvGaConfLexer::mMODET ( bool _createToken )

Definition at line 1322 of file C1dInvGaConfLexer.cpp.

References MODET.

Referenced by nextToken().

01322                                                 {
01323         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01324         _ttype = MODET;
01325         std::string::size_type _saveIndex;
01326         
01327         match("mode");
01328         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01329            _token = makeToken(_ttype);
01330            _token->setText(text.substr(_begin, text.length()-_begin));
01331         }
01332         _returnToken = _token;
01333         _saveIndex=0;
01334 }

void C1dInvGaConfLexer::mMTFITT ( bool _createToken )

Definition at line 1336 of file C1dInvGaConfLexer.cpp.

References MTFITT.

Referenced by nextToken().

01336                                                  {
01337         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01338         _ttype = MTFITT;
01339         std::string::size_type _saveIndex;
01340         
01341         match("mtfit");
01342         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01343            _token = makeToken(_ttype);
01344            _token->setText(text.substr(_begin, text.length()-_begin));
01345         }
01346         _returnToken = _token;
01347         _saveIndex=0;
01348 }

void C1dInvGaConfLexer::mMTINPUTDATAT ( bool _createToken )

Definition at line 1350 of file C1dInvGaConfLexer.cpp.

References MTINPUTDATAT.

Referenced by nextToken().

01350                                                        {
01351         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01352         _ttype = MTINPUTDATAT;
01353         std::string::size_type _saveIndex;
01354         
01355         match("mtinputdata");
01356         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01357            _token = makeToken(_ttype);
01358            _token->setText(text.substr(_begin, text.length()-_begin));
01359         }
01360         _returnToken = _token;
01361         _saveIndex=0;
01362 }

void C1dInvGaConfLexer::mRECINPUTDATAT ( bool _createToken )

Definition at line 1364 of file C1dInvGaConfLexer.cpp.

References RECINPUTDATAT.

Referenced by nextToken().

01364                                                         {
01365         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01366         _ttype = RECINPUTDATAT;
01367         std::string::size_type _saveIndex;
01368         
01369         match("recinputdata");
01370         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01371            _token = makeToken(_ttype);
01372            _token->setText(text.substr(_begin, text.length()-_begin));
01373         }
01374         _returnToken = _token;
01375         _saveIndex=0;
01376 }

void C1dInvGaConfLexer::mRFABSVELDATAT ( bool _createToken )

Definition at line 1378 of file C1dInvGaConfLexer.cpp.

References RFABSVELDATAT.

Referenced by nextToken().

01378                                                         {
01379         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01380         _ttype = RFABSVELDATAT;
01381         std::string::size_type _saveIndex;
01382         
01383         match("rfabsveldata");
01384         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01385            _token = makeToken(_ttype);
01386            _token->setText(text.substr(_begin, text.length()-_begin));
01387         }
01388         _returnToken = _token;
01389         _saveIndex=0;
01390 }

void C1dInvGaConfLexer::mANNEALINGGENERATIONT ( bool _createToken )

Definition at line 1392 of file C1dInvGaConfLexer.cpp.

References ANNEALINGGENERATIONT.

Referenced by nextToken().

01392                                                                {
01393         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01394         _ttype = ANNEALINGGENERATIONT;
01395         std::string::size_type _saveIndex;
01396         
01397         match("annealinggeneration");
01398         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01399            _token = makeToken(_ttype);
01400            _token->setText(text.substr(_begin, text.length()-_begin));
01401         }
01402         _returnToken = _token;
01403         _saveIndex=0;
01404 }

void C1dInvGaConfLexer::mELITISTT ( bool _createToken )

Definition at line 1406 of file C1dInvGaConfLexer.cpp.

References ELITISTT.

Referenced by nextToken().

01406                                                    {
01407         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01408         _ttype = ELITISTT;
01409         std::string::size_type _saveIndex;
01410         
01411         match("elitist");
01412         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01413            _token = makeToken(_ttype);
01414            _token->setText(text.substr(_begin, text.length()-_begin));
01415         }
01416         _returnToken = _token;
01417         _saveIndex=0;
01418 }

void C1dInvGaConfLexer::mTHICKBASET ( bool _createToken )

Definition at line 1420 of file C1dInvGaConfLexer.cpp.

References THICKBASET.

Referenced by nextToken().

01420                                                      {
01421         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01422         _ttype = THICKBASET;
01423         std::string::size_type _saveIndex;
01424         
01425         match("thickbase");
01426         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01427            _token = makeToken(_ttype);
01428            _token->setText(text.substr(_begin, text.length()-_begin));
01429         }
01430         _returnToken = _token;
01431         _saveIndex=0;
01432 }

void C1dInvGaConfLexer::mTHICKSTEPT ( bool _createToken )

Definition at line 1434 of file C1dInvGaConfLexer.cpp.

References THICKSTEPT.

Referenced by nextToken().

01434                                                      {
01435         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01436         _ttype = THICKSTEPT;
01437         std::string::size_type _saveIndex;
01438         
01439         match("thickstep");
01440         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01441            _token = makeToken(_ttype);
01442            _token->setText(text.substr(_begin, text.length()-_begin));
01443         }
01444         _returnToken = _token;
01445         _saveIndex=0;
01446 }

void C1dInvGaConfLexer::mTHICKSIZEST ( bool _createToken )

Definition at line 1448 of file C1dInvGaConfLexer.cpp.

References THICKSIZEST.

Referenced by nextToken().

01448                                                       {
01449         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01450         _ttype = THICKSIZEST;
01451         std::string::size_type _saveIndex;
01452         
01453         match("thicksizes");
01454         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01455            _token = makeToken(_ttype);
01456            _token->setText(text.substr(_begin, text.length()-_begin));
01457         }
01458         _returnToken = _token;
01459         _saveIndex=0;
01460 }

void C1dInvGaConfLexer::mRESBASET ( bool _createToken )

Definition at line 1462 of file C1dInvGaConfLexer.cpp.

References RESBASET.

Referenced by nextToken().

01462                                                    {
01463         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01464         _ttype = RESBASET;
01465         std::string::size_type _saveIndex;
01466         
01467         match("resbase");
01468         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01469            _token = makeToken(_ttype);
01470            _token->setText(text.substr(_begin, text.length()-_begin));
01471         }
01472         _returnToken = _token;
01473         _saveIndex=0;
01474 }

void C1dInvGaConfLexer::mRESSTEPT ( bool _createToken )

Definition at line 1476 of file C1dInvGaConfLexer.cpp.

References RESSTEPT.

Referenced by nextToken().

01476                                                    {
01477         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01478         _ttype = RESSTEPT;
01479         std::string::size_type _saveIndex;
01480         
01481         match("resstep");
01482         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01483            _token = makeToken(_ttype);
01484            _token->setText(text.substr(_begin, text.length()-_begin));
01485         }
01486         _returnToken = _token;
01487         _saveIndex=0;
01488 }

void C1dInvGaConfLexer::mRESSIZEST ( bool _createToken )

Definition at line 1490 of file C1dInvGaConfLexer.cpp.

References RESSIZEST.

Referenced by nextToken().

01490                                                     {
01491         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01492         _ttype = RESSIZEST;
01493         std::string::size_type _saveIndex;
01494         
01495         match("ressizes");
01496         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01497            _token = makeToken(_ttype);
01498            _token->setText(text.substr(_begin, text.length()-_begin));
01499         }
01500         _returnToken = _token;
01501         _saveIndex=0;
01502 }

void C1dInvGaConfLexer::mSVELBASET ( bool _createToken )

Definition at line 1504 of file C1dInvGaConfLexer.cpp.

References SVELBASET.

Referenced by nextToken().

01504                                                     {
01505         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01506         _ttype = SVELBASET;
01507         std::string::size_type _saveIndex;
01508         
01509         match("svelbase");
01510         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01511            _token = makeToken(_ttype);
01512            _token->setText(text.substr(_begin, text.length()-_begin));
01513         }
01514         _returnToken = _token;
01515         _saveIndex=0;
01516 }

void C1dInvGaConfLexer::mSVELSTEPT ( bool _createToken )

Definition at line 1518 of file C1dInvGaConfLexer.cpp.

References SVELSTEPT.

Referenced by nextToken().

01518                                                     {
01519         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01520         _ttype = SVELSTEPT;
01521         std::string::size_type _saveIndex;
01522         
01523         match("svelstep");
01524         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01525            _token = makeToken(_ttype);
01526            _token->setText(text.substr(_begin, text.length()-_begin));
01527         }
01528         _returnToken = _token;
01529         _saveIndex=0;
01530 }

void C1dInvGaConfLexer::mSVELSIZEST ( bool _createToken )

Definition at line 1532 of file C1dInvGaConfLexer.cpp.

References SVELSIZEST.

Referenced by nextToken().

01532                                                      {
01533         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01534         _ttype = SVELSIZEST;
01535         std::string::size_type _saveIndex;
01536         
01537         match("svelsizes");
01538         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01539            _token = makeToken(_ttype);
01540            _token->setText(text.substr(_begin, text.length()-_begin));
01541         }
01542         _returnToken = _token;
01543         _saveIndex=0;
01544 }

void C1dInvGaConfLexer::mWEIGHTST ( bool _createToken )

Definition at line 1546 of file C1dInvGaConfLexer.cpp.

References WEIGHTST.

Referenced by nextToken().

01546                                                    {
01547         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01548         _ttype = WEIGHTST;
01549         std::string::size_type _saveIndex;
01550         
01551         match("weights");
01552         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01553            _token = makeToken(_ttype);
01554            _token->setText(text.substr(_begin, text.length()-_begin));
01555         }
01556         _returnToken = _token;
01557         _saveIndex=0;
01558 }

void C1dInvGaConfLexer::mRECWEIGHTT ( bool _createToken )

Definition at line 1560 of file C1dInvGaConfLexer.cpp.

References RECWEIGHTT.

Referenced by nextToken().

01560                                                      {
01561         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01562         _ttype = RECWEIGHTT;
01563         std::string::size_type _saveIndex;
01564         
01565         match("recweight");
01566         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01567            _token = makeToken(_ttype);
01568            _token->setText(text.substr(_begin, text.length()-_begin));
01569         }
01570         _returnToken = _token;
01571         _saveIndex=0;
01572 }

void C1dInvGaConfLexer::mABSVELWEIGHTT ( bool _createToken )

Definition at line 1574 of file C1dInvGaConfLexer.cpp.

References ABSVELWEIGHTT.

Referenced by nextToken().

01574                                                         {
01575         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01576         _ttype = ABSVELWEIGHTT;
01577         std::string::size_type _saveIndex;
01578         
01579         match("absvelweight");
01580         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01581            _token = makeToken(_ttype);
01582            _token->setText(text.substr(_begin, text.length()-_begin));
01583         }
01584         _returnToken = _token;
01585         _saveIndex=0;
01586 }


Public Member Functions
bool	getCaseSensitiveLiterals () const
	C1dInvGaConfLexer (std::istream &in)
	C1dInvGaConfLexer (antlr::InputBuffer &ib)
	C1dInvGaConfLexer (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	mUSEVREFMODELT (bool _createToken)
void	mVREFMODELT (bool _createToken)
void	mMTFITEXPONENTT (bool _createToken)
void	mRECFITEXPONENTT (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	mSLOWNESST (bool _createToken)
void	mOMEGAT (bool _createToken)
void	mSIGMAT (bool _createToken)
void	mSHIFTT (bool _createToken)
void	mCCT (bool _createToken)
void	mPOISSONT (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	mRECERRORT (bool _createToken)
void	mRECMETHODT (bool _createToken)
void	mGATYPET (bool _createToken)
void	mOUTPUTBASET (bool _createToken)
void	mMODET (bool _createToken)
void	mMTFITT (bool _createToken)
void	mMTINPUTDATAT (bool _createToken)
void	mRECINPUTDATAT (bool _createToken)
void	mRFABSVELDATAT (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	mSVELBASET (bool _createToken)
void	mSVELSTEPT (bool _createToken)
void	mSVELSIZEST (bool _createToken)
void	mWEIGHTST (bool _createToken)
void	mRECWEIGHTT (bool _createToken)
void	mABSVELWEIGHTT (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)

C1dInvGaConfLexer Class Reference

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation