MT Tools » levmarq

CLevmarConfLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.6 (20070220): "CLevmarConf.g" -> "CLevmarConfLexer.cpp"$ */
00002 #include "CLevmarConfLexer.hpp"
00003 #include <antlr/CharBuffer.hpp>
00004 #include <antlr/TokenStreamException.hpp>
00005 #include <antlr/TokenStreamIOException.hpp>
00006 #include <antlr/TokenStreamRecognitionException.hpp>
00007 #include <antlr/CharStreamException.hpp>
00008 #include <antlr/CharStreamIOException.hpp>
00009 #include <antlr/NoViableAltForCharException.hpp>
00010 
00011 #line 1 "CLevmarConf.g"
00012 #line 13 "CLevmarConfLexer.cpp"
00013 CLevmarConfLexer::CLevmarConfLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 CLevmarConfLexer::CLevmarConfLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 CLevmarConfLexer::CLevmarConfLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void CLevmarConfLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken CLevmarConfLexer::nextToken()
00036 {
00037         antlr::RefToken theRetToken;
00038         for (;;) {
00039                 antlr::RefToken theRetToken;
00040                 int _ttype = antlr::Token::INVALID_TYPE;
00041                 resetText();
00042                 try {   // for lexical and char stream error handling
00043                         switch ( LA(1)) {
00044                         case 0x3d /* '=' */ :
00045                         {
00046                                 mEQUAL(true);
00047                                 theRetToken=_returnToken;
00048                                 break;
00049                         }
00050                         case 0x9 /* '\t' */ :
00051                         case 0xa /* '\n' */ :
00052                         case 0xd /* '\r' */ :
00053                         case 0x20 /* ' ' */ :
00054                         {
00055                                 mWS(true);
00056                                 theRetToken=_returnToken;
00057                                 break;
00058                         }
00059                         case 0x2b /* '+' */ :
00060                         case 0x2d /* '-' */ :
00061                         case 0x2e /* '.' */ :
00062                         case 0x30 /* '0' */ :
00063                         case 0x31 /* '1' */ :
00064                         case 0x32 /* '2' */ :
00065                         case 0x33 /* '3' */ :
00066                         case 0x34 /* '4' */ :
00067                         case 0x35 /* '5' */ :
00068                         case 0x36 /* '6' */ :
00069                         case 0x37 /* '7' */ :
00070                         case 0x38 /* '8' */ :
00071                         case 0x39 /* '9' */ :
00072                         {
00073                                 mNUMBER(true);
00074                                 theRetToken=_returnToken;
00075                                 break;
00076                         }
00077                         case 0x2f /* '/' */ :
00078                         {
00079                                 mCOMMENT(true);
00080                                 theRetToken=_returnToken;
00081                                 break;
00082                         }
00083                         default:
00084                                 if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 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' */ )) {
00085                                         mMTINPUTDATAT(true);
00086                                         theRetToken=_returnToken;
00087                                 }
00088                                 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' */ )) {
00089                                         mRECINPUTDATAT(true);
00090                                         theRetToken=_returnToken;
00091                                 }
00092                                 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' */ )) {
00093                                         mTENSORERRORT(true);
00094                                         theRetToken=_returnToken;
00095                                 }
00096                                 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' */ )) {
00097                                         mPHASEERRORT(true);
00098                                         theRetToken=_returnToken;
00099                                 }
00100                                 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) == 0x68 /* 'h' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x63 /* 'c' */ ) && (LA(10) == 0x6b /* 'k' */ )) {
00101                                         mSTARTTHICKT(true);
00102                                         theRetToken=_returnToken;
00103                                 }
00104                                 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)) {
00105                                         mSTARTTIMET(true);
00106                                         theRetToken=_returnToken;
00107                                 }
00108                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x73 /* 's' */ ) && (LA(7) == 0x76 /* 'v' */ ) && (LA(8) == 0x65 /* 'e' */ ) && (LA(9) == 0x6c /* 'l' */ ) && (true)) {
00109                                         mSTARTSVELT(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x64 /* 'd' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x6e /* 'n' */ ) && (LA(9) == 0x73 /* 's' */ ) && (true)) {
00113                                         mSTARTDENST(true);
00114                                         theRetToken=_returnToken;
00115                                 }
00116                                 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)) {
00117                                         mSLOWNESST(true);
00118                                         theRetToken=_returnToken;
00119                                 }
00120                                 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)) {
00121                                         mRESERRORT(true);
00122                                         theRetToken=_returnToken;
00123                                 }
00124                                 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)) {
00125                                         mRECERRORT(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x61 /* 'a' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x65 /* 'e' */ ) && (LA(8) == 0x73 /* 's' */ ) && (true) && (true)) {
00129                                         mSTARTREST(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x68 /* 'h' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x63 /* 'c' */ ) && (LA(8) == 0x6b /* 'k' */ ) && (true) && (true)) {
00133                                         mMINTHICKT(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x68 /* 'h' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x63 /* 'c' */ ) && (LA(8) == 0x6b /* 'k' */ ) && (true) && (true)) {
00137                                         mMAXTHICKT(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (true) && (true) && (true)) {
00141                                         mMAXITERT(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 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)) {
00145                                         mPOISSONT(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 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)) {
00149                                         mENDTIMET(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x76 /* 'v' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x6c /* 'l' */ ) && (true) && (true) && (true)) {
00153                                         mMINSVELT(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x76 /* 'v' */ ) && (LA(6) == 0x65 /* 'e' */ ) && (LA(7) == 0x6c /* 'l' */ ) && (true) && (true) && (true)) {
00157                                         mMAXSVELT(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x64 /* 'd' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x6e /* 'n' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00161                                         mMINDENST(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x64 /* 'd' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x6e /* 'n' */ ) && (LA(7) == 0x73 /* 's' */ ) && (true) && (true) && (true)) {
00165                                         mMAXDENST(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 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)) {
00169                                         mWEIGHTST(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x77 /* 'w' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x76 /* 'v' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x6c /* 'l' */ ) && (true) && (true) && (true) && (true)) {
00173                                         mWLEVELT(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x73 /* 's' */ ) && (true) && (true) && (true) && (true)) {
00177                                         mMINREST(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x72 /* 'r' */ ) && (LA(5) == 0x65 /* 'e' */ ) && (LA(6) == 0x73 /* 's' */ ) && (true) && (true) && (true) && (true)) {
00181                                         mMAXREST(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) == 0x6d /* 'm' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x66 /* 'f' */ ) && (LA(4) == 0x69 /* 'i' */ ) && (LA(5) == 0x74 /* 't' */ ) && (true) && (true) && (true) && (true) && (true)) {
00189                                         mMTFITT(true);
00190                                         theRetToken=_returnToken;
00191                                 }
00192                                 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)) {
00193                                         mOMEGAT(true);
00194                                         theRetToken=_returnToken;
00195                                 }
00196                                 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)) {
00197                                         mSIGMAT(true);
00198                                         theRetToken=_returnToken;
00199                                 }
00200                                 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)) {
00201                                         mSHIFTT(true);
00202                                         theRetToken=_returnToken;
00203                                 }
00204                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00205                                         mTRUE(true);
00206                                         theRetToken=_returnToken;
00207                                 }
00208                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00209                                         mMODET(true);
00210                                         theRetToken=_returnToken;
00211                                 }
00212                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00213                                         mSTRING(true);
00214                                         theRetToken=_returnToken;
00215                                 }
00216                         else {
00217                                 if (LA(1)==EOF_CHAR)
00218                                 {
00219                                         uponEOF();
00220                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00221                                 }
00222                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00223                         }
00224                         }
00225                         if ( !_returnToken )
00226                                 goto tryAgain; // found SKIP token
00227 
00228                         _ttype = _returnToken->getType();
00229                         _ttype = testLiteralsTable(_ttype);
00230                         _returnToken->setType(_ttype);
00231                         return _returnToken;
00232                 }
00233                 catch (antlr::RecognitionException& e) {
00234                                 throw antlr::TokenStreamRecognitionException(e);
00235                 }
00236                 catch (antlr::CharStreamIOException& csie) {
00237                         throw antlr::TokenStreamIOException(csie.io);
00238                 }
00239                 catch (antlr::CharStreamException& cse) {
00240                         throw antlr::TokenStreamException(cse.getMessage());
00241                 }
00242 tryAgain:;
00243         }
00244 }
00245 
00246 void CLevmarConfLexer::mEQUAL(bool _createToken) {
00247         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00248         _ttype = EQUAL;
00249         std::string::size_type _saveIndex;
00250         
00251         match('=' /* charlit */ );
00252         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00253            _token = makeToken(_ttype);
00254            _token->setText(text.substr(_begin, text.length()-_begin));
00255         }
00256         _returnToken = _token;
00257         _saveIndex=0;
00258 }
00259 
00260 void CLevmarConfLexer::mTRUE(bool _createToken) {
00261         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00262         _ttype = TRUE;
00263         std::string::size_type _saveIndex;
00264         
00265         match("true");
00266         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00267            _token = makeToken(_ttype);
00268            _token->setText(text.substr(_begin, text.length()-_begin));
00269         }
00270         _returnToken = _token;
00271         _saveIndex=0;
00272 }
00273 
00274 void CLevmarConfLexer::mFALSE(bool _createToken) {
00275         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00276         _ttype = FALSE;
00277         std::string::size_type _saveIndex;
00278         
00279         match("false");
00280         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00281            _token = makeToken(_ttype);
00282            _token->setText(text.substr(_begin, text.length()-_begin));
00283         }
00284         _returnToken = _token;
00285         _saveIndex=0;
00286 }
00287 
00288 void CLevmarConfLexer::mWS(bool _createToken) {
00289         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00290         _ttype = WS;
00291         std::string::size_type _saveIndex;
00292         
00293         { // ( ... )+
00294         int _cnt164=0;
00295         for (;;) {
00296                 switch ( LA(1)) {
00297                 case 0x20 /* ' ' */ :
00298                 {
00299                         match(' ' /* charlit */ );
00300                         break;
00301                 }
00302                 case 0xa /* '\n' */ :
00303                 case 0xd /* '\r' */ :
00304                 {
00305                         mNEWLINE(false);
00306                         break;
00307                 }
00308                 case 0x9 /* '\t' */ :
00309                 {
00310                         match('\t' /* charlit */ );
00311                         break;
00312                 }
00313                 default:
00314                 {
00315                         if ( _cnt164>=1 ) { goto _loop164; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00316                 }
00317                 }
00318                 _cnt164++;
00319         }
00320         _loop164:;
00321         }  // ( ... )+
00322         if ( inputState->guessing==0 ) {
00323 #line 135 "CLevmarConf.g"
00324                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00325 #line 326 "CLevmarConfLexer.cpp"
00326         }
00327         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00328            _token = makeToken(_ttype);
00329            _token->setText(text.substr(_begin, text.length()-_begin));
00330         }
00331         _returnToken = _token;
00332         _saveIndex=0;
00333 }
00334 
00335 void CLevmarConfLexer::mNEWLINE(bool _createToken) {
00336         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00337         _ttype = NEWLINE;
00338         std::string::size_type _saveIndex;
00339         
00340         {
00341         switch ( LA(1)) {
00342         case 0xa /* '\n' */ :
00343         {
00344                 match('\n' /* charlit */ );
00345                 break;
00346         }
00347         case 0xd /* '\r' */ :
00348         {
00349                 match('\r' /* charlit */ );
00350                 match('\n' /* charlit */ );
00351                 break;
00352         }
00353         default:
00354         {
00355                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00356         }
00357         }
00358         }
00359         if ( inputState->guessing==0 ) {
00360 #line 161 "CLevmarConf.g"
00361                 newline();
00362 #line 363 "CLevmarConfLexer.cpp"
00363         }
00364         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00365            _token = makeToken(_ttype);
00366            _token->setText(text.substr(_begin, text.length()-_begin));
00367         }
00368         _returnToken = _token;
00369         _saveIndex=0;
00370 }
00371 
00372 void CLevmarConfLexer::mSTRING(bool _createToken) {
00373         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00374         _ttype = STRING;
00375         std::string::size_type _saveIndex;
00376         
00377         mCHAR(false);
00378         { // ( ... )*
00379         for (;;) {
00380                 switch ( LA(1)) {
00381                 case 0x61 /* 'a' */ :
00382                 case 0x62 /* 'b' */ :
00383                 case 0x63 /* 'c' */ :
00384                 case 0x64 /* 'd' */ :
00385                 case 0x65 /* 'e' */ :
00386                 case 0x66 /* 'f' */ :
00387                 case 0x67 /* 'g' */ :
00388                 case 0x68 /* 'h' */ :
00389                 case 0x69 /* 'i' */ :
00390                 case 0x6a /* 'j' */ :
00391                 case 0x6b /* 'k' */ :
00392                 case 0x6c /* 'l' */ :
00393                 case 0x6d /* 'm' */ :
00394                 case 0x6e /* 'n' */ :
00395                 case 0x6f /* 'o' */ :
00396                 case 0x70 /* 'p' */ :
00397                 case 0x71 /* 'q' */ :
00398                 case 0x72 /* 'r' */ :
00399                 case 0x73 /* 's' */ :
00400                 case 0x74 /* 't' */ :
00401                 case 0x75 /* 'u' */ :
00402                 case 0x76 /* 'v' */ :
00403                 case 0x77 /* 'w' */ :
00404                 case 0x78 /* 'x' */ :
00405                 case 0x79 /* 'y' */ :
00406                 case 0x7a /* 'z' */ :
00407                 {
00408                         mCHAR(false);
00409                         break;
00410                 }
00411                 case 0x30 /* '0' */ :
00412                 case 0x31 /* '1' */ :
00413                 case 0x32 /* '2' */ :
00414                 case 0x33 /* '3' */ :
00415                 case 0x34 /* '4' */ :
00416                 case 0x35 /* '5' */ :
00417                 case 0x36 /* '6' */ :
00418                 case 0x37 /* '7' */ :
00419                 case 0x38 /* '8' */ :
00420                 case 0x39 /* '9' */ :
00421                 {
00422                         mDIGIT(false);
00423                         break;
00424                 }
00425                 case 0x23 /* '#' */ :
00426                 case 0x24 /* '$' */ :
00427                 case 0x25 /* '%' */ :
00428                 case 0x26 /* '&' */ :
00429                 case 0x27 /* '\'' */ :
00430                 case 0x28 /* '(' */ :
00431                 case 0x29 /* ')' */ :
00432                 case 0x2a /* '*' */ :
00433                 case 0x2b /* '+' */ :
00434                 case 0x2c /* ',' */ :
00435                 case 0x2d /* '-' */ :
00436                 case 0x2e /* '.' */ :
00437                 case 0x2f /* '/' */ :
00438                 case 0x3a /* ':' */ :
00439                 case 0x3b /* ';' */ :
00440                 case 0x3c /* '<' */ :
00441                 case 0x3f /* '?' */ :
00442                 case 0x40 /* '@' */ :
00443                 case 0x5b /* '[' */ :
00444                 case 0x5d /* ']' */ :
00445                 case 0x5e /* '^' */ :
00446                 case 0x5f /* '_' */ :
00447                 case 0x7b /* '{' */ :
00448                 case 0x7c /* '|' */ :
00449                 case 0x7d /* '}' */ :
00450                 case 0x7e /* '~' */ :
00451                 {
00452                         mOTHER(false);
00453                         break;
00454                 }
00455                 default:
00456                 {
00457                         goto _loop167;
00458                 }
00459                 }
00460         }
00461         _loop167:;
00462         } // ( ... )*
00463         _ttype = testLiteralsTable(_ttype);
00464         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00465            _token = makeToken(_ttype);
00466            _token->setText(text.substr(_begin, text.length()-_begin));
00467         }
00468         _returnToken = _token;
00469         _saveIndex=0;
00470 }
00471 
00472 void CLevmarConfLexer::mCHAR(bool _createToken) {
00473         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00474         _ttype = CHAR;
00475         std::string::size_type _saveIndex;
00476         
00477         {
00478         matchRange('a','z');
00479         }
00480         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00481            _token = makeToken(_ttype);
00482            _token->setText(text.substr(_begin, text.length()-_begin));
00483         }
00484         _returnToken = _token;
00485         _saveIndex=0;
00486 }
00487 
00488 void CLevmarConfLexer::mDIGIT(bool _createToken) {
00489         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00490         _ttype = DIGIT;
00491         std::string::size_type _saveIndex;
00492         
00493         matchRange('0','9');
00494         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00495            _token = makeToken(_ttype);
00496            _token->setText(text.substr(_begin, text.length()-_begin));
00497         }
00498         _returnToken = _token;
00499         _saveIndex=0;
00500 }
00501 
00502 void CLevmarConfLexer::mOTHER(bool _createToken) {
00503         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00504         _ttype = OTHER;
00505         std::string::size_type _saveIndex;
00506         
00507         switch ( LA(1)) {
00508         case 0x27 /* '\'' */ :
00509         {
00510                 match('\'' /* charlit */ );
00511                 break;
00512         }
00513         case 0x23 /* '#' */ :
00514         {
00515                 match('#' /* charlit */ );
00516                 break;
00517         }
00518         case 0x24 /* '$' */ :
00519         {
00520                 match('$' /* charlit */ );
00521                 break;
00522         }
00523         case 0x25 /* '%' */ :
00524         {
00525                 match('%' /* charlit */ );
00526                 break;
00527         }
00528         case 0x26 /* '&' */ :
00529         {
00530                 match('&' /* charlit */ );
00531                 break;
00532         }
00533         case 0x28 /* '(' */ :
00534         {
00535                 match('(' /* charlit */ );
00536                 break;
00537         }
00538         case 0x29 /* ')' */ :
00539         {
00540                 match(')' /* charlit */ );
00541                 break;
00542         }
00543         case 0x2a /* '*' */ :
00544         {
00545                 match('*' /* charlit */ );
00546                 break;
00547         }
00548         case 0x2b /* '+' */ :
00549         {
00550                 match('+' /* charlit */ );
00551                 break;
00552         }
00553         case 0x2c /* ',' */ :
00554         {
00555                 match(',' /* charlit */ );
00556                 break;
00557         }
00558         case 0x2d /* '-' */ :
00559         {
00560                 match('-' /* charlit */ );
00561                 break;
00562         }
00563         case 0x2e /* '.' */ :
00564         {
00565                 match('.' /* charlit */ );
00566                 break;
00567         }
00568         case 0x2f /* '/' */ :
00569         {
00570                 match('/' /* charlit */ );
00571                 break;
00572         }
00573         case 0x3a /* ':' */ :
00574         {
00575                 match(':' /* charlit */ );
00576                 break;
00577         }
00578         case 0x3b /* ';' */ :
00579         {
00580                 match(';' /* charlit */ );
00581                 break;
00582         }
00583         case 0x3c /* '<' */ :
00584         {
00585                 match('<' /* charlit */ );
00586                 break;
00587         }
00588         case 0x3f /* '?' */ :
00589         {
00590                 match('?' /* charlit */ );
00591                 break;
00592         }
00593         case 0x40 /* '@' */ :
00594         {
00595                 match('@' /* charlit */ );
00596                 break;
00597         }
00598         case 0x5b /* '[' */ :
00599         {
00600                 match('[' /* charlit */ );
00601                 break;
00602         }
00603         case 0x5d /* ']' */ :
00604         {
00605                 match(']' /* charlit */ );
00606                 break;
00607         }
00608         case 0x5e /* '^' */ :
00609         {
00610                 match('^' /* charlit */ );
00611                 break;
00612         }
00613         case 0x5f /* '_' */ :
00614         {
00615                 match('_' /* charlit */ );
00616                 break;
00617         }
00618         case 0x7b /* '{' */ :
00619         {
00620                 match('{' /* charlit */ );
00621                 break;
00622         }
00623         case 0x7c /* '|' */ :
00624         {
00625                 match('|' /* charlit */ );
00626                 break;
00627         }
00628         case 0x7d /* '}' */ :
00629         {
00630                 match('}' /* charlit */ );
00631                 break;
00632         }
00633         case 0x7e /* '~' */ :
00634         {
00635                 match('~' /* charlit */ );
00636                 break;
00637         }
00638         default:
00639         {
00640                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00641         }
00642         }
00643         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00644            _token = makeToken(_ttype);
00645            _token->setText(text.substr(_begin, text.length()-_begin));
00646         }
00647         _returnToken = _token;
00648         _saveIndex=0;
00649 }
00650 
00651 void CLevmarConfLexer::mNUMBER(bool _createToken) {
00652         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00653         _ttype = NUMBER;
00654         std::string::size_type _saveIndex;
00655         
00656         {
00657         switch ( LA(1)) {
00658         case 0x2b /* '+' */ :
00659         {
00660                 match('+' /* charlit */ );
00661                 break;
00662         }
00663         case 0x2d /* '-' */ :
00664         {
00665                 match('-' /* charlit */ );
00666                 break;
00667         }
00668         case 0x2e /* '.' */ :
00669         case 0x30 /* '0' */ :
00670         case 0x31 /* '1' */ :
00671         case 0x32 /* '2' */ :
00672         case 0x33 /* '3' */ :
00673         case 0x34 /* '4' */ :
00674         case 0x35 /* '5' */ :
00675         case 0x36 /* '6' */ :
00676         case 0x37 /* '7' */ :
00677         case 0x38 /* '8' */ :
00678         case 0x39 /* '9' */ :
00679         {
00680                 break;
00681         }
00682         default:
00683         {
00684                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00685         }
00686         }
00687         }
00688         {
00689         bool synPredMatched172 = false;
00690         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00691                 int _m172 = mark();
00692                 synPredMatched172 = true;
00693                 inputState->guessing++;
00694                 try {
00695                         {
00696                         mREAL(false);
00697                         }
00698                 }
00699                 catch (antlr::RecognitionException& pe) {
00700                         synPredMatched172 = false;
00701                 }
00702                 rewind(_m172);
00703                 inputState->guessing--;
00704         }
00705         if ( synPredMatched172 ) {
00706                 mREAL(false);
00707         }
00708         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00709                 mINT(false);
00710         }
00711         else {
00712                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00713         }
00714         
00715         }
00716         {
00717         if ((LA(1) == 0x65 /* 'e' */ )) {
00718                 {
00719                 match('e' /* charlit */ );
00720                 }
00721                 {
00722                 switch ( LA(1)) {
00723                 case 0x2b /* '+' */ :
00724                 {
00725                         match('+' /* charlit */ );
00726                         break;
00727                 }
00728                 case 0x2d /* '-' */ :
00729                 {
00730                         match('-' /* charlit */ );
00731                         break;
00732                 }
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                 mINT(false);
00753         }
00754         else {
00755         }
00756         
00757         }
00758         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00759            _token = makeToken(_ttype);
00760            _token->setText(text.substr(_begin, text.length()-_begin));
00761         }
00762         _returnToken = _token;
00763         _saveIndex=0;
00764 }
00765 
00766 void CLevmarConfLexer::mREAL(bool _createToken) {
00767         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00768         _ttype = REAL;
00769         std::string::size_type _saveIndex;
00770         
00771         {
00772         switch ( LA(1)) {
00773         case 0x2e /* '.' */ :
00774         {
00775                 match('.' /* charlit */ );
00776                 mINT(false);
00777                 break;
00778         }
00779         case 0x30 /* '0' */ :
00780         case 0x31 /* '1' */ :
00781         case 0x32 /* '2' */ :
00782         case 0x33 /* '3' */ :
00783         case 0x34 /* '4' */ :
00784         case 0x35 /* '5' */ :
00785         case 0x36 /* '6' */ :
00786         case 0x37 /* '7' */ :
00787         case 0x38 /* '8' */ :
00788         case 0x39 /* '9' */ :
00789         {
00790                 mINT(false);
00791                 match('.' /* charlit */ );
00792                 {
00793                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00794                         mINT(false);
00795                 }
00796                 else {
00797                 }
00798                 
00799                 }
00800                 break;
00801         }
00802         default:
00803         {
00804                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00805         }
00806         }
00807         }
00808         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00809            _token = makeToken(_ttype);
00810            _token->setText(text.substr(_begin, text.length()-_begin));
00811         }
00812         _returnToken = _token;
00813         _saveIndex=0;
00814 }
00815 
00816 void CLevmarConfLexer::mINT(bool _createToken) {
00817         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00818         _ttype = INT;
00819         std::string::size_type _saveIndex;
00820         
00821         { // ( ... )+
00822         int _cnt187=0;
00823         for (;;) {
00824                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00825                         mDIGIT(false);
00826                 }
00827                 else {
00828                         if ( _cnt187>=1 ) { goto _loop187; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00829                 }
00830                 
00831                 _cnt187++;
00832         }
00833         _loop187:;
00834         }  // ( ... )+
00835         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00836            _token = makeToken(_ttype);
00837            _token->setText(text.substr(_begin, text.length()-_begin));
00838         }
00839         _returnToken = _token;
00840         _saveIndex=0;
00841 }
00842 
00843 void CLevmarConfLexer::mCOMMENT(bool _createToken) {
00844         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00845         _ttype = COMMENT;
00846         std::string::size_type _saveIndex;
00847         
00848         match('/' /* charlit */ );
00849         match('/' /* charlit */ );
00850         { // ( ... )*
00851         for (;;) {
00852                 if ((_tokenSet_1.member(LA(1)))) {
00853                         {
00854                         match(_tokenSet_1);
00855                         }
00856                 }
00857                 else {
00858                         goto _loop179;
00859                 }
00860                 
00861         }
00862         _loop179:;
00863         } // ( ... )*
00864         mNEWLINE(false);
00865         if ( inputState->guessing==0 ) {
00866 #line 152 "CLevmarConf.g"
00867                 
00868                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00869                                 
00870 #line 871 "CLevmarConfLexer.cpp"
00871         }
00872         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00873            _token = makeToken(_ttype);
00874            _token->setText(text.substr(_begin, text.length()-_begin));
00875         }
00876         _returnToken = _token;
00877         _saveIndex=0;
00878 }
00879 
00880 void CLevmarConfLexer::mMAXITERT(bool _createToken) {
00881         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00882         _ttype = MAXITERT;
00883         std::string::size_type _saveIndex;
00884         
00885         match("maxiter");
00886         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00887            _token = makeToken(_ttype);
00888            _token->setText(text.substr(_begin, text.length()-_begin));
00889         }
00890         _returnToken = _token;
00891         _saveIndex=0;
00892 }
00893 
00894 void CLevmarConfLexer::mMODET(bool _createToken) {
00895         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00896         _ttype = MODET;
00897         std::string::size_type _saveIndex;
00898         
00899         match("mode");
00900         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00901            _token = makeToken(_ttype);
00902            _token->setText(text.substr(_begin, text.length()-_begin));
00903         }
00904         _returnToken = _token;
00905         _saveIndex=0;
00906 }
00907 
00908 void CLevmarConfLexer::mMTFITT(bool _createToken) {
00909         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00910         _ttype = MTFITT;
00911         std::string::size_type _saveIndex;
00912         
00913         match("mtfit");
00914         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00915            _token = makeToken(_ttype);
00916            _token->setText(text.substr(_begin, text.length()-_begin));
00917         }
00918         _returnToken = _token;
00919         _saveIndex=0;
00920 }
00921 
00922 void CLevmarConfLexer::mMTINPUTDATAT(bool _createToken) {
00923         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00924         _ttype = MTINPUTDATAT;
00925         std::string::size_type _saveIndex;
00926         
00927         match("mtinputdata");
00928         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00929            _token = makeToken(_ttype);
00930            _token->setText(text.substr(_begin, text.length()-_begin));
00931         }
00932         _returnToken = _token;
00933         _saveIndex=0;
00934 }
00935 
00936 void CLevmarConfLexer::mRECINPUTDATAT(bool _createToken) {
00937         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00938         _ttype = RECINPUTDATAT;
00939         std::string::size_type _saveIndex;
00940         
00941         match("recinputdata");
00942         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00943            _token = makeToken(_ttype);
00944            _token->setText(text.substr(_begin, text.length()-_begin));
00945         }
00946         _returnToken = _token;
00947         _saveIndex=0;
00948 }
00949 
00950 void CLevmarConfLexer::mSLOWNESST(bool _createToken) {
00951         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00952         _ttype = SLOWNESST;
00953         std::string::size_type _saveIndex;
00954         
00955         match("slowness");
00956         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00957            _token = makeToken(_ttype);
00958            _token->setText(text.substr(_begin, text.length()-_begin));
00959         }
00960         _returnToken = _token;
00961         _saveIndex=0;
00962 }
00963 
00964 void CLevmarConfLexer::mOMEGAT(bool _createToken) {
00965         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00966         _ttype = OMEGAT;
00967         std::string::size_type _saveIndex;
00968         
00969         match("omega");
00970         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00971            _token = makeToken(_ttype);
00972            _token->setText(text.substr(_begin, text.length()-_begin));
00973         }
00974         _returnToken = _token;
00975         _saveIndex=0;
00976 }
00977 
00978 void CLevmarConfLexer::mSIGMAT(bool _createToken) {
00979         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00980         _ttype = SIGMAT;
00981         std::string::size_type _saveIndex;
00982         
00983         match("sigma");
00984         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00985            _token = makeToken(_ttype);
00986            _token->setText(text.substr(_begin, text.length()-_begin));
00987         }
00988         _returnToken = _token;
00989         _saveIndex=0;
00990 }
00991 
00992 void CLevmarConfLexer::mSHIFTT(bool _createToken) {
00993         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00994         _ttype = SHIFTT;
00995         std::string::size_type _saveIndex;
00996         
00997         match("shift");
00998         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00999            _token = makeToken(_ttype);
01000            _token->setText(text.substr(_begin, text.length()-_begin));
01001         }
01002         _returnToken = _token;
01003         _saveIndex=0;
01004 }
01005 
01006 void CLevmarConfLexer::mWLEVELT(bool _createToken) {
01007         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01008         _ttype = WLEVELT;
01009         std::string::size_type _saveIndex;
01010         
01011         match("wlevel");
01012         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01013            _token = makeToken(_ttype);
01014            _token->setText(text.substr(_begin, text.length()-_begin));
01015         }
01016         _returnToken = _token;
01017         _saveIndex=0;
01018 }
01019 
01020 void CLevmarConfLexer::mPOISSONT(bool _createToken) {
01021         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01022         _ttype = POISSONT;
01023         std::string::size_type _saveIndex;
01024         
01025         match("poisson");
01026         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01027            _token = makeToken(_ttype);
01028            _token->setText(text.substr(_begin, text.length()-_begin));
01029         }
01030         _returnToken = _token;
01031         _saveIndex=0;
01032 }
01033 
01034 void CLevmarConfLexer::mSTARTTIMET(bool _createToken) {
01035         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01036         _ttype = STARTTIMET;
01037         std::string::size_type _saveIndex;
01038         
01039         match("starttime");
01040         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01041            _token = makeToken(_ttype);
01042            _token->setText(text.substr(_begin, text.length()-_begin));
01043         }
01044         _returnToken = _token;
01045         _saveIndex=0;
01046 }
01047 
01048 void CLevmarConfLexer::mENDTIMET(bool _createToken) {
01049         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01050         _ttype = ENDTIMET;
01051         std::string::size_type _saveIndex;
01052         
01053         match("endtime");
01054         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01055            _token = makeToken(_ttype);
01056            _token->setText(text.substr(_begin, text.length()-_begin));
01057         }
01058         _returnToken = _token;
01059         _saveIndex=0;
01060 }
01061 
01062 void CLevmarConfLexer::mTENSORERRORT(bool _createToken) {
01063         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01064         _ttype = TENSORERRORT;
01065         std::string::size_type _saveIndex;
01066         
01067         match("tensorerror");
01068         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01069            _token = makeToken(_ttype);
01070            _token->setText(text.substr(_begin, text.length()-_begin));
01071         }
01072         _returnToken = _token;
01073         _saveIndex=0;
01074 }
01075 
01076 void CLevmarConfLexer::mPHASEERRORT(bool _createToken) {
01077         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01078         _ttype = PHASEERRORT;
01079         std::string::size_type _saveIndex;
01080         
01081         match("phaseerror");
01082         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01083            _token = makeToken(_ttype);
01084            _token->setText(text.substr(_begin, text.length()-_begin));
01085         }
01086         _returnToken = _token;
01087         _saveIndex=0;
01088 }
01089 
01090 void CLevmarConfLexer::mRESERRORT(bool _createToken) {
01091         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01092         _ttype = RESERRORT;
01093         std::string::size_type _saveIndex;
01094         
01095         match("reserror");
01096         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01097            _token = makeToken(_ttype);
01098            _token->setText(text.substr(_begin, text.length()-_begin));
01099         }
01100         _returnToken = _token;
01101         _saveIndex=0;
01102 }
01103 
01104 void CLevmarConfLexer::mRECERRORT(bool _createToken) {
01105         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01106         _ttype = RECERRORT;
01107         std::string::size_type _saveIndex;
01108         
01109         match("recerror");
01110         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01111            _token = makeToken(_ttype);
01112            _token->setText(text.substr(_begin, text.length()-_begin));
01113         }
01114         _returnToken = _token;
01115         _saveIndex=0;
01116 }
01117 
01118 void CLevmarConfLexer::mMINREST(bool _createToken) {
01119         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01120         _ttype = MINREST;
01121         std::string::size_type _saveIndex;
01122         
01123         match("minres");
01124         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01125            _token = makeToken(_ttype);
01126            _token->setText(text.substr(_begin, text.length()-_begin));
01127         }
01128         _returnToken = _token;
01129         _saveIndex=0;
01130 }
01131 
01132 void CLevmarConfLexer::mMAXREST(bool _createToken) {
01133         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01134         _ttype = MAXREST;
01135         std::string::size_type _saveIndex;
01136         
01137         match("maxres");
01138         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01139            _token = makeToken(_ttype);
01140            _token->setText(text.substr(_begin, text.length()-_begin));
01141         }
01142         _returnToken = _token;
01143         _saveIndex=0;
01144 }
01145 
01146 void CLevmarConfLexer::mSTARTREST(bool _createToken) {
01147         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01148         _ttype = STARTREST;
01149         std::string::size_type _saveIndex;
01150         
01151         match("startres");
01152         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01153            _token = makeToken(_ttype);
01154            _token->setText(text.substr(_begin, text.length()-_begin));
01155         }
01156         _returnToken = _token;
01157         _saveIndex=0;
01158 }
01159 
01160 void CLevmarConfLexer::mMINTHICKT(bool _createToken) {
01161         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01162         _ttype = MINTHICKT;
01163         std::string::size_type _saveIndex;
01164         
01165         match("minthick");
01166         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01167            _token = makeToken(_ttype);
01168            _token->setText(text.substr(_begin, text.length()-_begin));
01169         }
01170         _returnToken = _token;
01171         _saveIndex=0;
01172 }
01173 
01174 void CLevmarConfLexer::mMAXTHICKT(bool _createToken) {
01175         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01176         _ttype = MAXTHICKT;
01177         std::string::size_type _saveIndex;
01178         
01179         match("maxthick");
01180         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01181            _token = makeToken(_ttype);
01182            _token->setText(text.substr(_begin, text.length()-_begin));
01183         }
01184         _returnToken = _token;
01185         _saveIndex=0;
01186 }
01187 
01188 void CLevmarConfLexer::mSTARTTHICKT(bool _createToken) {
01189         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01190         _ttype = STARTTHICKT;
01191         std::string::size_type _saveIndex;
01192         
01193         match("startthick");
01194         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01195            _token = makeToken(_ttype);
01196            _token->setText(text.substr(_begin, text.length()-_begin));
01197         }
01198         _returnToken = _token;
01199         _saveIndex=0;
01200 }
01201 
01202 void CLevmarConfLexer::mMINSVELT(bool _createToken) {
01203         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01204         _ttype = MINSVELT;
01205         std::string::size_type _saveIndex;
01206         
01207         match("minsvel");
01208         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01209            _token = makeToken(_ttype);
01210            _token->setText(text.substr(_begin, text.length()-_begin));
01211         }
01212         _returnToken = _token;
01213         _saveIndex=0;
01214 }
01215 
01216 void CLevmarConfLexer::mMAXSVELT(bool _createToken) {
01217         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01218         _ttype = MAXSVELT;
01219         std::string::size_type _saveIndex;
01220         
01221         match("maxsvel");
01222         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01223            _token = makeToken(_ttype);
01224            _token->setText(text.substr(_begin, text.length()-_begin));
01225         }
01226         _returnToken = _token;
01227         _saveIndex=0;
01228 }
01229 
01230 void CLevmarConfLexer::mSTARTSVELT(bool _createToken) {
01231         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01232         _ttype = STARTSVELT;
01233         std::string::size_type _saveIndex;
01234         
01235         match("startsvel");
01236         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01237            _token = makeToken(_ttype);
01238            _token->setText(text.substr(_begin, text.length()-_begin));
01239         }
01240         _returnToken = _token;
01241         _saveIndex=0;
01242 }
01243 
01244 void CLevmarConfLexer::mMINDENST(bool _createToken) {
01245         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01246         _ttype = MINDENST;
01247         std::string::size_type _saveIndex;
01248         
01249         match("mindens");
01250         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01251            _token = makeToken(_ttype);
01252            _token->setText(text.substr(_begin, text.length()-_begin));
01253         }
01254         _returnToken = _token;
01255         _saveIndex=0;
01256 }
01257 
01258 void CLevmarConfLexer::mMAXDENST(bool _createToken) {
01259         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01260         _ttype = MAXDENST;
01261         std::string::size_type _saveIndex;
01262         
01263         match("maxdens");
01264         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01265            _token = makeToken(_ttype);
01266            _token->setText(text.substr(_begin, text.length()-_begin));
01267         }
01268         _returnToken = _token;
01269         _saveIndex=0;
01270 }
01271 
01272 void CLevmarConfLexer::mSTARTDENST(bool _createToken) {
01273         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01274         _ttype = STARTDENST;
01275         std::string::size_type _saveIndex;
01276         
01277         match("startdens");
01278         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01279            _token = makeToken(_ttype);
01280            _token->setText(text.substr(_begin, text.length()-_begin));
01281         }
01282         _returnToken = _token;
01283         _saveIndex=0;
01284 }
01285 
01286 void CLevmarConfLexer::mWEIGHTST(bool _createToken) {
01287         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01288         _ttype = WEIGHTST;
01289         std::string::size_type _saveIndex;
01290         
01291         match("weights");
01292         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01293            _token = makeToken(_ttype);
01294            _token->setText(text.substr(_begin, text.length()-_begin));
01295         }
01296         _returnToken = _token;
01297         _saveIndex=0;
01298 }
01299 
01300 
01301 const unsigned long CLevmarConfLexer::_tokenSet_0_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL };
01302 // . 
01303 const antlr::BitSet CLevmarConfLexer::_tokenSet_0(_tokenSet_0_data_,6);
01304 const unsigned long CLevmarConfLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
01305 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
01306 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
01307 // \" # $ % & \' ( ) * + , - . 
01308 const antlr::BitSet CLevmarConfLexer::_tokenSet_1(_tokenSet_1_data_,8);
01309
Generated on Thu Nov 22 13:58:24 2007 for GPLIB++ by  doxygen 1.5.1