SurfInvGaConfLexer Class Reference

#include <SurfInvGaConfLexer.hpp>

Inheritance diagram for SurfInvGaConfLexer:

Inheritance graph
[legend]
Collaboration diagram for SurfInvGaConfLexer:

Collaboration graph
[legend]
List of all members.

Public Member Functions

bool getCaseSensitiveLiterals () const
 SurfInvGaConfLexer (std::istream &in)
 SurfInvGaConfLexer (antlr::InputBuffer &ib)
 SurfInvGaConfLexer (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 mFITEXPONENTT (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 mPOISSONT (bool _createToken)
void mTHREADST (bool _createToken)
void mERRORLEVELT (bool _createToken)
void mGATYPET (bool _createToken)
void mOUTPUTBASET (bool _createToken)
void mINPUTDATAT (bool _createToken)
void mANNEALINGGENERATIONT (bool _createToken)
void mELITISTT (bool _createToken)
void mTHICKBASET (bool _createToken)
void mTHICKSTEPT (bool _createToken)
void mTHICKSIZEST (bool _createToken)
void mSVELBASET (bool _createToken)
void mSVELSTEPT (bool _createToken)
void mSVELSIZEST (bool _createToken)
void mWEIGHTST (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)

Detailed Description

Definition at line 18 of file SurfInvGaConfLexer.hpp.


Constructor & Destructor Documentation

SurfInvGaConfLexer::SurfInvGaConfLexer ( std::istream &  in  ) 

Definition at line 13 of file SurfInvGaConfLexer.cpp.

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

SurfInvGaConfLexer::SurfInvGaConfLexer ( antlr::InputBuffer &  ib  ) 

Definition at line 19 of file SurfInvGaConfLexer.cpp.

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

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

Definition at line 25 of file SurfInvGaConfLexer.cpp.

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


Member Function Documentation

bool SurfInvGaConfLexer::getCaseSensitiveLiterals (  )  const [inline]

Definition at line 25 of file SurfInvGaConfLexer.hpp.

00026         {
00027                 return true;
00028         }

antlr::RefToken SurfInvGaConfLexer::nextToken (  ) 

Definition at line 35 of file SurfInvGaConfLexer.cpp.

References mANNEALINGGENERATIONT(), mCOMMENT(), mCOOLINGRATIOT(), mCROSSOVERPROBT(), mELITISTT(), mEQUAL(), mERRORLEVELT(), mFALSE(), mFITEXPONENTT(), mGATYPET(), mGENERATIONST(), mINITTEMPT(), mINPUTDATAT(), mMUTATIONPROBT(), mNUMBER(), mOUTPUTBASET(), mPOISSONT(), mPOPSIZET(), mSTRING(), mSVELBASET(), mSVELSIZEST(), mSVELSTEPT(), 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) == 0x66 /* 'f' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x78 /* 'x' */ ) && (LA(6) == 0x70 /* 'p' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00089                                         mFITEXPONENTT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x6e /* 'n' */ ) && (LA(7) == 0x67 /* 'g' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00093                                         mCOOLINGRATIOT(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 else if ((LA(1) == 0x67 /* 'g' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x6f /* 'o' */ ) && (LA(10) == 0x6e /* 'n' */ )) {
00097                                         mGENERATIONST(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x61 /* 'a' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x6f /* 'o' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (LA(10) == 0x72 /* 'r' */ )) {
00101                                         mMUTATIONPROBT(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 else if ((LA(1) == 0x63 /* 'c' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x6f /* 'o' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x76 /* 'v' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x72 /* 'r' */ ) && (LA(10) == 0x70 /* 'p' */ )) {
00105                                         mCROSSOVERPROBT(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x6f /* 'o' */ ) && (LA(5) == 0x72 /* 'r' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x76 /* 'v' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x6c /* 'l' */ )) {
00109                                         mERRORLEVELT(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                                 else if ((LA(1) == 0x6f /* 'o' */ ) && (LA(2) == 0x75 /* 'u' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x70 /* 'p' */ ) && (LA(5) == 0x75 /* 'u' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x62 /* 'b' */ ) && (LA(8) == 0x61 /* 'a' */ ) && (LA(9) == 0x73 /* 's' */ ) && (LA(10) == 0x65 /* 'e' */ )) {
00113                                         mOUTPUTBASET(true);
00114                                         theRetToken=_returnToken;
00115                                 }
00116                                 else if ((LA(1) == 0x61 /* 'a' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x67 /* 'g' */ ) && (LA(10) == 0x67 /* 'g' */ )) {
00117                                         mANNEALINGGENERATIONT(true);
00118                                         theRetToken=_returnToken;
00119                                 }
00120                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x7a /* 'z' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (LA(10) == 0x73 /* 's' */ )) {
00121                                         mTHICKSIZEST(true);
00122                                         theRetToken=_returnToken;
00123                                 }
00124                                 else if ((LA(1) == 0x76 /* 'v' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x66 /* 'f' */ ) && (LA(5) == 0x6d /* 'm' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x64 /* 'd' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x6c /* 'l' */ ) && (true)) {
00125                                         mVREFMODELT(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 else if ((LA(1) == 0x69 /* 'i' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x70 /* 'p' */ ) && (LA(4) == 0x75 /* 'u' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x64 /* 'd' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x74 /* 't' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (true)) {
00129                                         mINPUTDATAT(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x62 /* 'b' */ ) && (LA(7) == 0x61 /* 'a' */ ) && (LA(8) == 0x73 /* 's' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00133                                         mTHICKBASET(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x63 /* 'c' */ ) && (LA(5) == 0x6b /* 'k' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x70 /* 'p' */ ) && (true)) {
00137                                         mTHICKSTEPT(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x7a /* 'z' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x73 /* 's' */ ) && (true)) {
00141                                         mSVELSIZEST(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 else if ((LA(1) == 0x69 /* 'i' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x6d /* 'm' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (true) && (true)) {
00145                                         mINITTEMPT(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x62 /* 'b' */ ) && (LA(6) == 0x61 /* 'a' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (true) && (true)) {
00149                                         mSVELBASET(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x76 /* 'v' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x70 /* 'p' */ ) && (true) && (true)) {
00153                                         mSVELSTEPT(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 else if ((LA(1) == 0x76 /* 'v' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x62 /* 'b' */ ) && (LA(5) == 0x6f /* 'o' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00157                                         mVERBOSET(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x70 /* 'p' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x7a /* 'z' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (true) && (true) && (true)) {
00161                                         mPOPSIZET(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 else if ((LA(1) == 0x70 /* 'p' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x6e /* 'n' */ ) && (true) && (true) && (true)) {
00165                                         mPOISSONT(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x72 /* 'r' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (LA(5) == 0x61 /* 'a' */ ) && (LA(6) == 0x64 /* 'd' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00169                                         mTHREADST(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x65 /* 'e' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x69 /* 'i' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x74 /* 't' */ ) && (true) && (true) && (true)) {
00173                                         mELITISTT(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if ((LA(1) == 0x77 /* 'w' */ ) && (LA(2) == 0x65 /* 'e' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x67 /* 'g' */ ) && (LA(5) == 0x68 /* 'h' */ ) && (LA(6) == 0x74 /* 't' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00177                                         mWEIGHTST(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 else if ((LA(1) == 0x67 /* 'g' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x74 /* 't' */ ) && (LA(4) == 0x79 /* 'y' */ ) && (LA(5) == 0x70 /* 'p' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true)) {
00181                                         mGATYPET(true);
00182                                         theRetToken=_returnToken;
00183                                 }
00184                                 else if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6c /* 'l' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true)) {
00185                                         mFALSE(true);
00186                                         theRetToken=_returnToken;
00187                                 }
00188                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00189                                         mTRUE(true);
00190                                         theRetToken=_returnToken;
00191                                 }
00192                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00193                                         mSTRING(true);
00194                                         theRetToken=_returnToken;
00195                                 }
00196                         else {
00197                                 if (LA(1)==EOF_CHAR)
00198                                 {
00199                                         uponEOF();
00200                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00201                                 }
00202                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00203                         }
00204                         }
00205                         if ( !_returnToken )
00206                                 goto tryAgain; // found SKIP token
00207 
00208                         _ttype = _returnToken->getType();
00209                         _ttype = testLiteralsTable(_ttype);
00210                         _returnToken->setType(_ttype);
00211                         return _returnToken;
00212                 }
00213                 catch (antlr::RecognitionException& e) {
00214                                 throw antlr::TokenStreamRecognitionException(e);
00215                 }
00216                 catch (antlr::CharStreamIOException& csie) {
00217                         throw antlr::TokenStreamIOException(csie.io);
00218                 }
00219                 catch (antlr::CharStreamException& cse) {
00220                         throw antlr::TokenStreamException(cse.getMessage());
00221                 }
00222 tryAgain:;
00223         }
00224 }

Here is the call graph for this function:

void SurfInvGaConfLexer::mEQUAL ( bool  _createToken  ) 

Definition at line 226 of file SurfInvGaConfLexer.cpp.

References EQUAL.

Referenced by nextToken().

00226                                                  {
00227         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00228         _ttype = EQUAL;
00229         std::string::size_type _saveIndex;
00230         
00231         match('=' /* charlit */ );
00232         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00233            _token = makeToken(_ttype);
00234            _token->setText(text.substr(_begin, text.length()-_begin));
00235         }
00236         _returnToken = _token;
00237         _saveIndex=0;
00238 }

void SurfInvGaConfLexer::mTRUE ( bool  _createToken  ) 

Definition at line 240 of file SurfInvGaConfLexer.cpp.

References TRUE.

Referenced by nextToken().

00240                                                 {
00241         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00242         _ttype = TRUE;
00243         std::string::size_type _saveIndex;
00244         
00245         match("true");
00246         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00247            _token = makeToken(_ttype);
00248            _token->setText(text.substr(_begin, text.length()-_begin));
00249         }
00250         _returnToken = _token;
00251         _saveIndex=0;
00252 }

void SurfInvGaConfLexer::mFALSE ( bool  _createToken  ) 

Definition at line 254 of file SurfInvGaConfLexer.cpp.

References FALSE.

Referenced by nextToken().

00254                                                  {
00255         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00256         _ttype = FALSE;
00257         std::string::size_type _saveIndex;
00258         
00259         match("false");
00260         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00261            _token = makeToken(_ttype);
00262            _token->setText(text.substr(_begin, text.length()-_begin));
00263         }
00264         _returnToken = _token;
00265         _saveIndex=0;
00266 }

void SurfInvGaConfLexer::mWS ( bool  _createToken  ) 

Definition at line 268 of file SurfInvGaConfLexer.cpp.

References mNEWLINE(), and WS.

Referenced by nextToken().

00268                                               {
00269         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00270         _ttype = WS;
00271         std::string::size_type _saveIndex;
00272         
00273         { // ( ... )+
00274         int _cnt126=0;
00275         for (;;) {
00276                 switch ( LA(1)) {
00277                 case 0x20 /* ' ' */ :
00278                 {
00279                         match(' ' /* charlit */ );
00280                         break;
00281                 }
00282                 case 0xa /* '\n' */ :
00283                 case 0xd /* '\r' */ :
00284                 {
00285                         mNEWLINE(false);
00286                         break;
00287                 }
00288                 case 0x9 /* '\t' */ :
00289                 {
00290                         match('\t' /* charlit */ );
00291                         break;
00292                 }
00293                 default:
00294                 {
00295                         if ( _cnt126>=1 ) { goto _loop126; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00296                 }
00297                 }
00298                 _cnt126++;
00299         }
00300         _loop126:;
00301         }  // ( ... )+
00302         if ( inputState->guessing==0 ) {
00303 #line 122 "SurfInvGaConf.g"
00304                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00305 #line 306 "SurfInvGaConfLexer.cpp"
00306         }
00307         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00308            _token = makeToken(_ttype);
00309            _token->setText(text.substr(_begin, text.length()-_begin));
00310         }
00311         _returnToken = _token;
00312         _saveIndex=0;
00313 }

Here is the call graph for this function:

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

Definition at line 315 of file SurfInvGaConfLexer.cpp.

References NEWLINE.

Referenced by mCOMMENT(), and mWS().

00315                                                    {
00316         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00317         _ttype = NEWLINE;
00318         std::string::size_type _saveIndex;
00319         
00320         {
00321         switch ( LA(1)) {
00322         case 0xa /* '\n' */ :
00323         {
00324                 match('\n' /* charlit */ );
00325                 break;
00326         }
00327         case 0xd /* '\r' */ :
00328         {
00329                 match('\r' /* charlit */ );
00330                 match('\n' /* charlit */ );
00331                 break;
00332         }
00333         default:
00334         {
00335                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00336         }
00337         }
00338         }
00339         if ( inputState->guessing==0 ) {
00340 #line 148 "SurfInvGaConf.g"
00341                 newline();
00342 #line 343 "SurfInvGaConfLexer.cpp"
00343         }
00344         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00345            _token = makeToken(_ttype);
00346            _token->setText(text.substr(_begin, text.length()-_begin));
00347         }
00348         _returnToken = _token;
00349         _saveIndex=0;
00350 }

void SurfInvGaConfLexer::mSTRING ( bool  _createToken  ) 

Definition at line 352 of file SurfInvGaConfLexer.cpp.

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

Referenced by nextToken().

00352                                                   {
00353         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00354         _ttype = STRING;
00355         std::string::size_type _saveIndex;
00356         
00357         mCHAR(false);
00358         { // ( ... )*
00359         for (;;) {
00360                 switch ( LA(1)) {
00361                 case 0x61 /* 'a' */ :
00362                 case 0x62 /* 'b' */ :
00363                 case 0x63 /* 'c' */ :
00364                 case 0x64 /* 'd' */ :
00365                 case 0x65 /* 'e' */ :
00366                 case 0x66 /* 'f' */ :
00367                 case 0x67 /* 'g' */ :
00368                 case 0x68 /* 'h' */ :
00369                 case 0x69 /* 'i' */ :
00370                 case 0x6a /* 'j' */ :
00371                 case 0x6b /* 'k' */ :
00372                 case 0x6c /* 'l' */ :
00373                 case 0x6d /* 'm' */ :
00374                 case 0x6e /* 'n' */ :
00375                 case 0x6f /* 'o' */ :
00376                 case 0x70 /* 'p' */ :
00377                 case 0x71 /* 'q' */ :
00378                 case 0x72 /* 'r' */ :
00379                 case 0x73 /* 's' */ :
00380                 case 0x74 /* 't' */ :
00381                 case 0x75 /* 'u' */ :
00382                 case 0x76 /* 'v' */ :
00383                 case 0x77 /* 'w' */ :
00384                 case 0x78 /* 'x' */ :
00385                 case 0x79 /* 'y' */ :
00386                 case 0x7a /* 'z' */ :
00387                 {
00388                         mCHAR(false);
00389                         break;
00390                 }
00391                 case 0x30 /* '0' */ :
00392                 case 0x31 /* '1' */ :
00393                 case 0x32 /* '2' */ :
00394                 case 0x33 /* '3' */ :
00395                 case 0x34 /* '4' */ :
00396                 case 0x35 /* '5' */ :
00397                 case 0x36 /* '6' */ :
00398                 case 0x37 /* '7' */ :
00399                 case 0x38 /* '8' */ :
00400                 case 0x39 /* '9' */ :
00401                 {
00402                         mDIGIT(false);
00403                         break;
00404                 }
00405                 case 0x23 /* '#' */ :
00406                 case 0x24 /* '$' */ :
00407                 case 0x25 /* '%' */ :
00408                 case 0x26 /* '&' */ :
00409                 case 0x27 /* '\'' */ :
00410                 case 0x28 /* '(' */ :
00411                 case 0x29 /* ')' */ :
00412                 case 0x2a /* '*' */ :
00413                 case 0x2b /* '+' */ :
00414                 case 0x2c /* ',' */ :
00415                 case 0x2d /* '-' */ :
00416                 case 0x2e /* '.' */ :
00417                 case 0x2f /* '/' */ :
00418                 case 0x3a /* ':' */ :
00419                 case 0x3b /* ';' */ :
00420                 case 0x3c /* '<' */ :
00421                 case 0x3f /* '?' */ :
00422                 case 0x40 /* '@' */ :
00423                 case 0x5b /* '[' */ :
00424                 case 0x5d /* ']' */ :
00425                 case 0x5e /* '^' */ :
00426                 case 0x5f /* '_' */ :
00427                 case 0x7b /* '{' */ :
00428                 case 0x7c /* '|' */ :
00429                 case 0x7d /* '}' */ :
00430                 case 0x7e /* '~' */ :
00431                 {
00432                         mOTHER(false);
00433                         break;
00434                 }
00435                 default:
00436                 {
00437                         goto _loop129;
00438                 }
00439                 }
00440         }
00441         _loop129:;
00442         } // ( ... )*
00443         _ttype = testLiteralsTable(_ttype);
00444         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00445            _token = makeToken(_ttype);
00446            _token->setText(text.substr(_begin, text.length()-_begin));
00447         }
00448         _returnToken = _token;
00449         _saveIndex=0;
00450 }

Here is the call graph for this function:

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

Definition at line 452 of file SurfInvGaConfLexer.cpp.

References CHAR.

Referenced by mSTRING().

00452                                                 {
00453         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00454         _ttype = CHAR;
00455         std::string::size_type _saveIndex;
00456         
00457         {
00458         matchRange('a','z');
00459         }
00460         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00461            _token = makeToken(_ttype);
00462            _token->setText(text.substr(_begin, text.length()-_begin));
00463         }
00464         _returnToken = _token;
00465         _saveIndex=0;
00466 }

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

Definition at line 468 of file SurfInvGaConfLexer.cpp.

References DIGIT.

Referenced by mINT(), and mSTRING().

00468                                                  {
00469         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00470         _ttype = DIGIT;
00471         std::string::size_type _saveIndex;
00472         
00473         matchRange('0','9');
00474         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00475            _token = makeToken(_ttype);
00476            _token->setText(text.substr(_begin, text.length()-_begin));
00477         }
00478         _returnToken = _token;
00479         _saveIndex=0;
00480 }

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

Definition at line 482 of file SurfInvGaConfLexer.cpp.

References OTHER.

Referenced by mSTRING().

00482                                                  {
00483         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00484         _ttype = OTHER;
00485         std::string::size_type _saveIndex;
00486         
00487         switch ( LA(1)) {
00488         case 0x27 /* '\'' */ :
00489         {
00490                 match('\'' /* charlit */ );
00491                 break;
00492         }
00493         case 0x23 /* '#' */ :
00494         {
00495                 match('#' /* charlit */ );
00496                 break;
00497         }
00498         case 0x24 /* '$' */ :
00499         {
00500                 match('$' /* charlit */ );
00501                 break;
00502         }
00503         case 0x25 /* '%' */ :
00504         {
00505                 match('%' /* charlit */ );
00506                 break;
00507         }
00508         case 0x26 /* '&' */ :
00509         {
00510                 match('&' /* charlit */ );
00511                 break;
00512         }
00513         case 0x28 /* '(' */ :
00514         {
00515                 match('(' /* charlit */ );
00516                 break;
00517         }
00518         case 0x29 /* ')' */ :
00519         {
00520                 match(')' /* charlit */ );
00521                 break;
00522         }
00523         case 0x2a /* '*' */ :
00524         {
00525                 match('*' /* charlit */ );
00526                 break;
00527         }
00528         case 0x2b /* '+' */ :
00529         {
00530                 match('+' /* charlit */ );
00531                 break;
00532         }
00533         case 0x2c /* ',' */ :
00534         {
00535                 match(',' /* charlit */ );
00536                 break;
00537         }
00538         case 0x2d /* '-' */ :
00539         {
00540                 match('-' /* charlit */ );
00541                 break;
00542         }
00543         case 0x2e /* '.' */ :
00544         {
00545                 match('.' /* charlit */ );
00546                 break;
00547         }
00548         case 0x2f /* '/' */ :
00549         {
00550                 match('/' /* charlit */ );
00551                 break;
00552         }
00553         case 0x3a /* ':' */ :
00554         {
00555                 match(':' /* charlit */ );
00556                 break;
00557         }
00558         case 0x3b /* ';' */ :
00559         {
00560                 match(';' /* charlit */ );
00561                 break;
00562         }
00563         case 0x3c /* '<' */ :
00564         {
00565                 match('<' /* charlit */ );
00566                 break;
00567         }
00568         case 0x3f /* '?' */ :
00569         {
00570                 match('?' /* charlit */ );
00571                 break;
00572         }
00573         case 0x40 /* '@' */ :
00574         {
00575                 match('@' /* charlit */ );
00576                 break;
00577         }
00578         case 0x5b /* '[' */ :
00579         {
00580                 match('[' /* charlit */ );
00581                 break;
00582         }
00583         case 0x5d /* ']' */ :
00584         {
00585                 match(']' /* charlit */ );
00586                 break;
00587         }
00588         case 0x5e /* '^' */ :
00589         {
00590                 match('^' /* charlit */ );
00591                 break;
00592         }
00593         case 0x5f /* '_' */ :
00594         {
00595                 match('_' /* charlit */ );
00596                 break;
00597         }
00598         case 0x7b /* '{' */ :
00599         {
00600                 match('{' /* charlit */ );
00601                 break;
00602         }
00603         case 0x7c /* '|' */ :
00604         {
00605                 match('|' /* charlit */ );
00606                 break;
00607         }
00608         case 0x7d /* '}' */ :
00609         {
00610                 match('}' /* charlit */ );
00611                 break;
00612         }
00613         case 0x7e /* '~' */ :
00614         {
00615                 match('~' /* charlit */ );
00616                 break;
00617         }
00618         default:
00619         {
00620                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00621         }
00622         }
00623         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00624            _token = makeToken(_ttype);
00625            _token->setText(text.substr(_begin, text.length()-_begin));
00626         }
00627         _returnToken = _token;
00628         _saveIndex=0;
00629 }

void SurfInvGaConfLexer::mNUMBER ( bool  _createToken  ) 

Definition at line 631 of file SurfInvGaConfLexer.cpp.

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

Referenced by nextToken().

00631                                                   {
00632         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00633         _ttype = NUMBER;
00634         std::string::size_type _saveIndex;
00635         
00636         {
00637         switch ( LA(1)) {
00638         case 0x2b /* '+' */ :
00639         {
00640                 match('+' /* charlit */ );
00641                 break;
00642         }
00643         case 0x2d /* '-' */ :
00644         {
00645                 match('-' /* charlit */ );
00646                 break;
00647         }
00648         case 0x2e /* '.' */ :
00649         case 0x30 /* '0' */ :
00650         case 0x31 /* '1' */ :
00651         case 0x32 /* '2' */ :
00652         case 0x33 /* '3' */ :
00653         case 0x34 /* '4' */ :
00654         case 0x35 /* '5' */ :
00655         case 0x36 /* '6' */ :
00656         case 0x37 /* '7' */ :
00657         case 0x38 /* '8' */ :
00658         case 0x39 /* '9' */ :
00659         {
00660                 break;
00661         }
00662         default:
00663         {
00664                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00665         }
00666         }
00667         }
00668         {
00669         bool synPredMatched134 = false;
00670         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00671                 int _m134 = mark();
00672                 synPredMatched134 = true;
00673                 inputState->guessing++;
00674                 try {
00675                         {
00676                         mREAL(false);
00677                         }
00678                 }
00679                 catch (antlr::RecognitionException& pe) {
00680                         synPredMatched134 = false;
00681                 }
00682                 rewind(_m134);
00683                 inputState->guessing--;
00684         }
00685         if ( synPredMatched134 ) {
00686                 mREAL(false);
00687         }
00688         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00689                 mINT(false);
00690         }
00691         else {
00692                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00693         }
00694         
00695         }
00696         {
00697         if ((LA(1) == 0x65 /* 'e' */ )) {
00698                 {
00699                 match('e' /* charlit */ );
00700                 }
00701                 {
00702                 switch ( LA(1)) {
00703                 case 0x2b /* '+' */ :
00704                 {
00705                         match('+' /* charlit */ );
00706                         break;
00707                 }
00708                 case 0x2d /* '-' */ :
00709                 {
00710                         match('-' /* charlit */ );
00711                         break;
00712                 }
00713                 case 0x30 /* '0' */ :
00714                 case 0x31 /* '1' */ :
00715                 case 0x32 /* '2' */ :
00716                 case 0x33 /* '3' */ :
00717                 case 0x34 /* '4' */ :
00718                 case 0x35 /* '5' */ :
00719                 case 0x36 /* '6' */ :
00720                 case 0x37 /* '7' */ :
00721                 case 0x38 /* '8' */ :
00722                 case 0x39 /* '9' */ :
00723                 {
00724                         break;
00725                 }
00726                 default:
00727                 {
00728                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00729                 }
00730                 }
00731                 }
00732                 mINT(false);
00733         }
00734         else {
00735         }
00736         
00737         }
00738         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00739            _token = makeToken(_ttype);
00740            _token->setText(text.substr(_begin, text.length()-_begin));
00741         }
00742         _returnToken = _token;
00743         _saveIndex=0;
00744 }

Here is the call graph for this function:

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

Definition at line 746 of file SurfInvGaConfLexer.cpp.

References mINT(), and REAL.

Referenced by mNUMBER().

00746                                                 {
00747         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00748         _ttype = REAL;
00749         std::string::size_type _saveIndex;
00750         
00751         {
00752         switch ( LA(1)) {
00753         case 0x2e /* '.' */ :
00754         {
00755                 match('.' /* charlit */ );
00756                 mINT(false);
00757                 break;
00758         }
00759         case 0x30 /* '0' */ :
00760         case 0x31 /* '1' */ :
00761         case 0x32 /* '2' */ :
00762         case 0x33 /* '3' */ :
00763         case 0x34 /* '4' */ :
00764         case 0x35 /* '5' */ :
00765         case 0x36 /* '6' */ :
00766         case 0x37 /* '7' */ :
00767         case 0x38 /* '8' */ :
00768         case 0x39 /* '9' */ :
00769         {
00770                 mINT(false);
00771                 match('.' /* charlit */ );
00772                 {
00773                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00774                         mINT(false);
00775                 }
00776                 else {
00777                 }
00778                 
00779                 }
00780                 break;
00781         }
00782         default:
00783         {
00784                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00785         }
00786         }
00787         }
00788         if ( _createToken && _token==antlr::nullToken && _ttype!=ant