GPLIB++: EDILexer Class Reference

antlr::RefToken EDILexer::nextToken ( )

Definition at line 80 of file EDILexer.cpp.

References mCOLON(), mCOMMENT(), mDATE(), mDIGIT(), mEQUAL(), mEXKL(), mHEAD(), mKEYWORD(), mNUMBER(), mOTHER(), mSLASH(), mSPECIAL(), mSTRING(), and mWS().

00081 {
00082         antlr::RefToken theRetToken;
00083         for (;;) {
00084                 antlr::RefToken theRetToken;
00085                 int _ttype = antlr::Token::INVALID_TYPE;
00086                 setCommitToPath(false);
00087                 resetText();
00088                 try {   // for lexical and char stream error handling
00089                         switch ( LA(1)) {
00090                         case 0x22 /* '\"' */ :
00091                         case 0x61 /* 'a' */ :
00092                         case 0x62 /* 'b' */ :
00093                         case 0x63 /* 'c' */ :
00094                         case 0x64 /* 'd' */ :
00095                         case 0x65 /* 'e' */ :
00096                         case 0x66 /* 'f' */ :
00097                         case 0x67 /* 'g' */ :
00098                         case 0x68 /* 'h' */ :
00099                         case 0x69 /* 'i' */ :
00100                         case 0x6a /* 'j' */ :
00101                         case 0x6b /* 'k' */ :
00102                         case 0x6c /* 'l' */ :
00103                         case 0x6d /* 'm' */ :
00104                         case 0x6e /* 'n' */ :
00105                         case 0x6f /* 'o' */ :
00106                         case 0x70 /* 'p' */ :
00107                         case 0x71 /* 'q' */ :
00108                         case 0x72 /* 'r' */ :
00109                         case 0x73 /* 's' */ :
00110                         case 0x74 /* 't' */ :
00111                         case 0x75 /* 'u' */ :
00112                         case 0x76 /* 'v' */ :
00113                         case 0x77 /* 'w' */ :
00114                         case 0x78 /* 'x' */ :
00115                         case 0x79 /* 'y' */ :
00116                         case 0x7a /* 'z' */ :
00117                         {
00118                                 mSTRING(true);
00119                                 theRetToken=_returnToken;
00120                                 break;
00121                         }
00122                         case 0x9 /* '\t' */ :
00123                         case 0xa /* '\n' */ :
00124                         case 0xd /* '\r' */ :
00125                         case 0x20 /* ' ' */ :
00126                         {
00127                                 mWS(true);
00128                                 theRetToken=_returnToken;
00129                                 break;
00130                         }
00131                         case 0x3d /* '=' */ :
00132                         {
00133                                 mEQUAL(true);
00134                                 theRetToken=_returnToken;
00135                                 break;
00136                         }
00137                         case 0x2f /* '/' */ :
00138                         {
00139                                 mSLASH(true);
00140                                 theRetToken=_returnToken;
00141                                 break;
00142                         }
00143                         case 0x21 /* '!' */ :
00144                         {
00145                                 mEXKL(true);
00146                                 theRetToken=_returnToken;
00147                                 break;
00148                         }
00149                         case 0x3a /* ':' */ :
00150                         {
00151                                 mCOLON(true);
00152                                 theRetToken=_returnToken;
00153                                 break;
00154                         }
00155                         default:
00156                                 if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x68 /* 'h' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x61 /* 'a' */ ) && (LA(5) == 0x64 /* 'd' */ ) && (true) && (true) && (true) && (true) && (true)) {
00157                                         mHEAD(true);
00158                                         theRetToken=_returnToken;
00159                                 }
00160                                 else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && ((LA(2) >= 0x30 /* '0' */  && LA(2) <= 0x39 /* '9' */ )) && (LA(3) == 0x2f /* '/' */ )) {
00161                                         mDATE(true);
00162                                         theRetToken=_returnToken;
00163                                 }
00164                                 else if ((LA(1) == 0x3e /* '>' */ ) && (_tokenSet_0.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00165                                         mKEYWORD(true);
00166                                         theRetToken=_returnToken;
00167                                 }
00168                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x21 /* '!' */ )) {
00169                                         mCOMMENT(true);
00170                                         theRetToken=_returnToken;
00171                                 }
00172                                 else if ((LA(1) == 0x3e /* '>' */ ) && (true)) {
00173                                         mSPECIAL(true);
00174                                         theRetToken=_returnToken;
00175                                 }
00176                                 else if ((_tokenSet_1.member(LA(1))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00177                                         mNUMBER(true);
00178                                         theRetToken=_returnToken;
00179                                 }
00180                                 else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00181                                         mDIGIT(true);
00182                                         theRetToken=_returnToken;
00183                                 }
00184                                 else if ((_tokenSet_2.member(LA(1))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00185                                         mOTHER(true);
00186                                         theRetToken=_returnToken;
00187                                 }
00188                         else {
00189                                 if (LA(1)==EOF_CHAR)
00190                                 {
00191                                         uponEOF();
00192                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00193                                 }
00194                                 else {consume(); goto tryAgain;}
00195                         }
00196                         }
00197                         if ( !_returnToken )
00198                                 goto tryAgain; // found SKIP token
00199 
00200                         _ttype = _returnToken->getType();
00201                         _ttype = testLiteralsTable(_ttype);
00202                         _returnToken->setType(_ttype);
00203                         return _returnToken;
00204                 }
00205                 catch (antlr::RecognitionException& e) {
00206                         if ( !getCommitToPath() ) {
00207                                 consume();
00208                                 goto tryAgain;
00209                         }
00210                                 throw antlr::TokenStreamRecognitionException(e);
00211                 }
00212                 catch (antlr::CharStreamIOException& csie) {
00213                         throw antlr::TokenStreamIOException(csie.io);
00214                 }
00215                 catch (antlr::CharStreamException& cse) {
00216                         throw antlr::TokenStreamException(cse.getMessage());
00217                 }
00218 tryAgain:;
00219         }
00220 }

Here is the call graph for this function:

void EDILexer::mHEAD ( bool _createToken )

Definition at line 222 of file EDILexer.cpp.

References HEAD.

Referenced by nextToken().

00222                                       {
00223         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00224         _ttype = HEAD;
00225         std::string::size_type _saveIndex;
00226         
00227         match(">head");
00228         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00229            _token = makeToken(_ttype);
00230            _token->setText(text.substr(_begin, text.length()-_begin));
00231         }
00232         _returnToken = _token;
00233         _saveIndex=0;
00234 }

void EDILexer::mKEYWORD ( bool _createToken )

Definition at line 236 of file EDILexer.cpp.

References KEYWORD, mSPECIAL(), and mSTRING().

Referenced by nextToken().

00236                                          {
00237         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00238         _ttype = KEYWORD;
00239         std::string::size_type _saveIndex;
00240         
00241         mSPECIAL(false);
00242         mSTRING(false);
00243         _ttype = testLiteralsTable(_ttype);
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 }

Here is the call graph for this function:

void EDILexer::mSPECIAL ( bool _createToken )

Definition at line 252 of file EDILexer.cpp.

References SPECIAL.

Referenced by mCOMMENT(), mKEYWORD(), and nextToken().

00252                                          {
00253         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00254         _ttype = SPECIAL;
00255         std::string::size_type _saveIndex;
00256         
00257         match('>' /* charlit */ );
00258         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00259            _token = makeToken(_ttype);
00260            _token->setText(text.substr(_begin, text.length()-_begin));
00261         }
00262         _returnToken = _token;
00263         _saveIndex=0;
00264 }

void EDILexer::mSTRING ( bool _createToken )

Definition at line 266 of file EDILexer.cpp.

References mLEGAL_CHAR(), mLETTER(), and STRING.

Referenced by mKEYWORD(), and nextToken().

00266                                         {
00267         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00268         _ttype = STRING;
00269         std::string::size_type _saveIndex;
00270         
00271         switch ( LA(1)) {
00272         case 0x61 /* 'a' */ :
00273         case 0x62 /* 'b' */ :
00274         case 0x63 /* 'c' */ :
00275         case 0x64 /* 'd' */ :
00276         case 0x65 /* 'e' */ :
00277         case 0x66 /* 'f' */ :
00278         case 0x67 /* 'g' */ :
00279         case 0x68 /* 'h' */ :
00280         case 0x69 /* 'i' */ :
00281         case 0x6a /* 'j' */ :
00282         case 0x6b /* 'k' */ :
00283         case 0x6c /* 'l' */ :
00284         case 0x6d /* 'm' */ :
00285         case 0x6e /* 'n' */ :
00286         case 0x6f /* 'o' */ :
00287         case 0x70 /* 'p' */ :
00288         case 0x71 /* 'q' */ :
00289         case 0x72 /* 'r' */ :
00290         case 0x73 /* 's' */ :
00291         case 0x74 /* 't' */ :
00292         case 0x75 /* 'u' */ :
00293         case 0x76 /* 'v' */ :
00294         case 0x77 /* 'w' */ :
00295         case 0x78 /* 'x' */ :
00296         case 0x79 /* 'y' */ :
00297         case 0x7a /* 'z' */ :
00298         {
00299                 mLETTER(false);
00300                 { // ( ... )*
00301                 for (;;) {
00302                         if ((_tokenSet_3.member(LA(1)))) {
00303                                 mLEGAL_CHAR(false);
00304                         }
00305                         else {
00306                                 goto _loop77;
00307                         }
00308                         
00309                 }
00310                 _loop77:;
00311                 } // ( ... )*
00312                 break;
00313         }
00314         case 0x22 /* '\"' */ :
00315         {
00316                 {
00317                 match('\"' /* charlit */ );
00318                 { // ( ... )*
00319                 for (;;) {
00320                         switch ( LA(1)) {
00321                         case 0x23 /* '#' */ :
00322                         case 0x24 /* '$' */ :
00323                         case 0x25 /* '%' */ :
00324                         case 0x26 /* '&' */ :
00325                         case 0x27 /* '\'' */ :
00326                         case 0x28 /* '(' */ :
00327                         case 0x29 /* ')' */ :
00328                         case 0x2a /* '*' */ :
00329                         case 0x2b /* '+' */ :
00330                         case 0x2c /* ',' */ :
00331                         case 0x2d /* '-' */ :
00332                         case 0x2e /* '.' */ :
00333                         case 0x2f /* '/' */ :
00334                         case 0x30 /* '0' */ :
00335                         case 0x31 /* '1' */ :
00336                         case 0x32 /* '2' */ :
00337                         case 0x33 /* '3' */ :
00338                         case 0x34 /* '4' */ :
00339                         case 0x35 /* '5' */ :
00340                         case 0x36 /* '6' */ :
00341                         case 0x37 /* '7' */ :
00342                         case 0x38 /* '8' */ :
00343                         case 0x39 /* '9' */ :
00344                         case 0x3a /* ':' */ :
00345                         case 0x3b /* ';' */ :
00346                         case 0x3c /* '<' */ :
00347                         case 0x3f /* '?' */ :
00348                         case 0x40 /* '@' */ :
00349                         case 0x5b /* '[' */ :
00350                         case 0x5d /* ']' */ :
00351                         case 0x5e /* '^' */ :
00352                         case 0x5f /* '_' */ :
00353                         case 0x61 /* 'a' */ :
00354                         case 0x62 /* 'b' */ :
00355                         case 0x63 /* 'c' */ :
00356                         case 0x64 /* 'd' */ :
00357                         case 0x65 /* 'e' */ :
00358                         case 0x66 /* 'f' */ :
00359                         case 0x67 /* 'g' */ :
00360                         case 0x68 /* 'h' */ :
00361                         case 0x69 /* 'i' */ :
00362                         case 0x6a /* 'j' */ :
00363                         case 0x6b /* 'k' */ :
00364                         case 0x6c /* 'l' */ :
00365                         case 0x6d /* 'm' */ :
00366                         case 0x6e /* 'n' */ :
00367                         case 0x6f /* 'o' */ :
00368                         case 0x70 /* 'p' */ :
00369                         case 0x71 /* 'q' */ :
00370                         case 0x72 /* 'r' */ :
00371                         case 0x73 /* 's' */ :
00372                         case 0x74 /* 't' */ :
00373                         case 0x75 /* 'u' */ :
00374                         case 0x76 /* 'v' */ :
00375                         case 0x77 /* 'w' */ :
00376                         case 0x78 /* 'x' */ :
00377                         case 0x79 /* 'y' */ :
00378                         case 0x7a /* 'z' */ :
00379                         case 0x7b /* '{' */ :
00380                         case 0x7c /* '|' */ :
00381                         case 0x7d /* '}' */ :
00382                         case 0x7e /* '~' */ :
00383                         {
00384                                 mLEGAL_CHAR(false);
00385                                 break;
00386                         }
00387                         case 0x20 /* ' ' */ :
00388                         {
00389                                 match(' ' /* charlit */ );
00390                                 break;
00391                         }
00392                         default:
00393                         {
00394                                 goto _loop80;
00395                         }
00396                         }
00397                 }
00398                 _loop80:;
00399                 } // ( ... )*
00400                 match('\"' /* charlit */ );
00401                 }
00402                 break;
00403         }
00404         default:
00405         {
00406                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00407         }
00408         }
00409         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00410            _token = makeToken(_ttype);
00411            _token->setText(text.substr(_begin, text.length()-_begin));
00412         }
00413         _returnToken = _token;
00414         _saveIndex=0;
00415 }

Here is the call graph for this function:

void EDILexer::mWS ( bool _createToken )

Definition at line 417 of file EDILexer.cpp.

References WS.

Referenced by nextToken().

00417                                     {
00418         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00419         _ttype = WS;
00420         std::string::size_type _saveIndex;
00421         
00422         {
00423         switch ( LA(1)) {
00424         case 0x20 /* ' ' */ :
00425         {
00426                 match(' ' /* charlit */ );
00427                 break;
00428         }
00429         case 0x9 /* '\t' */ :
00430         {
00431                 match('\t' /* charlit */ );
00432                 break;
00433         }
00434         case 0xd /* '\r' */ :
00435         {
00436                 match('\r' /* charlit */ );
00437                 match('\n' /* charlit */ );
00438                 if ( inputState->guessing==0 ) {
00439 #line 244 "EdiParser2.g"
00440                         newline();
00441 #line 442 "EDILexer.cpp"
00442                 }
00443                 break;
00444         }
00445         case 0xa /* '\n' */ :
00446         {
00447                 match('\n' /* charlit */ );
00448                 if ( inputState->guessing==0 ) {
00449 #line 245 "EdiParser2.g"
00450                         newline();
00451 #line 452 "EDILexer.cpp"
00452                 }
00453                 break;
00454         }
00455         default:
00456         {
00457                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00458         }
00459         }
00460         }
00461         if ( inputState->guessing==0 ) {
00462 #line 247 "EdiParser2.g"
00463                 _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00464 #line 465 "EDILexer.cpp"
00465         }
00466         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00467            _token = makeToken(_ttype);
00468            _token->setText(text.substr(_begin, text.length()-_begin));
00469         }
00470         _returnToken = _token;
00471         _saveIndex=0;
00472 }

void EDILexer::mEQUAL ( bool _createToken )

Definition at line 474 of file EDILexer.cpp.

References EQUAL.

Referenced by nextToken().

00474                                        {
00475         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00476         _ttype = EQUAL;
00477         std::string::size_type _saveIndex;
00478         
00479         match('=' /* charlit */ );
00480         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00481            _token = makeToken(_ttype);
00482            _token->setText(text.substr(_begin, text.length()-_begin));
00483         }
00484         _returnToken = _token;
00485         _saveIndex=0;
00486 }

void EDILexer::mSLASH ( bool _createToken )

Definition at line 488 of file EDILexer.cpp.

References SLASH.

Referenced by mLEGAL_CHAR(), and nextToken().

00488                                        {
00489         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00490         _ttype = SLASH;
00491         std::string::size_type _saveIndex;
00492         
00493         match('/' /* charlit */ );
00494         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00495            _token = makeToken(_ttype);
00496            _token->setText(text.substr(_begin, text.length()-_begin));
00497         }
00498         _returnToken = _token;
00499         _saveIndex=0;
00500 }

void EDILexer::mEXKL ( bool _createToken )

Definition at line 502 of file EDILexer.cpp.

References EXKL.

Referenced by mCOMMENT(), and nextToken().

00502                                       {
00503         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00504         _ttype = EXKL;
00505         std::string::size_type _saveIndex;
00506         
00507         match('!' /* charlit */ );
00508         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00509            _token = makeToken(_ttype);
00510            _token->setText(text.substr(_begin, text.length()-_begin));
00511         }
00512         _returnToken = _token;
00513         _saveIndex=0;
00514 }

void EDILexer::mCOLON ( bool _createToken )

Definition at line 516 of file EDILexer.cpp.

References COLON.

Referenced by mLEGAL_CHAR(), and nextToken().

00516                                        {
00517         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00518         _ttype = COLON;
00519         std::string::size_type _saveIndex;
00520         
00521         match(':' /* charlit */ );
00522         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00523            _token = makeToken(_ttype);
00524            _token->setText(text.substr(_begin, text.length()-_begin));
00525         }
00526         _returnToken = _token;
00527         _saveIndex=0;
00528 }

void EDILexer::mCOMMENT ( bool _createToken )

Definition at line 530 of file EDILexer.cpp.

References COMMENT, mEXKL(), and mSPECIAL().

Referenced by nextToken().

00530                                          {
00531         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00532         _ttype = COMMENT;
00533         std::string::size_type _saveIndex;
00534         
00535         mSPECIAL(false);
00536         mEXKL(false);
00537         { // ( ... )*
00538         for (;;) {
00539                 if ((_tokenSet_4.member(LA(1)))) {
00540                         matchNot('!' /* charlit */ );
00541                 }
00542                 else {
00543                         goto _loop66;
00544                 }
00545                 
00546         }
00547         _loop66:;
00548         } // ( ... )*
00549         mEXKL(false);
00550         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00551            _token = makeToken(_ttype);
00552            _token->setText(text.substr(_begin, text.length()-_begin));
00553         }
00554         _returnToken = _token;
00555         _saveIndex=0;
00556 }

Here is the call graph for this function:

void EDILexer::mNUMBER ( bool _createToken )

Definition at line 558 of file EDILexer.cpp.

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

Referenced by nextToken().

00558                                         {
00559         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00560         _ttype = NUMBER;
00561         std::string::size_type _saveIndex;
00562         
00563         {
00564         switch ( LA(1)) {
00565         case 0x2b /* '+' */ :
00566         {
00567                 match('+' /* charlit */ );
00568                 break;
00569         }
00570         case 0x2d /* '-' */ :
00571         {
00572                 match('-' /* charlit */ );
00573                 break;
00574         }
00575         case 0x2e /* '.' */ :
00576         case 0x30 /* '0' */ :
00577         case 0x31 /* '1' */ :
00578         case 0x32 /* '2' */ :
00579         case 0x33 /* '3' */ :
00580         case 0x34 /* '4' */ :
00581         case 0x35 /* '5' */ :
00582         case 0x36 /* '6' */ :
00583         case 0x37 /* '7' */ :
00584         case 0x38 /* '8' */ :
00585         case 0x39 /* '9' */ :
00586         {
00587                 break;
00588         }
00589         default:
00590         {
00591                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00592         }
00593         }
00594         }
00595         {
00596         bool synPredMatched71 = false;
00597         if (((_tokenSet_5.member(LA(1))) && (_tokenSet_5.member(LA(2))) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true))) {
00598                 int _m71 = mark();
00599                 synPredMatched71 = true;
00600                 inputState->guessing++;
00601                 try {
00602                         {
00603                         mREAL(false);
00604                         }
00605                 }
00606                 catch (antlr::RecognitionException& pe) {
00607                         synPredMatched71 = false;
00608                 }
00609                 rewind(_m71);
00610                 inputState->guessing--;
00611         }
00612         if ( synPredMatched71 ) {
00613                 mREAL(false);
00614         }
00615         else if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ )) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true) && (true)) {
00616                 mINT(false);
00617         }
00618         else {
00619                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00620         }
00621         
00622         }
00623         {
00624         if ((LA(1) == 0x65 /* 'e' */ )) {
00625                 {
00626                 match('e' /* charlit */ );
00627                 }
00628                 {
00629                 switch ( LA(1)) {
00630                 case 0x2b /* '+' */ :
00631                 {
00632                         match('+' /* charlit */ );
00633                         break;
00634                 }
00635                 case 0x2d /* '-' */ :
00636                 {
00637                         match('-' /* charlit */ );
00638                         break;
00639                 }
00640                 case 0x30 /* '0' */ :
00641                 case 0x31 /* '1' */ :
00642                 case 0x32 /* '2' */ :
00643                 case 0x33 /* '3' */ :
00644                 case 0x34 /* '4' */ :
00645                 case 0x35 /* '5' */ :
00646                 case 0x36 /* '6' */ :
00647                 case 0x37 /* '7' */ :
00648                 case 0x38 /* '8' */ :
00649                 case 0x39 /* '9' */ :
00650                 {
00651                         break;
00652                 }
00653                 default:
00654                 {
00655                         throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00656                 }
00657                 }
00658                 }
00659                 mINT(false);
00660         }
00661         else {
00662         }
00663         
00664         }
00665         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00666            _token = makeToken(_ttype);
00667            _token->setText(text.substr(_begin, text.length()-_begin));
00668         }
00669         _returnToken = _token;
00670         _saveIndex=0;
00671 }

Here is the call graph for this function:

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

Definition at line 673 of file EDILexer.cpp.

References mINT(), and REAL.

Referenced by mNUMBER().

00673                                       {
00674         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00675         _ttype = REAL;
00676         std::string::size_type _saveIndex;
00677         
00678         {
00679         switch ( LA(1)) {
00680         case 0x2e /* '.' */ :
00681         {
00682                 match('.' /* charlit */ );
00683                 mINT(false);
00684                 break;
00685         }
00686         case 0x30 /* '0' */ :
00687         case 0x31 /* '1' */ :
00688         case 0x32 /* '2' */ :
00689         case 0x33 /* '3' */ :
00690         case 0x34 /* '4' */ :
00691         case 0x35 /* '5' */ :
00692         case 0x36 /* '6' */ :
00693         case 0x37 /* '7' */ :
00694         case 0x38 /* '8' */ :
00695         case 0x39 /* '9' */ :
00696         {
00697                 mINT(false);
00698                 match('.' /* charlit */ );
00699                 {
00700                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00701                         mINT(false);
00702                 }
00703                 else {
00704                 }
00705                 
00706                 }
00707                 break;
00708         }
00709         default:
00710         {
00711                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00712         }
00713         }
00714         }
00715         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00716            _token = makeToken(_ttype);
00717            _token->setText(text.substr(_begin, text.length()-_begin));
00718         }
00719         _returnToken = _token;
00720         _saveIndex=0;
00721 }

Here is the call graph for this function:

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

Definition at line 723 of file EDILexer.cpp.

References INT, and mDIGIT().

Referenced by mNUMBER(), and mREAL().

00723                                      {
00724         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00725         _ttype = INT;
00726         std::string::size_type _saveIndex;
00727         
00728         { // ( ... )+
00729         int _cnt88=0;
00730         for (;;) {
00731                 if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
00732                         mDIGIT(false);
00733                 }
00734                 else {
00735                         if ( _cnt88>=1 ) { goto _loop88; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00736                 }
00737                 
00738                 _cnt88++;
00739         }
00740         _loop88:;
00741         }  // ( ... )+
00742         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00743            _token = makeToken(_ttype);
00744            _token->setText(text.substr(_begin, text.length()-_begin));
00745         }
00746         _returnToken = _token;
00747         _saveIndex=0;
00748 }

Here is the call graph for this function:

void EDILexer::mLETTER ( bool _createToken ) [protected]

Definition at line 750 of file EDILexer.cpp.

References LETTER.

Referenced by mLEGAL_CHAR(), and mSTRING().

00750                                         {
00751         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00752         _ttype = LETTER;
00753         std::string::size_type _saveIndex;
00754         
00755         matchRange('a','z');
00756         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00757            _token = makeToken(_ttype);
00758            _token->setText(text.substr(_begin, text.length()-_begin));
00759         }
00760         _returnToken = _token;
00761         _saveIndex=0;
00762 }

void EDILexer::mLEGAL_CHAR ( bool _createToken ) [protected]

Definition at line 764 of file EDILexer.cpp.

References LEGAL_CHAR, mCOLON(), mDIGIT(), mLETTER(), mOTHER(), and mSLASH().

Referenced by mSTRING().

00764                                             {
00765         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00766         _ttype = LEGAL_CHAR;
00767         std::string::size_type _saveIndex;
00768         
00769         switch ( LA(1)) {
00770         case 0x61 /* 'a' */ :
00771         case 0x62 /* 'b' */ :
00772         case 0x63 /* 'c' */ :
00773         case 0x64 /* 'd' */ :
00774         case 0x65 /* 'e' */ :
00775         case 0x66 /* 'f' */ :
00776         case 0x67 /* 'g' */ :
00777         case 0x68 /* 'h' */ :
00778         case 0x69 /* 'i' */ :
00779         case 0x6a /* 'j' */ :
00780         case 0x6b /* 'k' */ :
00781         case 0x6c /* 'l' */ :
00782         case 0x6d /* 'm' */ :
00783         case 0x6e /* 'n' */ :
00784         case 0x6f /* 'o' */ :
00785         case 0x70 /* 'p' */ :
00786         case 0x71 /* 'q' */ :
00787         case 0x72 /* 'r' */ :
00788         case 0x73 /* 's' */ :
00789         case 0x74 /* 't' */ :
00790         case 0x75 /* 'u' */ :
00791         case 0x76 /* 'v' */ :
00792         case 0x77 /* 'w' */ :
00793         case 0x78 /* 'x' */ :
00794         case 0x79 /* 'y' */ :
00795         case 0x7a /* 'z' */ :
00796         {
00797                 mLETTER(false);
00798                 break;
00799         }
00800         case 0x30 /* '0' */ :
00801         case 0x31 /* '1' */ :
00802         case 0x32 /* '2' */ :
00803         case 0x33 /* '3' */ :
00804         case 0x34 /* '4' */ :
00805         case 0x35 /* '5' */ :
00806         case 0x36 /* '6' */ :
00807         case 0x37 /* '7' */ :
00808         case 0x38 /* '8' */ :
00809         case 0x39 /* '9' */ :
00810         {
00811                 mDIGIT(false);
00812                 break;
00813         }
00814         case 0x23 /* '#' */ :
00815         case 0x24 /* '$' */ :
00816         case 0x25 /* '%' */ :
00817         case 0x26 /* '&' */ :
00818         case 0x27 /* '\'' */ :
00819         case 0x28 /* '(' */ :
00820         case 0x29 /* ')' */ :
00821         case 0x2a /* '*' */ :
00822         case 0x2b /* '+' */ :
00823         case 0x2c /* ',' */ :
00824         case 0x2d /* '-' */ :
00825         case 0x2e /* '.' */ :
00826         case 0x3b /* ';' */ :
00827         case 0x3c /* '<' */ :
00828         case 0x3f /* '?' */ :
00829         case 0x40 /* '@' */ :
00830         case 0x5b /* '[' */ :
00831         case 0x5d /* ']' */ :
00832         case 0x5e /* '^' */ :
00833         case 0x5f /* '_' */ :
00834         case 0x7b /* '{' */ :
00835         case 0x7c /* '|' */ :
00836         case 0x7d /* '}' */ :
00837         case 0x7e /* '~' */ :
00838         {
00839                 mOTHER(false);
00840                 break;
00841         }
00842         case 0x3a /* ':' */ :
00843         {
00844                 mCOLON(false);
00845                 break;
00846         }
00847         case 0x2f /* '/' */ :
00848         {
00849                 mSLASH(false);
00850                 break;
00851         }
00852         default:
00853         {
00854                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00855         }
00856         }
00857         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00858            _token = makeToken(_ttype);
00859            _token->setText(text.substr(_begin, text.length()-_begin));
00860         }
00861         _returnToken = _token;
00862         _saveIndex=0;
00863 }

Here is the call graph for this function:

void EDILexer::mDATE ( bool _createToken )

Definition at line 865 of file EDILexer.cpp.

References DATE, and mDIGIT().

Referenced by nextToken().

00865                                       {
00866         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00867         _ttype = DATE;
00868         std::string::size_type _saveIndex;
00869         
00870         mDIGIT(false);
00871         mDIGIT(false);
00872         match('/' /* charlit */ );
00873         mDIGIT(false);
00874         mDIGIT(false);
00875         match('/' /* charlit */ );
00876         mDIGIT(false);
00877         mDIGIT(false);
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 }

Here is the call graph for this function:

void EDILexer::mDIGIT ( bool _createToken )

Definition at line 886 of file EDILexer.cpp.

References DIGIT.

Referenced by mDATE(), mINT(), mLEGAL_CHAR(), and nextToken().

00886                                        {
00887         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00888         _ttype = DIGIT;
00889         std::string::size_type _saveIndex;
00890         
00891         matchRange('0','9');
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 }

void EDILexer::mOTHER ( bool _createToken )

Definition at line 900 of file EDILexer.cpp.

References OTHER.

Referenced by mLEGAL_CHAR(), and nextToken().

00900                                        {
00901         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00902         _ttype = OTHER;
00903         std::string::size_type _saveIndex;
00904         
00905         switch ( LA(1)) {
00906         case 0x27 /* '\'' */ :
00907         {
00908                 match('\'' /* charlit */ );
00909                 break;
00910         }
00911         case 0x23 /* '#' */ :
00912         {
00913                 match('#' /* charlit */ );
00914                 break;
00915         }
00916         case 0x24 /* '$' */ :
00917         {
00918                 match('$' /* charlit */ );
00919                 break;
00920         }
00921         case 0x25 /* '%' */ :
00922         {
00923                 match('%' /* charlit */ );
00924                 break;
00925         }
00926         case 0x26 /* '&' */ :
00927         {
00928                 match('&' /* charlit */ );
00929                 break;
00930         }
00931         case 0x28 /* '(' */ :
00932         {
00933                 match('(' /* charlit */ );
00934                 break;
00935         }
00936         case 0x29 /* ')' */ :
00937         {
00938                 match(')' /* charlit */ );
00939                 break;
00940         }
00941         case 0x2a /* '*' */ :
00942         {
00943                 match('*' /* charlit */ );
00944                 break;
00945         }
00946         case 0x2b /* '+' */ :
00947         {
00948                 match('+' /* charlit */ );
00949                 break;
00950         }
00951         case 0x2c /* ',' */ :
00952         {
00953                 match(',' /* charlit */ );
00954                 break;
00955         }
00956         case 0x2d /* '-' */ :
00957         {
00958                 match('-' /* charlit */ );
00959                 break;
00960         }
00961         case 0x2e /* '.' */ :
00962         {
00963                 match('.' /* charlit */ );
00964                 break;
00965         }
00966         case 0x3b /* ';' */ :
00967         {
00968                 match(';' /* charlit */ );
00969                 break;
00970         }
00971         case 0x3c /* '<' */ :
00972         {
00973                 match('<' /* charlit */ );
00974                 break;
00975         }
00976         case 0x3f /* '?' */ :
00977         {
00978                 match('?' /* charlit */ );
00979                 break;
00980         }
00981         case 0x40 /* '@' */ :
00982         {
00983                 match('@' /* charlit */ );
00984                 break;
00985         }
00986         case 0x5b /* '[' */ :
00987         {
00988                 match('[' /* charlit */ );
00989                 break;
00990         }
00991         case 0x5d /* ']' */ :
00992         {
00993                 match(']' /* charlit */ );
00994                 break;
00995         }
00996         case 0x5e /* '^' */ :
00997         {
00998                 match('^' /* charlit */ );
00999                 break;
01000         }
01001         case 0x5f /* '_' */ :
01002         {
01003                 match('_' /* charlit */ );
01004                 break;
01005         }
01006         case 0x7b /* '{' */ :
01007         {
01008                 match('{' /* charlit */ );
01009                 break;
01010         }
01011         case 0x7c /* '|' */ :
01012         {
01013                 match('|' /* charlit */ );
01014                 break;
01015         }
01016         case 0x7d /* '}' */ :
01017         {
01018                 match('}' /* charlit */ );
01019                 break;
01020         }
01021         case 0x7e /* '~' */ :
01022         {
01023                 match('~' /* charlit */ );
01024                 break;
01025         }
01026         default:
01027         {
01028                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01029         }
01030         }
01031         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
01032            _token = makeToken(_ttype);
01033            _token->setText(text.substr(_begin, text.length()-_begin));
01034         }
01035         _returnToken = _token;
01036         _saveIndex=0;
01037 }

void EDILexer::mSIGN ( bool _createToken ) [protected]

Definition at line 1039 of file EDILexer.cpp.

References SIGN.

01039                                       {
01040         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
01041         _ttype = SIGN;
01042         std::string::size_type _saveIndex;
01043         
01044         switch ( LA(1)) {
01045         case 0x2b /* '+' */ :
01046         {
01047                 match('+' /* charlit */ );
01048                 break;
01049         }
01050         case 0x2d /* '-' */ :
01051         {
01052                 match('-' /* charlit */ );
01053                 break;
01054         }
01055         default:
01056         {
01057                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01058         }
01059         }
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 }


Public Member Functions
bool	getCaseSensitiveLiterals () const
	EDILexer (std::istream &in)
	EDILexer (antlr::InputBuffer &ib)
	EDILexer (const antlr::LexerSharedInputState &state)
antlr::RefToken	nextToken ()
void	mHEAD (bool _createToken)
void	mKEYWORD (bool _createToken)
void	mSPECIAL (bool _createToken)
void	mSTRING (bool _createToken)
void	mWS (bool _createToken)
void	mEQUAL (bool _createToken)
void	mSLASH (bool _createToken)
void	mEXKL (bool _createToken)
void	mCOLON (bool _createToken)
void	mCOMMENT (bool _createToken)
void	mNUMBER (bool _createToken)
void	mDATE (bool _createToken)
void	mDIGIT (bool _createToken)
void	mOTHER (bool _createToken)
Protected Member Functions
void	mREAL (bool _createToken)
void	mINT (bool _createToken)
void	mLETTER (bool _createToken)
void	mLEGAL_CHAR (bool _createToken)
void	mSIGN (bool _createToken)

EDILexer Class Reference

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation