MT Tools » levmarq

CLevanisoConfLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.6 (20070220): "CLevanisoConf.g" -> "CLevanisoConfLexer.cpp"$ */
00002 #include "CLevanisoConfLexer.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 "CLevanisoConf.g"
00012 #line 13 "CLevanisoConfLexer.cpp"
00013 CLevanisoConfLexer::CLevanisoConfLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 CLevanisoConfLexer::CLevanisoConfLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 CLevanisoConfLexer::CLevanisoConfLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void CLevanisoConfLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken CLevanisoConfLexer::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) == 0x70 /* 'p' */ ) && (LA(2) == 0x74 /* 't' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6e /* 'n' */ ) && (LA(5) == 0x73 /* 's' */ ) && (LA(6) == 0x6f /* 'o' */ ) && (LA(7) == 0x72 /* 'r' */ ) && (LA(8) == 0x64 /* 'd' */ ) && (LA(9) == 0x61 /* 'a' */ ) && (LA(10) == 0x74 /* 't' */ )) {
00089                                         mPTENSORDATAT(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) == 0x61 /* 'a' */ ) && (LA(7) == 0x6e /* 'n' */ ) && (LA(8) == 0x69 /* 'i' */ ) && (LA(9) == 0x73 /* 's' */ ) && (LA(10) == 0x6f /* 'o' */ )) {
00105                                         mSTARTANISOT(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) == 0x74 /* 't' */ ) && (LA(8) == 0x72 /* 'r' */ ) && (LA(9) == 0x69 /* 'i' */ ) && (LA(10) == 0x6b /* 'k' */ )) {
00109                                         mSTARTSTRIKET(true);
00110                                         theRetToken=_returnToken;
00111                                 }
00112                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6b /* 'k' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00113                                         mMINSTRIKET(true);
00114                                         theRetToken=_returnToken;
00115                                 }
00116                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x73 /* 's' */ ) && (LA(5) == 0x74 /* 't' */ ) && (LA(6) == 0x72 /* 'r' */ ) && (LA(7) == 0x69 /* 'i' */ ) && (LA(8) == 0x6b /* 'k' */ ) && (LA(9) == 0x65 /* 'e' */ ) && (true)) {
00117                                         mMAXSTRIKET(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) == 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)) {
00125                                         mSTARTREST(true);
00126                                         theRetToken=_returnToken;
00127                                 }
00128                                 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)) {
00129                                         mMINTHICKT(true);
00130                                         theRetToken=_returnToken;
00131                                 }
00132                                 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)) {
00133                                         mMAXTHICKT(true);
00134                                         theRetToken=_returnToken;
00135                                 }
00136                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (LA(4) == 0x61 /* 'a' */ ) && (LA(5) == 0x6e /* 'n' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x6f /* 'o' */ ) && (true) && (true)) {
00137                                         mMINANISOT(true);
00138                                         theRetToken=_returnToken;
00139                                 }
00140                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (LA(4) == 0x61 /* 'a' */ ) && (LA(5) == 0x6e /* 'n' */ ) && (LA(6) == 0x69 /* 'i' */ ) && (LA(7) == 0x73 /* 's' */ ) && (LA(8) == 0x6f /* 'o' */ ) && (true) && (true)) {
00141                                         mMAXANISOT(true);
00142                                         theRetToken=_returnToken;
00143                                 }
00144                                 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)) {
00145                                         mMAXITERT(true);
00146                                         theRetToken=_returnToken;
00147                                 }
00148                                 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)) {
00149                                         mWEIGHTST(true);
00150                                         theRetToken=_returnToken;
00151                                 }
00152                                 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)) {
00153                                         mMINREST(true);
00154                                         theRetToken=_returnToken;
00155                                 }
00156                                 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)) {
00157                                         mMAXREST(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 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)) {
00161                                         mFALSE(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 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)) {
00165                                         mMTFITT(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x72 /* 'r' */ ) && (LA(3) == 0x75 /* 'u' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00169                                         mTRUE(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x6d /* 'm' */ ) && (LA(2) == 0x6f /* 'o' */ ) && (LA(3) == 0x64 /* 'd' */ ) && (LA(4) == 0x65 /* 'e' */ ) && (true) && (true) && (true) && (true) && (true) && (true)) {
00173                                         mMODET(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if (((LA(1) >= 0x61 /* 'a' */  && LA(1) <= 0x7a /* 'z' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00177                                         mSTRING(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                         else {
00181                                 if (LA(1)==EOF_CHAR)
00182                                 {
00183                                         uponEOF();
00184                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00185                                 }
00186                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00187                         }
00188                         }
00189                         if ( !_returnToken )
00190                                 goto tryAgain; // found SKIP token
00191 
00192                         _ttype = _returnToken->getType();
00193                         _ttype = testLiteralsTable(_ttype);
00194                         _returnToken->setType(_ttype);
00195                         return _returnToken;
00196                 }
00197                 catch (antlr::RecognitionException& e) {
00198                                 throw antlr::TokenStreamRecognitionException(e);
00199                 }
00200                 catch (antlr::CharStreamIOException& csie) {
00201                         throw antlr::TokenStreamIOException(csie.io);
00202                 }
00203                 catch (antlr::CharStreamException& cse) {
00204                         throw antlr::TokenStreamException(cse.getMessage());
00205                 }
00206 tryAgain:;
00207         }
00208 }
00209 
00210 void CLevanisoConfLexer::mEQUAL(bool _createToken) {
00211         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00212         _ttype = EQUAL;
00213         std::string::size_type _saveIndex;
00214         
00215         match('=' /* charlit */ );
00216         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00217            _token = makeToken(_ttype);
00218            _token->setText(text.substr(_begin, text.length()-_begin));
00219         }
00220         _returnToken = _token;
00221         _saveIndex=0;
00222 }
00223 
00224 void CLevanisoConfLexer::mTRUE(bool _createToken) {
00225         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00226         _ttype = TRUE;
00227         std::string::size_type _saveIndex;
00228         
00229         match("true");
00230         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00231            _token = makeToken(_ttype);
00232            _token->setText(text.substr(_begin, text.length()-_begin));
00233         }
00234         _returnToken = _token;
00235         _saveIndex=0;
00236 }
00237 
00238 void CLevanisoConfLexer::mFALSE(bool _createToken) {
00239         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00240         _ttype = FALSE;
00241         std::string::size_type _saveIndex;
00242         
00243         match("false");
00244         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00245            _token = makeToken(_ttype);
00246            _token->setText(text.substr(_begin, text.length()-_begin));
00247         }
00248         _returnToken = _token;
00249         _saveIndex=0;
00250 }
00251 
00252 void CLevanisoConfLexer::mWS(bool _createToken) {
00253         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00254         _ttype = WS;
00255         std::string::size_type _saveIndex;
00256         
00257         { // ( ... )+
00258         int _cnt128=0;
00259         for (;;) {
00260                 switch ( LA(1)) {
00261                 case 0x20 /* ' ' */ :
00262                 {
00263                         match(' ' /* charlit */ );
00264                         break;
00265                 }
00266                 case 0xa /* '\n' */ :
00267                 case 0xd /* '\r' */ :
00268                 {
00269                         mNEWLINE(false);
00270                         break;
00271                 }
00272                 case 0x9 /* '\t' */ :
00273                 {
00274                         match('\t' /* charlit */ );
00275                         break;
00276                 }
00277                 default:
00278                 {
00279                         if ( _cnt128>=1 ) { goto _loop128; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00280                 }
00281                 }
00282                 _cnt128++;
00283         }
00284         _loop128:;
00285         }  // ( ... )+
00286         if ( inputState->guessing==0 ) {
00287 #line 117 "CLevanisoConf.g"
00288                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00289 #line 290 "CLevanisoConfLexer.cpp"
00290         }
00291         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00292            _token = makeToken(_ttype);
00293            _token->setText(text.substr(_begin, text.length()-_begin));
00294         }
00295         _returnToken = _token;
00296         _saveIndex=0;
00297 }
00298 
00299 void CLevanisoConfLexer::mNEWLINE(bool _createToken) {
00300         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00301         _ttype = NEWLINE;
00302         std::string::size_type _saveIndex;
00303         
00304         {
00305         switch ( LA(1)) {
00306         case 0xa /* '\n' */ :
00307         {
00308                 match('\n' /* charlit */ );
00309                 break;
00310         }
00311         case 0xd /* '\r' */ :
00312         {
00313                 match('\r' /* charlit */ );
00314                 match('\n' /* charlit */ );
00315                 break;
00316         }
00317         default:
00318         {
00319                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00320         }
00321         }
00322         }
00323         if ( inputState->guessing==0 ) {
00324 #line 143 "CLevanisoConf.g"
00325                 newline();
00326 #line 327 "CLevanisoConfLexer.cpp"
00327         }
00328         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00329            _token = makeToken(_ttype);
00330            _token->setText(text.substr(_begin, text.length()-_begin));
00331         }
00332         _returnToken = _token;
00333         _saveIndex=0;
00334 }
00335 
00336 void CLevanisoConfLexer::mSTRING(bool _createToken) {
00337         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00338         _ttype = STRING;
00339         std::string::size_type _saveIndex;
00340         
00341         mCHAR(false);
00342         { // ( ... )*
00343         for (;;) {
00344                 switch ( LA(1)) {
00345                 case 0x61 /* 'a' */ :
00346                 case 0x62 /* 'b' */ :
00347                 case 0x63 /* 'c' */ :
00348                 case 0x64 /* 'd' */ :
00349                 case 0x65 /* 'e' */ :
00350                 case 0x66 /* 'f' */ :
00351                 case 0x67 /* 'g' */ :
00352                 case 0x68 /* 'h' */ :
00353                 case 0x69 /* 'i' */ :
00354                 case 0x6a /* 'j' */ :
00355                 case 0x6b /* 'k' */ :
00356                 case 0x6c /* 'l' */ :
00357                 case 0x6d /* 'm' */ :
00358                 case 0x6e /* 'n' */ :
00359                 case 0x6f /* 'o' */ :
00360                 case 0x70 /* 'p' */ :
00361                 case 0x71 /* 'q' */ :
00362                 case 0x72 /* 'r' */ :
00363                 case 0x73 /* 's' */ :
00364                 case 0x74 /* 't' */ :
00365                 case 0x75 /* 'u' */ :
00366                 case 0x76 /* 'v' */ :
00367                 case 0x77 /* 'w' */ :
00368                 case 0x78 /* 'x' */ :
00369                 case 0x79 /* 'y' */ :
00370                 case 0x7a /* 'z' */ :
00371                 {
00372                         mCHAR(false);
00373                         break;
00374                 }
00375                 case 0x30 /* '0' */ :
00376                 case 0x31 /* '1' */ :
00377                 case 0x32 /* '2' */ :
00378                 case 0x33 /* '3' */ :
00379                 case 0x34 /* '4' */ :
00380                 case 0x35 /* '5' */ :
00381                 case 0x36 /* '6' */ :
00382                 case 0x37 /* '7' */ :
00383                 case 0x38 /* '8' */ :
00384                 case 0x39 /* '9' */ :
00385                 {
00386                         mDIGIT(false);
00387                         break;
00388                 }
00389                 case 0x23 /* '#' */ :
00390                 case 0x24 /* '$' */ :
00391                 case 0x25 /* '%' */ :
00392                 case 0x26 /* '&' */ :
00393                 case 0x27 /* '\'' */ :
00394                 case 0x28 /* '(' */ :
00395                 case 0x29 /* ')' */ :
00396                 case 0x2a /* '*' */ :
00397                 case 0x2b /* '+' */ :
00398                 case 0x2c /* ',' */ :
00399                 case 0x2d /* '-' */ :
00400                 case 0x2e /* '.' */ :
00401                 case 0x2f /* '/' */ :
00402                 case 0x3a /* ':' */ :
00403                 case 0x3b /* ';' */ :
00404                 case 0x3c /* '<' */ :
00405                 case 0x3f /* '?' */ :
00406                 case 0x40 /* '@' */ :
00407                 case 0x5b /* '[' */ :
00408                 case 0x5d /* ']' */ :
00409                 case 0x5e /* '^' */ :
00410                 case 0x5f /* '_' */ :
00411                 case 0x7b /* '{' */ :
00412                 case 0x7c /* '|' */ :
00413                 case 0x7d /* '}' */ :
00414                 case 0x7e /* '~' */ :
00415                 {
00416                         mOTHER(false);
00417                         break;
00418                 }
00419                 default:
00420                 {
00421                         goto _loop131;
00422                 }
00423                 }
00424         }
00425         _loop131:;
00426         } // ( ... )*
00427         _ttype = testLiteralsTable(_ttype);
00428         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00429            _token = makeToken(_ttype);
00430            _token->setText(text.substr(_begin, text.length()-_begin));
00431         }
00432         _returnToken = _token;
00433         _saveIndex=0;
00434 }
00435 
00436 void CLevanisoConfLexer::mCHAR(bool _createToken) {
00437         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00438         _ttype = CHAR;
00439         std::string::size_type _saveIndex;
00440         
00441         {
00442         matchRange('a','z');
00443         }
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 }
00451 
00452 void CLevanisoConfLexer::mDIGIT(bool _createToken) {
00453         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00454         _ttype = DIGIT;
00455         std::string::size_type _saveIndex;
00456         
00457         matchRange('0','9');
00458         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00459            _token = makeToken(_ttype);
00460            _token->setText(text.substr(_begin, text.length()-_begin));
00461         }
00462         _returnToken = _token;
00463         _saveIndex=0;
00464 }
00465 
00466 void CLevanisoConfLexer::mOTHER(bool _createToken) {
00467         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00468         _ttype = OTHER;
00469         std::string::size_type _saveIndex;
00470         
00471         switch ( LA(1)) {
00472         case 0x27 /* '\'' */ :
00473         {
00474                 match('\'' /* charlit */ );
00475                 break;
00476         }
00477         case 0x23 /* '#' */ :
00478         {
00479                 match('#' /* charlit */ );
00480                 break;
00481         }
00482         case 0x24 /* '$' */ :
00483         {
00484                 match('$' /* charlit */ );
00485                 break;
00486         }
00487         case 0x25 /* '%' */ :
00488         {
00489                 match('%' /* charlit */ );
00490                 break;
00491         }
00492         case 0x26 /* '&' */ :
00493         {
00494                 match('&' /* charlit */ );
00495                 break;
00496         }
00497         case 0x28 /* '(' */ :
00498         {
00499                 match('(' /* charlit */ );
00500                 break;
00501         }
00502         case 0x29 /* ')' */ :
00503         {
00504                 match(')' /* charlit */ );
00505                 break;
00506         }
00507         case 0x2a /* '*' */ :
00508         {
00509                 match('*' /* charlit */ );
00510                 break;
00511         }
00512         case 0x2b /* '+' */ :
00513         {
00514                 match('+' /* charlit */ );
00515                 break;
00516         }
00517         case 0x2c /* ',' */ :
00518         {
00519                 match(',' /* charlit */ );
00520                 break;
00521         }
00522         case 0x2d /* '-' */ :
00523         {
00524                 match('-' /* charlit */ );
00525                 break;
00526         }
00527         case 0x2e /* '.' */ :
00528         {
00529                 match('.' /* charlit */ );
00530                 break;
00531         }
00532         case 0x2f /* '/' */ :
00533         {
00534                 match('/' /* charlit */ );
00535                 break;
00536         }
00537         case 0x3a /* ':' */ :
00538         {
00539                 match(':' /* charlit */ );
00540                 break;
00541         }
00542         case 0x3b /* ';' */ :
00543         {
00544                 match(';' /* charlit */ );
00545                 break;
00546         }
00547         case 0x3c /* '<' */ :
00548         {
00549                 match('<' /* charlit */ );
00550                 break;
00551         }
00552         case 0x3f /* '?' */ :
00553         {
00554                 match('?' /* charlit */ );
00555                 break;
00556         }
00557         case 0x40 /* '@' */ :
00558         {
00559                 match('@' /* charlit */ );
00560                 break;
00561         }
00562         case 0x5b /* '[' */ :
00563         {
00564                 match('[' /* charlit */ );
00565                 break;
00566         }
00567         case 0x5d /* ']' */ :
00568         {
00569                 match(']' /* charlit */ );
00570                 break;
00571         }
00572         case 0x5e /* '^' */ :
00573         {
00574                 match('^' /* charlit */ );
00575                 break;
00576         }
00577         case 0x5f /* '_' */ :
00578         {
00579                 match('_' /* charlit */ );
00580                 break;
00581         }
00582         case 0x7b /* '{' */ :
00583         {
00584                 match('{' /* charlit */ );
00585                 break;
00586         }
00587         case 0x7c /* '|' */ :
00588         {
00589                 match('|' /* charlit */ );
00590                 break;
00591         }
00592         case 0x7d /* '}' */ :
00593         {
00594                 match('}' /* charlit */ );
00595                 break;
00596         }
00597         case 0x7e /* '~' */ :
00598         {
00599                 match('~' /* charlit */ );
00600                 break;
00601         }
00602         default:
00603         {
00604                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00605         }
00606         }
00607         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00608            _token = makeToken(_ttype);
00609            _token->setText(text.substr(_begin, text.length()-_begin));
00610         }
00611         _returnToken = _token;
00612         _saveIndex=0;
00613 }
00614 
00615 void CLevanisoConfLexer::mNUMBER(bool _createToken) {
00616         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00617         _ttype = NUMBER;
00618         std::string::size_type _saveIndex;
00619         
00620         {
00621         switch ( LA(1)) {
00622         case 0x2b /* '+' */ :
00623         {
00624                 match('+' /* charlit */ );
00625                 break;
00626         }
00627         case 0x2d /* '-' */ :
00628         {
00629                 match('-' /* charlit */ );
00630                 break;
00631         }
00632         case 0x2e /* '.' */ :
00633         case 0x30 /* '0' */ :
00634         case 0x31 /* '1' */ :
00635         case 0x32 /* '2' */ :
00636         case 0x33 /* '3' */ :
00637         case 0x34 /* '4' */ :
00638         case 0x35 /* '5' */ :
00639         case 0x36 /* '6' */ :
00640         case 0x37 /* '7' */ :
00641         case 0x38 /* '8' */ :
00642         case 0x39 /* '9' */ :
00643         {
00644                 break;
00645         }
00646         default:
00647         {
00648                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00649         }
00650         }
00651         }
00652         {
00653         bool synPredMatched136 = false;
00654         if (((_tokenSet_0.member(LA(1))) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00655                 int _m136 = mark();
00656                 synPredMatched136 = true;
00657                 inputState->guessing++;
00658                 try {
00659                         {
00660                         mREAL(false);
00661                         }
00662                 }
00663                 catch (antlr::RecognitionException& pe) {
00664                         synPredMatched136 = false;
00665                 }
00666                 rewind(_m136);
00667                 inputState->guessing--;
00668         }
00669         if ( synPredMatched136 ) {
00670                 mREAL(false);
00671         }
00672         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00673                 mINT(false);
00674         }
00675         else {
00676                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00677         }
00678         
00679         }
00680         {
00681         if ((LA(1) == 0x65 /* 'e' */ )) {
00682                 {
00683                 match('e' /* charlit */ );
00684                 }
00685                 {
00686                 switch ( LA(1)) {
00687                 case 0x2b /* '+' */ :
00688                 {
00689                         match('+' /* charlit */ );
00690                         break;
00691                 }
00692                 case 0x2d /* '-' */ :
00693                 {
00694                         match('-' /* charlit */ );
00695                         break;
00696                 }
00697                 case 0x30 /* '0' */ :
00698                 case 0x31 /* '1' */ :
00699                 case 0x32 /* '2' */ :
00700                 case 0x33 /* '3' */ :
00701                 case 0x34 /* '4' */ :
00702                 case 0x35 /* '5' */ :
00703                 case 0x36 /* '6' */ :
00704                 case 0x37 /* '7' */ :
00705                 case 0x38 /* '8' */ :
00706                 case 0x39 /* '9' */ :
00707                 {
00708                         break;
00709                 }
00710                 default:
00711                 {
00712                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00713                 }
00714                 }
00715                 }
00716                 mINT(false);
00717         }
00718         else {
00719         }
00720         
00721         }
00722         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00723            _token = makeToken(_ttype);
00724            _token->setText(text.substr(_begin, text.length()-_begin));
00725         }
00726         _returnToken = _token;
00727         _saveIndex=0;
00728 }
00729 
00730 void CLevanisoConfLexer::mREAL(bool _createToken) {
00731         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00732         _ttype = REAL;
00733         std::string::size_type _saveIndex;
00734         
00735         {
00736         switch ( LA(1)) {
00737         case 0x2e /* '.' */ :
00738         {
00739                 match('.' /* charlit */ );
00740                 mINT(false);
00741                 break;
00742         }
00743         case 0x30 /* '0' */ :
00744         case 0x31 /* '1' */ :
00745         case 0x32 /* '2' */ :
00746         case 0x33 /* '3' */ :
00747         case 0x34 /* '4' */ :
00748         case 0x35 /* '5' */ :
00749         case 0x36 /* '6' */ :
00750         case 0x37 /* '7' */ :
00751         case 0x38 /* '8' */ :
00752         case 0x39 /* '9' */ :
00753         {
00754                 mINT(false);
00755                 match('.' /* charlit */ );
00756                 {
00757                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00758                         mINT(false);
00759                 }
00760                 else {
00761                 }
00762                 
00763                 }
00764                 break;
00765         }
00766         default:
00767         {
00768                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00769         }
00770         }
00771         }
00772         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00773            _token = makeToken(_ttype);
00774            _token->setText(text.substr(_begin, text.length()-_begin));
00775         }
00776         _returnToken = _token;
00777         _saveIndex=0;
00778 }
00779 
00780 void CLevanisoConfLexer::mINT(bool _createToken) {
00781         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00782         _ttype = INT;
00783         std::string::size_type _saveIndex;
00784         
00785         { // ( ... )+
00786         int _cnt151=0;
00787         for (;;) {
00788                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00789                         mDIGIT(false);
00790                 }
00791                 else {
00792                         if ( _cnt151>=1 ) { goto _loop151; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00793                 }
00794                 
00795                 _cnt151++;
00796         }
00797         _loop151:;
00798         }  // ( ... )+
00799         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00800            _token = makeToken(_ttype);
00801            _token->setText(text.substr(_begin, text.length()-_begin));
00802         }
00803         _returnToken = _token;
00804         _saveIndex=0;
00805 }
00806 
00807 void CLevanisoConfLexer::mCOMMENT(bool _createToken) {
00808         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00809         _ttype = COMMENT;
00810         std::string::size_type _saveIndex;
00811         
00812         match('/' /* charlit */ );
00813         match('/' /* charlit */ );
00814         { // ( ... )*
00815         for (;;) {
00816                 if ((_tokenSet_1.member(LA(1)))) {
00817                         {
00818                         match(_tokenSet_1);
00819                         }
00820                 }
00821                 else {
00822                         goto _loop143;
00823                 }
00824                 
00825         }
00826         _loop143:;
00827         } // ( ... )*
00828         mNEWLINE(false);
00829         if ( inputState->guessing==0 ) {
00830 #line 134 "CLevanisoConf.g"
00831                 
00832                                         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00833                                 
00834 #line 835 "CLevanisoConfLexer.cpp"
00835         }
00836         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00837            _token = makeToken(_ttype);
00838            _token->setText(text.substr(_begin, text.length()-_begin));
00839         }
00840         _returnToken = _token;
00841         _saveIndex=0;
00842 }
00843 
00844 void CLevanisoConfLexer::mMAXITERT(bool _createToken) {
00845         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00846         _ttype = MAXITERT;
00847         std::string::size_type _saveIndex;
00848         
00849         match("maxiter");
00850         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00851            _token = makeToken(_ttype);
00852            _token->setText(text.substr(_begin, text.length()-_begin));
00853         }
00854         _returnToken = _token;
00855         _saveIndex=0;
00856 }
00857 
00858 void CLevanisoConfLexer::mMODET(bool _createToken) {
00859         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00860         _ttype = MODET;
00861         std::string::size_type _saveIndex;
00862         
00863         match("mode");
00864         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00865            _token = makeToken(_ttype);
00866            _token->setText(text.substr(_begin, text.length()-_begin));
00867         }
00868         _returnToken = _token;
00869         _saveIndex=0;
00870 }
00871 
00872 void CLevanisoConfLexer::mMTFITT(bool _createToken) {
00873         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00874         _ttype = MTFITT;
00875         std::string::size_type _saveIndex;
00876         
00877         match("mtfit");
00878         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00879            _token = makeToken(_ttype);
00880            _token->setText(text.substr(_begin, text.length()-_begin));
00881         }
00882         _returnToken = _token;
00883         _saveIndex=0;
00884 }
00885 
00886 void CLevanisoConfLexer::mMTINPUTDATAT(bool _createToken) {
00887         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00888         _ttype = MTINPUTDATAT;
00889         std::string::size_type _saveIndex;
00890         
00891         match("mtinputdata");
00892         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00893            _token = makeToken(_ttype);
00894            _token->setText(text.substr(_begin, text.length()-_begin));
00895         }
00896         _returnToken = _token;
00897         _saveIndex=0;
00898 }
00899 
00900 void CLevanisoConfLexer::mPTENSORDATAT(bool _createToken) {
00901         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00902         _ttype = PTENSORDATAT;
00903         std::string::size_type _saveIndex;
00904         
00905         match("ptensordata");
00906         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00907            _token = makeToken(_ttype);
00908            _token->setText(text.substr(_begin, text.length()-_begin));
00909         }
00910         _returnToken = _token;
00911         _saveIndex=0;
00912 }
00913 
00914 void CLevanisoConfLexer::mTENSORERRORT(bool _createToken) {
00915         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00916         _ttype = TENSORERRORT;
00917         std::string::size_type _saveIndex;
00918         
00919         match("tensorerror");
00920         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00921            _token = makeToken(_ttype);
00922            _token->setText(text.substr(_begin, text.length()-_begin));
00923         }
00924         _returnToken = _token;
00925         _saveIndex=0;
00926 }
00927 
00928 void CLevanisoConfLexer::mPHASEERRORT(bool _createToken) {
00929         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00930         _ttype = PHASEERRORT;
00931         std::string::size_type _saveIndex;
00932         
00933         match("phaseerror");
00934         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00935            _token = makeToken(_ttype);
00936            _token->setText(text.substr(_begin, text.length()-_begin));
00937         }
00938         _returnToken = _token;
00939         _saveIndex=0;
00940 }
00941 
00942 void CLevanisoConfLexer::mRESERRORT(bool _createToken) {
00943         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00944         _ttype = RESERRORT;
00945         std::string::size_type _saveIndex;
00946         
00947         match("reserror");
00948         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00949            _token = makeToken(_ttype);
00950            _token->setText(text.substr(_begin, text.length()-_begin));
00951         }
00952         _returnToken = _token;
00953         _saveIndex=0;
00954 }
00955 
00956 void CLevanisoConfLexer::mMINREST(bool _createToken) {
00957         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00958         _ttype = MINREST;
00959         std::string::size_type _saveIndex;
00960         
00961         match("minres");
00962         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00963            _token = makeToken(_ttype);
00964            _token->setText(text.substr(_begin, text.length()-_begin));
00965         }
00966         _returnToken = _token;
00967         _saveIndex=0;
00968 }
00969 
00970 void CLevanisoConfLexer::mMAXREST(bool _createToken) {
00971         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00972         _ttype = MAXREST;
00973         std::string::size_type _saveIndex;
00974         
00975         match("maxres");
00976         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00977            _token = makeToken(_ttype);
00978            _token->setText(text.substr(_begin, text.length()-_begin));
00979         }
00980         _returnToken = _token;
00981         _saveIndex=0;
00982 }
00983 
00984 void CLevanisoConfLexer::mSTARTREST(bool _createToken) {
00985         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00986         _ttype = STARTREST;
00987         std::string::size_type _saveIndex;
00988         
00989         match("startres");
00990         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00991            _token = makeToken(_ttype);
00992            _token->setText(text.substr(_begin, text.length()-_begin));
00993         }
00994         _returnToken = _token;
00995         _saveIndex=0;
00996 }
00997 
00998 void CLevanisoConfLexer::mMINTHICKT(bool _createToken) {
00999         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01000         _ttype = MINTHICKT;
01001         std::string::size_type _saveIndex;
01002         
01003         match("minthick");
01004         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01005            _token = makeToken(_ttype);
01006            _token->setText(text.substr(_begin, text.length()-_begin));
01007         }
01008         _returnToken = _token;
01009         _saveIndex=0;
01010 }
01011 
01012 void CLevanisoConfLexer::mMAXTHICKT(bool _createToken) {
01013         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01014         _ttype = MAXTHICKT;
01015         std::string::size_type _saveIndex;
01016         
01017         match("maxthick");
01018         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01019            _token = makeToken(_ttype);
01020            _token->setText(text.substr(_begin, text.length()-_begin));
01021         }
01022         _returnToken = _token;
01023         _saveIndex=0;
01024 }
01025 
01026 void CLevanisoConfLexer::mSTARTTHICKT(bool _createToken) {
01027         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01028         _ttype = STARTTHICKT;
01029         std::string::size_type _saveIndex;
01030         
01031         match("startthick");
01032         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01033            _token = makeToken(_ttype);
01034            _token->setText(text.substr(_begin, text.length()-_begin));
01035         }
01036         _returnToken = _token;
01037         _saveIndex=0;
01038 }
01039 
01040 void CLevanisoConfLexer::mMINANISOT(bool _createToken) {
01041         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01042         _ttype = MINANISOT;
01043         std::string::size_type _saveIndex;
01044         
01045         match("minaniso");
01046         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01047            _token = makeToken(_ttype);
01048            _token->setText(text.substr(_begin, text.length()-_begin));
01049         }
01050         _returnToken = _token;
01051         _saveIndex=0;
01052 }
01053 
01054 void CLevanisoConfLexer::mMAXANISOT(bool _createToken) {
01055         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01056         _ttype = MAXANISOT;
01057         std::string::size_type _saveIndex;
01058         
01059         match("maxaniso");
01060         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01061            _token = makeToken(_ttype);
01062            _token->setText(text.substr(_begin, text.length()-_begin));
01063         }
01064         _returnToken = _token;
01065         _saveIndex=0;
01066 }
01067 
01068 void CLevanisoConfLexer::mSTARTANISOT(bool _createToken) {
01069         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01070         _ttype = STARTANISOT;
01071         std::string::size_type _saveIndex;
01072         
01073         match("startaniso");
01074         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01075            _token = makeToken(_ttype);
01076            _token->setText(text.substr(_begin, text.length()-_begin));
01077         }
01078         _returnToken = _token;
01079         _saveIndex=0;
01080 }
01081 
01082 void CLevanisoConfLexer::mMINSTRIKET(bool _createToken) {
01083         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01084         _ttype = MINSTRIKET;
01085         std::string::size_type _saveIndex;
01086         
01087         match("minstrike");
01088         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01089            _token = makeToken(_ttype);
01090            _token->setText(text.substr(_begin, text.length()-_begin));
01091         }
01092         _returnToken = _token;
01093         _saveIndex=0;
01094 }
01095 
01096 void CLevanisoConfLexer::mMAXSTRIKET(bool _createToken) {
01097         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01098         _ttype = MAXSTRIKET;
01099         std::string::size_type _saveIndex;
01100         
01101         match("maxstrike");
01102         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01103            _token = makeToken(_ttype);
01104            _token->setText(text.substr(_begin, text.length()-_begin));
01105         }
01106         _returnToken = _token;
01107         _saveIndex=0;
01108 }
01109 
01110 void CLevanisoConfLexer::mSTARTSTRIKET(bool _createToken) {
01111         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01112         _ttype = STARTSTRIKET;
01113         std::string::size_type _saveIndex;
01114         
01115         match("startstrike");
01116         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01117            _token = makeToken(_ttype);
01118            _token->setText(text.substr(_begin, text.length()-_begin));
01119         }
01120         _returnToken = _token;
01121         _saveIndex=0;
01122 }
01123 
01124 void CLevanisoConfLexer::mWEIGHTST(bool _createToken) {
01125         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01126         _ttype = WEIGHTST;
01127         std::string::size_type _saveIndex;
01128         
01129         match("weights");
01130         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01131            _token = makeToken(_ttype);
01132            _token->setText(text.substr(_begin, text.length()-_begin));
01133         }
01134         _returnToken = _token;
01135         _saveIndex=0;
01136 }
01137 
01138 
01139 const unsigned long CLevanisoConfLexer::_tokenSet_0_data_[] = { 0UL, 67059712UL, 0UL, 0UL, 0UL, 0UL };
01140 const antlr::BitSet CLevanisoConfLexer::_tokenSet_0(_tokenSet_0_data_,6);
01141 const unsigned long CLevanisoConfLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
01142 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
01143 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
01144 // \" # $ % 
01145 const antlr::BitSet CLevanisoConfLexer::_tokenSet_1(_tokenSet_1_data_,8);
01146
Generated on Thu Nov 22 13:58:24 2007 for GPLIB++ by  doxygen 1.5.1