Universal Accelerator Parser: ExpressionLexer.cpp Source File

00001 /* $ANTLR 2.7.0: "Expression.g" -> "ExpressionLexer.cpp"$ */
00002 #include "ExpressionLexer.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 
00012   #include <string>
00013   #include <algorithm>
00014 
00015 ExpressionLexer::ExpressionLexer(ANTLR_USE_NAMESPACE(std)istream& in)
00016         : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in))
00017 {
00018         setCaseSensitive(false);
00019         initLiterals();
00020 }
00021 
00022 ExpressionLexer::ExpressionLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
00023         : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib)
00024 {
00025         setCaseSensitive(false);
00026         initLiterals();
00027 }
00028 
00029 ExpressionLexer::ExpressionLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
00030         : ANTLR_USE_NAMESPACE(antlr)CharScanner(state)
00031 {
00032         setCaseSensitive(false);
00033         initLiterals();
00034 }
00035 
00036 void ExpressionLexer::initLiterals()
00037 {
00038         literals["ran"] = 38;
00039         literals["min"] = 37;
00040         literals["sqrt"] = 25;
00041         literals["atan"] = 33;
00042         literals["ran_gauss"] = 39;
00043         literals["log"] = 26;
00044         literals["user0"] = 43;
00045         literals["abs"] = 35;
00046         literals["randf"] = 40;
00047         literals["exp"] = 27;
00048         literals["tgauss"] = 42;
00049         literals["sin"] = 28;
00050         literals["gauss"] = 41;
00051         literals["user2"] = 45;
00052         literals["cos"] = 29;
00053         literals["max"] = 36;
00054         literals["."] = 19;
00055         literals["asin"] = 31;
00056         literals["atan2"] = 34;
00057         literals["tan"] = 30;
00058         literals["acos"] = 32;
00059         literals["user1"] = 44;
00060 }
00061 bool ExpressionLexer::getCaseSensitiveLiterals() const
00062 {
00063         return false;
00064 }
00065 
00066 ANTLR_USE_NAMESPACE(antlr)RefToken ExpressionLexer::nextToken()
00067 {
00068         ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00069         for (;;) {
00070                 ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00071                 int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
00072                 resetText();
00073                 try {   // for char stream error handling
00074                         try {   // for lexical error handling
00075                                 switch ( LA(1)) {
00076                                 case static_cast<unsigned char>('\t'):
00077                                 case static_cast<unsigned char>('\n'):
00078                                 case static_cast<unsigned char>('\r'):
00079                                 case static_cast<unsigned char>(' '):
00080                                 {
00081                                         mWS_(true);
00082                                         theRetToken=_returnToken;
00083                                         break;
00084                                 }
00085                                 case static_cast<unsigned char>('('):
00086                                 {
00087                                         mLPAREN(true);
00088                                         theRetToken=_returnToken;
00089                                         break;
00090                                 }
00091                                 case static_cast<unsigned char>(')'):
00092                                 {
00093                                         mRPAREN(true);
00094                                         theRetToken=_returnToken;
00095                                         break;
00096                                 }
00097                                 case static_cast<unsigned char>('['):
00098                                 {
00099                                         mLBRACKET(true);
00100                                         theRetToken=_returnToken;
00101                                         break;
00102                                 }
00103                                 case static_cast<unsigned char>(']'):
00104                                 {
00105                                         mRBRACKET(true);
00106                                         theRetToken=_returnToken;
00107                                         break;
00108                                 }
00109                                 case static_cast<unsigned char>('+'):
00110                                 {
00111                                         mPLUS(true);
00112                                         theRetToken=_returnToken;
00113                                         break;
00114                                 }
00115                                 case static_cast<unsigned char>('-'):
00116                                 {
00117                                         mMINUS(true);
00118                                         theRetToken=_returnToken;
00119                                         break;
00120                                 }
00121                                 case static_cast<unsigned char>('*'):
00122                                 {
00123                                         mMULT(true);
00124                                         theRetToken=_returnToken;
00125                                         break;
00126                                 }
00127                                 case static_cast<unsigned char>('/'):
00128                                 {
00129                                         mDIV(true);
00130                                         theRetToken=_returnToken;
00131                                         break;
00132                                 }
00133                                 case static_cast<unsigned char>('%'):
00134                                 {
00135                                         mMOD(true);
00136                                         theRetToken=_returnToken;
00137                                         break;
00138                                 }
00139                                 case static_cast<unsigned char>('^'):
00140                                 {
00141                                         mPOW(true);
00142                                         theRetToken=_returnToken;
00143                                         break;
00144                                 }
00145                                 case static_cast<unsigned char>(','):
00146                                 {
00147                                         mCOMMA(true);
00148                                         theRetToken=_returnToken;
00149                                         break;
00150                                 }
00151                                 case static_cast<unsigned char>(':'):
00152                                 {
00153                                         mCOLON(true);
00154                                         theRetToken=_returnToken;
00155                                         break;
00156                                 }
00157                                 case static_cast<unsigned char>('='):
00158                                 {
00159                                         mEQUAL(true);
00160                                         theRetToken=_returnToken;
00161                                         break;
00162                                 }
00163                                 case static_cast<unsigned char>('@'):
00164                                 {
00165                                         mAT(true);
00166                                         theRetToken=_returnToken;
00167                                         break;
00168                                 }
00169                                 case static_cast<unsigned char>(';'):
00170                                 {
00171                                         mSEMI(true);
00172                                         theRetToken=_returnToken;
00173                                         break;
00174                                 }
00175                                 case static_cast<unsigned char>('a'):
00176                                 case static_cast<unsigned char>('b'):
00177                                 case static_cast<unsigned char>('c'):
00178                                 case static_cast<unsigned char>('d'):
00179                                 case static_cast<unsigned char>('e'):
00180                                 case static_cast<unsigned char>('f'):
00181                                 case static_cast<unsigned char>('g'):
00182                                 case static_cast<unsigned char>('h'):
00183                                 case static_cast<unsigned char>('i'):
00184                                 case static_cast<unsigned char>('j'):
00185                                 case static_cast<unsigned char>('k'):
00186                                 case static_cast<unsigned char>('l'):
00187                                 case static_cast<unsigned char>('m'):
00188                                 case static_cast<unsigned char>('n'):
00189                                 case static_cast<unsigned char>('o'):
00190                                 case static_cast<unsigned char>('p'):
00191                                 case static_cast<unsigned char>('q'):
00192                                 case static_cast<unsigned char>('r'):
00193                                 case static_cast<unsigned char>('s'):
00194                                 case static_cast<unsigned char>('t'):
00195                                 case static_cast<unsigned char>('u'):
00196                                 case static_cast<unsigned char>('v'):
00197                                 case static_cast<unsigned char>('w'):
00198                                 case static_cast<unsigned char>('x'):
00199                                 case static_cast<unsigned char>('y'):
00200                                 case static_cast<unsigned char>('z'):
00201                                 {
00202                                         mIDENT(true);
00203                                         theRetToken=_returnToken;
00204                                         break;
00205                                 }
00206                                 case static_cast<unsigned char>('.'):
00207                                 {
00208                                         mNUM_FLOAT(true);
00209                                         theRetToken=_returnToken;
00210                                         break;
00211                                 }
00212                                 case static_cast<unsigned char>('0'):
00213                                 case static_cast<unsigned char>('1'):
00214                                 case static_cast<unsigned char>('2'):
00215                                 case static_cast<unsigned char>('3'):
00216                                 case static_cast<unsigned char>('4'):
00217                                 case static_cast<unsigned char>('5'):
00218                                 case static_cast<unsigned char>('6'):
00219                                 case static_cast<unsigned char>('7'):
00220                                 case static_cast<unsigned char>('8'):
00221                                 case static_cast<unsigned char>('9'):
00222                                 {
00223                                         mNUM_DOUBLE(true);
00224                                         theRetToken=_returnToken;
00225                                         break;
00226                                 }
00227                                 case static_cast<unsigned char>('\''):
00228                                 {
00229                                         mSTRING_LITERAL_S(true);
00230                                         theRetToken=_returnToken;
00231                                         break;
00232                                 }
00233                                 case static_cast<unsigned char>('"'):
00234                                 {
00235                                         mSTRING_LITERAL_D(true);
00236                                         theRetToken=_returnToken;
00237                                         break;
00238                                 }
00239                                 default:
00240                                 {
00241                                         if (LA(1)==EOF_CHAR) {uponEOF(); _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);}
00242                                 else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());}
00243                                 }
00244                                 }
00245                                 if ( !_returnToken ) goto tryAgain; // found SKIP token
00246                                 _ttype = _returnToken->getType();
00247                                 _ttype = testLiteralsTable(_ttype);
00248                                 _returnToken->setType(_ttype);
00249                                 return _returnToken;
00250                         }
00251                         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
00252                                 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
00253                         }
00254                 }
00255                 catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
00256                    throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
00257                 }
00258                 catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
00259                    throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
00260                 }
00261 tryAgain:;
00262         }
00263 }
00264 
00265 void ExpressionLexer::mWS_(bool _createToken) {
00266         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00267         _ttype = WS_;
00268         int _saveIndex;
00269         
00270         {
00271         switch ( LA(1)) {
00272         case static_cast<unsigned char>(' '):
00273         {
00274                 match(static_cast<unsigned char>(' '));
00275                 break;
00276         }
00277         case static_cast<unsigned char>('\t'):
00278         {
00279                 match(static_cast<unsigned char>('\t'));
00280                 break;
00281         }
00282         case static_cast<unsigned char>('\n'):
00283         {
00284                 match(static_cast<unsigned char>('\n'));
00285                 break;
00286         }
00287         case static_cast<unsigned char>('\r'):
00288         {
00289                 match(static_cast<unsigned char>('\r'));
00290                 break;
00291         }
00292         default:
00293         {
00294                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());
00295         }
00296         }
00297         }
00298         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00299         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00300            _token = makeToken(_ttype);
00301            _token->setText(text.substr(_begin, text.length()-_begin));
00302         }
00303         _returnToken = _token;
00304 }
00305 
00306 void ExpressionLexer::mLPAREN(bool _createToken) {
00307         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00308         _ttype = LPAREN;
00309         int _saveIndex;
00310         
00311         match(static_cast<unsigned char>('('));
00312         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00313            _token = makeToken(_ttype);
00314            _token->setText(text.substr(_begin, text.length()-_begin));
00315         }
00316         _returnToken = _token;
00317 }
00318 
00319 void ExpressionLexer::mRPAREN(bool _createToken) {
00320         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00321         _ttype = RPAREN;
00322         int _saveIndex;
00323         
00324         match(static_cast<unsigned char>(')'));
00325         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00326            _token = makeToken(_ttype);
00327            _token->setText(text.substr(_begin, text.length()-_begin));
00328         }
00329         _returnToken = _token;
00330 }
00331 
00332 void ExpressionLexer::mLBRACKET(bool _createToken) {
00333         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00334         _ttype = LBRACKET;
00335         int _saveIndex;
00336         
00337         match(static_cast<unsigned char>('['));
00338         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00339            _token = makeToken(_ttype);
00340            _token->setText(text.substr(_begin, text.length()-_begin));
00341         }
00342         _returnToken = _token;
00343 }
00344 
00345 void ExpressionLexer::mRBRACKET(bool _createToken) {
00346         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00347         _ttype = RBRACKET;
00348         int _saveIndex;
00349         
00350         match(static_cast<unsigned char>(']'));
00351         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00352            _token = makeToken(_ttype);
00353            _token->setText(text.substr(_begin, text.length()-_begin));
00354         }
00355         _returnToken = _token;
00356 }
00357 
00358 void ExpressionLexer::mPLUS(bool _createToken) {
00359         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00360         _ttype = PLUS;
00361         int _saveIndex;
00362         
00363         match(static_cast<unsigned char>('+'));
00364         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00365            _token = makeToken(_ttype);
00366            _token->setText(text.substr(_begin, text.length()-_begin));
00367         }
00368         _returnToken = _token;
00369 }
00370 
00371 void ExpressionLexer::mMINUS(bool _createToken) {
00372         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00373         _ttype = MINUS;
00374         int _saveIndex;
00375         
00376         match(static_cast<unsigned char>('-'));
00377         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00378            _token = makeToken(_ttype);
00379            _token->setText(text.substr(_begin, text.length()-_begin));
00380         }
00381         _returnToken = _token;
00382 }
00383 
00384 void ExpressionLexer::mMULT(bool _createToken) {
00385         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00386         _ttype = MULT;
00387         int _saveIndex;
00388         
00389         match(static_cast<unsigned char>('*'));
00390         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00391            _token = makeToken(_ttype);
00392            _token->setText(text.substr(_begin, text.length()-_begin));
00393         }
00394         _returnToken = _token;
00395 }
00396 
00397 void ExpressionLexer::mDIV(bool _createToken) {
00398         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00399         _ttype = DIV;
00400         int _saveIndex;
00401         
00402         match(static_cast<unsigned char>('/'));
00403         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00404            _token = makeToken(_ttype);
00405            _token->setText(text.substr(_begin, text.length()-_begin));
00406         }
00407         _returnToken = _token;
00408 }
00409 
00410 void ExpressionLexer::mMOD(bool _createToken) {
00411         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00412         _ttype = MOD;
00413         int _saveIndex;
00414         
00415         match(static_cast<unsigned char>('%'));
00416         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00417            _token = makeToken(_ttype);
00418            _token->setText(text.substr(_begin, text.length()-_begin));
00419         }
00420         _returnToken = _token;
00421 }
00422 
00423 void ExpressionLexer::mPOW(bool _createToken) {
00424         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00425         _ttype = POW;
00426         int _saveIndex;
00427         
00428         match(static_cast<unsigned char>('^'));
00429         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00430            _token = makeToken(_ttype);
00431            _token->setText(text.substr(_begin, text.length()-_begin));
00432         }
00433         _returnToken = _token;
00434 }
00435 
00436 void ExpressionLexer::mCOMMA(bool _createToken) {
00437         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00438         _ttype = COMMA;
00439         int _saveIndex;
00440         
00441         match(static_cast<unsigned char>(','));
00442         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00443            _token = makeToken(_ttype);
00444            _token->setText(text.substr(_begin, text.length()-_begin));
00445         }
00446         _returnToken = _token;
00447 }
00448 
00449 void ExpressionLexer::mCOLON(bool _createToken) {
00450         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00451         _ttype = COLON;
00452         int _saveIndex;
00453         
00454         match(static_cast<unsigned char>(':'));
00455         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00456            _token = makeToken(_ttype);
00457            _token->setText(text.substr(_begin, text.length()-_begin));
00458         }
00459         _returnToken = _token;
00460 }
00461 
00462 void ExpressionLexer::mEQUAL(bool _createToken) {
00463         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00464         _ttype = EQUAL;
00465         int _saveIndex;
00466         
00467         match(static_cast<unsigned char>('='));
00468         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00469            _token = makeToken(_ttype);
00470            _token->setText(text.substr(_begin, text.length()-_begin));
00471         }
00472         _returnToken = _token;
00473 }
00474 
00475 void ExpressionLexer::mAT(bool _createToken) {
00476         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00477         _ttype = AT;
00478         int _saveIndex;
00479         
00480         match(static_cast<unsigned char>('@'));
00481         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00482            _token = makeToken(_ttype);
00483            _token->setText(text.substr(_begin, text.length()-_begin));
00484         }
00485         _returnToken = _token;
00486 }
00487 
00488 void ExpressionLexer::mSEMI(bool _createToken) {
00489         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00490         _ttype = SEMI;
00491         int _saveIndex;
00492         
00493         match(static_cast<unsigned char>(';'));
00494         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00495            _token = makeToken(_ttype);
00496            _token->setText(text.substr(_begin, text.length()-_begin));
00497         }
00498         _returnToken = _token;
00499 }
00500 
00501 void ExpressionLexer::mIDENT(bool _createToken) {
00502         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00503         _ttype = IDENT;
00504         int _saveIndex;
00505         
00506         {
00507         matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
00508         }
00509         {
00510         for (;;) {
00511                 switch ( LA(1)) {
00512                 case static_cast<unsigned char>('a'):
00513                 case static_cast<unsigned char>('b'):
00514                 case static_cast<unsigned char>('c'):
00515                 case static_cast<unsigned char>('d'):
00516                 case static_cast<unsigned char>('e'):
00517                 case static_cast<unsigned char>('f'):
00518                 case static_cast<unsigned char>('g'):
00519                 case static_cast<unsigned char>('h'):
00520                 case static_cast<unsigned char>('i'):
00521                 case static_cast<unsigned char>('j'):
00522                 case static_cast<unsigned char>('k'):
00523                 case static_cast<unsigned char>('l'):
00524                 case static_cast<unsigned char>('m'):
00525                 case static_cast<unsigned char>('n'):
00526                 case static_cast<unsigned char>('o'):
00527                 case static_cast<unsigned char>('p'):
00528                 case static_cast<unsigned char>('q'):
00529                 case static_cast<unsigned char>('r'):
00530                 case static_cast<unsigned char>('s'):
00531                 case static_cast<unsigned char>('t'):
00532                 case static_cast<unsigned char>('u'):
00533                 case static_cast<unsigned char>('v'):
00534                 case static_cast<unsigned char>('w'):
00535                 case static_cast<unsigned char>('x'):
00536                 case static_cast<unsigned char>('y'):
00537                 case static_cast<unsigned char>('z'):
00538                 {
00539                         matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
00540                         break;
00541                 }
00542                 case static_cast<unsigned char>('_'):
00543                 {
00544                         match(static_cast<unsigned char>('_'));
00545                         break;
00546                 }
00547                 case static_cast<unsigned char>('0'):
00548                 case static_cast<unsigned char>('1'):
00549                 case static_cast<unsigned char>('2'):
00550                 case static_cast<unsigned char>('3'):
00551                 case static_cast<unsigned char>('4'):
00552                 case static_cast<unsigned char>('5'):
00553                 case static_cast<unsigned char>('6'):
00554                 case static_cast<unsigned char>('7'):
00555                 case static_cast<unsigned char>('8'):
00556                 case static_cast<unsigned char>('9'):
00557                 {
00558                         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
00559                         break;
00560                 }
00561                 default:
00562                 {
00563                         goto _loop66;
00564                 }
00565                 }
00566         }
00567         _loop66:;
00568         }
00569         _ttype = testLiteralsTable(_ttype);
00570         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00571            _token = makeToken(_ttype);
00572            _token->setText(text.substr(_begin, text.length()-_begin));
00573         }
00574         _returnToken = _token;
00575 }
00576 
00577 void ExpressionLexer::mNUM_FLOAT(bool _createToken) {
00578         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00579         _ttype = NUM_FLOAT;
00580         int _saveIndex;
00581         
00582         {
00583         match(static_cast<unsigned char>('.'));
00584         }
00585         {
00586         int _cnt70=0;
00587         for (;;) {
00588                 if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
00589                         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
00590                 }
00591                 else {
00592                         if ( _cnt70>=1 ) { goto _loop70; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());}
00593                 }
00594                 
00595                 _cnt70++;
00596         }
00597         _loop70:;
00598         }
00599         {
00600         if ((LA(1)==static_cast<unsigned char>('e'))) {
00601                 match(static_cast<unsigned char>('e'));
00602                 {
00603                 switch ( LA(1)) {
00604                 case static_cast<unsigned char>('+'):
00605                 {
00606                         match(static_cast<unsigned char>('+'));
00607                         break;
00608                 }
00609                 case static_cast<unsigned char>('-'):
00610                 {
00611                         match(static_cast<unsigned char>('-'));
00612                         break;
00613                 }
00614                 case static_cast<unsigned char>('0'):
00615                 case static_cast<unsigned char>('1'):
00616                 case static_cast<unsigned char>('2'):
00617                 case static_cast<unsigned char>('3'):
00618                 case static_cast<unsigned char>('4'):
00619                 case static_cast<unsigned char>('5'):
00620                 case static_cast<unsigned char>('6'):
00621                 case static_cast<unsigned char>('7'):
00622                 case static_cast<unsigned char>('8'):
00623                 case static_cast<unsigned char>('9'):
00624                 {
00625                         break;
00626                 }
00627                 default:
00628                 {
00629                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());
00630                 }
00631                 }
00632                 }
00633                 {
00634                 int _cnt74=0;
00635                 for (;;) {
00636                         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
00637                                 matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
00638                         }
00639                         else {
00640                                 if ( _cnt74>=1 ) { goto _loop74; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());}
00641                         }
00642                         
00643                         _cnt74++;
00644                 }
00645                 _loop74:;
00646                 }
00647         }
00648         else {
00649         }
00650         
00651         }
00652         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00653            _token = makeToken(_ttype);
00654            _token->setText(text.substr(_begin, text.length()-_begin));
00655         }
00656         _returnToken = _token;
00657 }
00658 
00659 void ExpressionLexer::mNUM_DOUBLE(bool _createToken) {
00660         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00661         _ttype = NUM_DOUBLE;
00662         int _saveIndex;
00663         
00664         {
00665         int _cnt77=0;
00666         for (;;) {
00667                 if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
00668                         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
00669                 }
00670                 else {
00671                         if ( _cnt77>=1 ) { goto _loop77; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());}
00672                 }
00673                 
00674                 _cnt77++;
00675         }
00676         _loop77:;
00677         }
00678         {
00679         if ((LA(1)==static_cast<unsigned char>('.'))) {
00680                 {
00681                 match(static_cast<unsigned char>('.'));
00682                 }
00683                 {
00684                 for (;;) {
00685                         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
00686                                 matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
00687                         }
00688                         else {
00689                                 goto _loop81;
00690                         }
00691                         
00692                 }
00693                 _loop81:;
00694                 }
00695         }
00696         else {
00697         }
00698         
00699         }
00700         {
00701         if ((LA(1)==static_cast<unsigned char>('e'))) {
00702                 match(static_cast<unsigned char>('e'));
00703                 {
00704                 switch ( LA(1)) {
00705                 case static_cast<unsigned char>('+'):
00706                 {
00707                         match(static_cast<unsigned char>('+'));
00708                         break;
00709                 }
00710                 case static_cast<unsigned char>('-'):
00711                 {
00712                         match(static_cast<unsigned char>('-'));
00713                         break;
00714                 }
00715                 case static_cast<unsigned char>('0'):
00716                 case static_cast<unsigned char>('1'):
00717                 case static_cast<unsigned char>('2'):
00718                 case static_cast<unsigned char>('3'):
00719                 case static_cast<unsigned char>('4'):
00720                 case static_cast<unsigned char>('5'):
00721                 case static_cast<unsigned char>('6'):
00722                 case static_cast<unsigned char>('7'):
00723                 case static_cast<unsigned char>('8'):
00724                 case static_cast<unsigned char>('9'):
00725                 {
00726                         break;
00727                 }
00728                 default:
00729                 {
00730                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());
00731                 }
00732                 }
00733                 }
00734                 {
00735                 int _cnt85=0;
00736                 for (;;) {
00737                         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
00738                                 matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
00739                         }
00740                         else {
00741                                 if ( _cnt85>=1 ) { goto _loop85; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());}
00742                         }
00743                         
00744                         _cnt85++;
00745                 }
00746                 _loop85:;
00747                 }
00748         }
00749         else {
00750         }
00751         
00752         }
00753         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00754            _token = makeToken(_ttype);
00755            _token->setText(text.substr(_begin, text.length()-_begin));
00756         }
00757         _returnToken = _token;
00758 }
00759 
00760 void ExpressionLexer::mSTRING_LITERAL_S(bool _createToken) {
00761         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00762         _ttype = STRING_LITERAL_S;
00763         int _saveIndex;
00764         
00765         _saveIndex=text.length();
00766         match(static_cast<unsigned char>('\''));
00767         text.erase(_saveIndex);
00768         {
00769         for (;;) {
00770                 switch ( LA(1)) {
00771                 case static_cast<unsigned char>('\\'):
00772                 {
00773                         mESC(false);
00774                         break;
00775                 }
00776                 case static_cast<unsigned char>('\t'):
00777                 case static_cast<unsigned char>(' '):
00778                 case static_cast<unsigned char>('"'):
00779                 case static_cast<unsigned char>('%'):
00780                 case static_cast<unsigned char>('('):
00781                 case static_cast<unsigned char>(')'):
00782                 case static_cast<unsigned char>('*'):
00783                 case static_cast<unsigned char>('+'):
00784                 case static_cast<unsigned char>(','):
00785                 case static_cast<unsigned char>('-'):
00786                 case static_cast<unsigned char>('.'):
00787                 case static_cast<unsigned char>('/'):
00788                 case static_cast<unsigned char>('0'):
00789                 case static_cast<unsigned char>('1'):
00790                 case static_cast<unsigned char>('2'):
00791                 case static_cast<unsigned char>('3'):
00792                 case static_cast<unsigned char>('4'):
00793                 case static_cast<unsigned char>('5'):
00794                 case static_cast<unsigned char>('6'):
00795                 case static_cast<unsigned char>('7'):
00796                 case static_cast<unsigned char>('8'):
00797                 case static_cast<unsigned char>('9'):
00798                 case static_cast<unsigned char>(':'):
00799                 case static_cast<unsigned char>(';'):
00800                 case static_cast<unsigned char>('='):
00801                 case static_cast<unsigned char>('@'):
00802                 case static_cast<unsigned char>('['):
00803                 case static_cast<unsigned char>(']'):
00804                 case static_cast<unsigned char>('^'):
00805                 case static_cast<unsigned char>('_'):
00806                 case static_cast<unsigned char>('a'):
00807                 case static_cast<unsigned char>('b'):
00808                 case static_cast<unsigned char>('c'):
00809                 case static_cast<unsigned char>('d'):
00810                 case static_cast<unsigned char>('e'):
00811                 case static_cast<unsigned char>('f'):
00812                 case static_cast<unsigned char>('g'):
00813                 case static_cast<unsigned char>('h'):
00814                 case static_cast<unsigned char>('i'):
00815                 case static_cast<unsigned char>('j'):
00816                 case static_cast<unsigned char>('k'):
00817                 case static_cast<unsigned char>('l'):
00818                 case static_cast<unsigned char>('m'):
00819                 case static_cast<unsigned char>('n'):
00820                 case static_cast<unsigned char>('o'):
00821                 case static_cast<unsigned char>('p'):
00822                 case static_cast<unsigned char>('q'):
00823                 case static_cast<unsigned char>('r'):
00824                 case static_cast<unsigned char>('s'):
00825                 case static_cast<unsigned char>('t'):
00826                 case static_cast<unsigned char>('u'):
00827                 case static_cast<unsigned char>('v'):
00828                 case static_cast<unsigned char>('w'):
00829                 case static_cast<unsigned char>('x'):
00830                 case static_cast<unsigned char>('y'):
00831                 case static_cast<unsigned char>('z'):
00832                 {
00833                         {
00834                         match(_tokenSet_0);
00835                         }
00836                         break;
00837                 }
00838                 default:
00839                 {
00840                         goto _loop89;
00841                 }
00842                 }
00843         }
00844         _loop89:;
00845         }
00846         _saveIndex=text.length();
00847         match(static_cast<unsigned char>('\''));
00848         text.erase(_saveIndex);
00849         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00850            _token = makeToken(_ttype);
00851            _token->setText(text.substr(_begin, text.length()-_begin));
00852         }
00853         _returnToken = _token;
00854 }
00855 
00856 void ExpressionLexer::mESC(bool _createToken) {
00857         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00858         _ttype = ESC;
00859         int _saveIndex;
00860         
00861         match(static_cast<unsigned char>('\\'));
00862         {
00863         switch ( LA(1)) {
00864         case static_cast<unsigned char>('n'):
00865         {
00866                 match(static_cast<unsigned char>('n'));
00867                 break;
00868         }
00869         case static_cast<unsigned char>('r'):
00870         {
00871                 match(static_cast<unsigned char>('r'));
00872                 break;
00873         }
00874         case static_cast<unsigned char>('t'):
00875         {
00876                 match(static_cast<unsigned char>('t'));
00877                 break;
00878         }
00879         case static_cast<unsigned char>('b'):
00880         {
00881                 match(static_cast<unsigned char>('b'));
00882                 break;
00883         }
00884         case static_cast<unsigned char>('f'):
00885         {
00886                 match(static_cast<unsigned char>('f'));
00887                 break;
00888         }
00889         case static_cast<unsigned char>('"'):
00890         {
00891                 match(static_cast<unsigned char>('"'));
00892                 break;
00893         }
00894         case static_cast<unsigned char>('\''):
00895         {
00896                 match(static_cast<unsigned char>('\''));
00897                 break;
00898         }
00899         case static_cast<unsigned char>('\\'):
00900         {
00901                 match(static_cast<unsigned char>('\\'));
00902                 break;
00903         }
00904         default:
00905         {
00906                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine());
00907         }
00908         }
00909         }
00910         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00911            _token = makeToken(_ttype);
00912            _token->setText(text.substr(_begin, text.length()-_begin));
00913         }
00914         _returnToken = _token;
00915 }
00916 
00917 void ExpressionLexer::mSTRING_LITERAL_D(bool _createToken) {
00918         int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00919         _ttype = STRING_LITERAL_D;
00920         int _saveIndex;
00921         
00922         _saveIndex=text.length();
00923         match(static_cast<unsigned char>('"'));
00924         text.erase(_saveIndex);
00925         {
00926         for (;;) {
00927                 switch ( LA(1)) {
00928                 case static_cast<unsigned char>('\\'):
00929                 {
00930                         mESC(false);
00931                         break;
00932                 }
00933                 case static_cast<unsigned char>('\t'):
00934                 case static_cast<unsigned char>(' '):
00935                 case static_cast<unsigned char>('%'):
00936                 case static_cast<unsigned char>('\''):
00937                 case static_cast<unsigned char>('('):
00938                 case static_cast<unsigned char>(')'):
00939                 case static_cast<unsigned char>('*'):
00940                 case static_cast<unsigned char>('+'):
00941                 case static_cast<unsigned char>(','):
00942                 case static_cast<unsigned char>('-'):
00943                 case static_cast<unsigned char>('.'):
00944                 case static_cast<unsigned char>('/'):
00945                 case static_cast<unsigned char>('0'):
00946                 case static_cast<unsigned char>('1'):
00947                 case static_cast<unsigned char>('2'):
00948                 case static_cast<unsigned char>('3'):
00949                 case static_cast<unsigned char>('4'):
00950                 case static_cast<unsigned char>('5'):
00951                 case static_cast<unsigned char>('6'):
00952                 case static_cast<unsigned char>('7'):
00953                 case static_cast<unsigned char>('8'):
00954                 case static_cast<unsigned char>('9'):
00955                 case static_cast<unsigned char>(':'):
00956                 case static_cast<unsigned char>(';'):
00957                 case static_cast<unsigned char>('='):
00958                 case static_cast<unsigned char>('@'):
00959                 case static_cast<unsigned char>('['):
00960                 case static_cast<unsigned char>(']'):
00961                 case static_cast<unsigned char>('^'):
00962                 case static_cast<unsigned char>('_'):
00963                 case static_cast<unsigned char>('a'):
00964                 case static_cast<unsigned char>('b'):
00965                 case static_cast<unsigned char>('c'):
00966                 case static_cast<unsigned char>('d'):
00967                 case static_cast<unsigned char>('e'):
00968                 case static_cast<unsigned char>('f'):
00969                 case static_cast<unsigned char>('g'):
00970                 case static_cast<unsigned char>('h'):
00971                 case static_cast<unsigned char>('i'):
00972                 case static_cast<unsigned char>('j'):
00973                 case static_cast<unsigned char>('k'):
00974                 case static_cast<unsigned char>('l'):
00975                 case static_cast<unsigned char>('m'):
00976                 case static_cast<unsigned char>('n'):
00977                 case static_cast<unsigned char>('o'):
00978                 case static_cast<unsigned char>('p'):
00979                 case static_cast<unsigned char>('q'):
00980                 case static_cast<unsigned char>('r'):
00981                 case static_cast<unsigned char>('s'):
00982                 case static_cast<unsigned char>('t'):
00983                 case static_cast<unsigned char>('u'):
00984                 case static_cast<unsigned char>('v'):
00985                 case static_cast<unsigned char>('w'):
00986                 case static_cast<unsigned char>('x'):
00987                 case static_cast<unsigned char>('y'):
00988                 case static_cast<unsigned char>('z'):
00989                 {
00990                         {
00991                         match(_tokenSet_1);
00992                         }
00993                         break;
00994                 }
00995                 default:
00996                 {
00997                         goto _loop93;
00998                 }
00999                 }
01000         }
01001         _loop93:;
01002         }
01003         _saveIndex=text.length();
01004         match(static_cast<unsigned char>('"'));
01005         text.erase(_saveIndex);
01006         if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01007            _token = makeToken(_ttype);
01008            _token->setText(text.substr(_begin, text.length()-_begin));
01009         }
01010         _returnToken = _token;
01011 }
01012 
01013 
01014 const unsigned long ExpressionLexer::_tokenSet_0_data_[] = { 512UL, 805306149UL, 3892314113UL, 134217726UL, 0UL, 0UL, 0UL, 0UL };
01015 const ANTLR_USE_NAMESPACE(antlr)BitSet ExpressionLexer::_tokenSet_0(_tokenSet_0_data_,8);
01016 const unsigned long ExpressionLexer::_tokenSet_1_data_[] = { 512UL, 805306273UL, 3892314113UL, 134217726UL, 0UL, 0UL, 0UL, 0UL };
01017 const ANTLR_USE_NAMESPACE(antlr)BitSet ExpressionLexer::_tokenSet_1(_tokenSet_1_data_,8);
01018