MT Tools » J Parser

JLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.6 (20070220): "JParser.g" -> "JLexer.cpp"$ */
00002 #include "JLexer.hpp"
00003 #include <antlr/CharBuffer.hpp>
00004 #include <antlr/TokenStreamException.hpp>
00005 #include <antlr/TokenStreamIOException.hpp>
00006 #include <antlr/TokenStreamRecognitionException.hpp>
00007 #include <antlr/CharStreamException.hpp>
00008 #include <antlr/CharStreamIOException.hpp>
00009 #include <antlr/NoViableAltForCharException.hpp>
00010 
00011 #line 1 "JParser.g"
00012 #line 13 "JLexer.cpp"
00013 JLexer::JLexer(std::istream& in)
00014         : antlr::CharScanner(new antlr::CharBuffer(in),false)
00015 {
00016         initLiterals();
00017 }
00018 
00019 JLexer::JLexer(antlr::InputBuffer& ib)
00020         : antlr::CharScanner(ib,false)
00021 {
00022         initLiterals();
00023 }
00024 
00025 JLexer::JLexer(const antlr::LexerSharedInputState& state)
00026         : antlr::CharScanner(state,false)
00027 {
00028         initLiterals();
00029 }
00030 
00031 void JLexer::initLiterals()
00032 {
00033 }
00034 
00035 antlr::RefToken JLexer::nextToken()
00036 {
00037         antlr::RefToken theRetToken;
00038         for (;;) {
00039                 antlr::RefToken theRetToken;
00040                 int _ttype = antlr::Token::INVALID_TYPE;
00041                 resetText();
00042                 try {   // for lexical and char stream error handling
00043                         switch ( LA(1)) {
00044                         case 0x3d /* '=' */ :
00045                         {
00046                                 mEQUAL(true);
00047                                 theRetToken=_returnToken;
00048                                 break;
00049                         }
00050                         case 0x9 /* '\t' */ :
00051                         case 0x20 /* ' ' */ :
00052                         {
00053                                 mWS(true);
00054                                 theRetToken=_returnToken;
00055                                 break;
00056                         }
00057                         case 0x23 /* '#' */ :
00058                         {
00059                                 mCOMMENT(true);
00060                                 theRetToken=_returnToken;
00061                                 break;
00062                         }
00063                         case 0xa /* '\n' */ :
00064                         case 0xd /* '\r' */ :
00065                         {
00066                                 mNEWLINE(true);
00067                                 theRetToken=_returnToken;
00068                                 break;
00069                         }
00070                         default:
00071                                 if ((LA(1) == 0x75 /* 'u' */ ) && (LA(2) == 0x6e /* 'n' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x74 /* 't' */ ) && (LA(5) == 0x73 /* 's' */ ) && (true)) {
00072                                         mUNITS(true);
00073                                         theRetToken=_returnToken;
00074                                 }
00075                                 else if ((LA(1) == 0x66 /* 'f' */ ) && (LA(2) == 0x69 /* 'i' */ ) && (LA(3) == 0x65 /* 'e' */ ) && (LA(4) == 0x6c /* 'l' */ ) && (LA(5) == 0x64 /* 'd' */ ) && (true)) {
00076                                         mFIELD(true);
00077                                         theRetToken=_returnToken;
00078                                 }
00079                                 else if ((LA(1) == 0x73 /* 's' */ ) && (LA(2) == 0x2e /* '.' */ ) && (LA(3) == 0x69 /* 'i' */ ) && (LA(4) == 0x2e /* '.' */ ) && (true) && (true)) {
00080                                         mSI(true);
00081                                         theRetToken=_returnToken;
00082                                 }
00083                                 else if ((LA(1) == 0x6e /* 'n' */ ) && (LA(2) == 0x61 /* 'a' */ ) && (LA(3) == 0x6e /* 'n' */ ) && (true) && (true) && (true)) {
00084                                         mUNDEF(true);
00085                                         theRetToken=_returnToken;
00086                                 }
00087                                 else if ((LA(1) == 0x7a /* 'z' */ ) && (LA(2) == 0x78 /* 'x' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (true) && (true) && (true)) {
00088                                         mZXX(true);
00089                                         theRetToken=_returnToken;
00090                                 }
00091                                 else if ((LA(1) == 0x7a /* 'z' */ ) && (LA(2) == 0x78 /* 'x' */ ) && (LA(3) == 0x79 /* 'y' */ ) && (true) && (true) && (true)) {
00092                                         mZXY(true);
00093                                         theRetToken=_returnToken;
00094                                 }
00095                                 else if ((LA(1) == 0x7a /* 'z' */ ) && (LA(2) == 0x79 /* 'y' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (true) && (true) && (true)) {
00096                                         mZYX(true);
00097                                         theRetToken=_returnToken;
00098                                 }
00099                                 else if ((LA(1) == 0x7a /* 'z' */ ) && (LA(2) == 0x79 /* 'y' */ ) && (LA(3) == 0x79 /* 'y' */ ) && (true) && (true) && (true)) {
00100                                         mZYY(true);
00101                                         theRetToken=_returnToken;
00102                                 }
00103                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x78 /* 'x' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (true) && (true) && (true)) {
00104                                         mRXX(true);
00105                                         theRetToken=_returnToken;
00106                                 }
00107                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x78 /* 'x' */ ) && (LA(3) == 0x79 /* 'y' */ ) && (true) && (true) && (true)) {
00108                                         mRXY(true);
00109                                         theRetToken=_returnToken;
00110                                 }
00111                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x79 /* 'y' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (true) && (true) && (true)) {
00112                                         mRYX(true);
00113                                         theRetToken=_returnToken;
00114                                 }
00115                                 else if ((LA(1) == 0x72 /* 'r' */ ) && (LA(2) == 0x79 /* 'y' */ ) && (LA(3) == 0x79 /* 'y' */ ) && (true) && (true) && (true)) {
00116                                         mRYY(true);
00117                                         theRetToken=_returnToken;
00118                                 }
00119                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x7a /* 'z' */ ) && (LA(3) == 0x78 /* 'x' */ ) && (true) && (true) && (true)) {
00120                                         mTZX(true);
00121                                         theRetToken=_returnToken;
00122                                 }
00123                                 else if ((LA(1) == 0x74 /* 't' */ ) && (LA(2) == 0x7a /* 'z' */ ) && (LA(3) == 0x79 /* 'y' */ ) && (true) && (true) && (true)) {
00124                                         mTZY(true);
00125                                         theRetToken=_returnToken;
00126                                 }
00127                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x6f /* 'o' */ )) {
00128                                         mLONGITUDE(true);
00129                                         theRetToken=_returnToken;
00130                                 }
00131                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x6c /* 'l' */ ) && (LA(3) == 0x61 /* 'a' */ )) {
00132                                         mLATITUDE(true);
00133                                         theRetToken=_returnToken;
00134                                 }
00135                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x65 /* 'e' */ )) {
00136                                         mELEVATION(true);
00137                                         theRetToken=_returnToken;
00138                                 }
00139                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x61 /* 'a' */ )) {
00140                                         mAZIMUTH(true);
00141                                         theRetToken=_returnToken;
00142                                 }
00143                                 else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x73 /* 's' */ )) {
00144                                         mSTATION(true);
00145                                         theRetToken=_returnToken;
00146                                 }
00147                                 else if ((_tokenSet_0.member(LA(1))) && (true) && (true) && (true) && (true) && (true)) {
00148                                         mENTRY(true);
00149                                         theRetToken=_returnToken;
00150                                 }
00151                         else {
00152                                 if (LA(1)==EOF_CHAR)
00153                                 {
00154                                         uponEOF();
00155                                         _returnToken = makeToken(antlr::Token::EOF_TYPE);
00156                                 }
00157                                 else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00158                         }
00159                         }
00160                         if ( !_returnToken )
00161                                 goto tryAgain; // found SKIP token
00162 
00163                         _ttype = _returnToken->getType();
00164                         _ttype = testLiteralsTable(_ttype);
00165                         _returnToken->setType(_ttype);
00166                         return _returnToken;
00167                 }
00168                 catch (antlr::RecognitionException& e) {
00169                                 throw antlr::TokenStreamRecognitionException(e);
00170                 }
00171                 catch (antlr::CharStreamIOException& csie) {
00172                         throw antlr::TokenStreamIOException(csie.io);
00173                 }
00174                 catch (antlr::CharStreamException& cse) {
00175                         throw antlr::TokenStreamException(cse.getMessage());
00176                 }
00177 tryAgain:;
00178         }
00179 }
00180 
00181 void JLexer::mUNDEF(bool _createToken) {
00182         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00183         _ttype = UNDEF;
00184         std::string::size_type _saveIndex;
00185         
00186         match("nan");
00187         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00188            _token = makeToken(_ttype);
00189            _token->setText(text.substr(_begin, text.length()-_begin));
00190         }
00191         _returnToken = _token;
00192         _saveIndex=0;
00193 }
00194 
00195 void JLexer::mZXX(bool _createToken) {
00196         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00197         _ttype = ZXX;
00198         std::string::size_type _saveIndex;
00199         
00200         match("zxx");
00201         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00202            _token = makeToken(_ttype);
00203            _token->setText(text.substr(_begin, text.length()-_begin));
00204         }
00205         _returnToken = _token;
00206         _saveIndex=0;
00207 }
00208 
00209 void JLexer::mZXY(bool _createToken) {
00210         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00211         _ttype = ZXY;
00212         std::string::size_type _saveIndex;
00213         
00214         match("zxy");
00215         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00216            _token = makeToken(_ttype);
00217            _token->setText(text.substr(_begin, text.length()-_begin));
00218         }
00219         _returnToken = _token;
00220         _saveIndex=0;
00221 }
00222 
00223 void JLexer::mZYX(bool _createToken) {
00224         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00225         _ttype = ZYX;
00226         std::string::size_type _saveIndex;
00227         
00228         match("zyx");
00229         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00230            _token = makeToken(_ttype);
00231            _token->setText(text.substr(_begin, text.length()-_begin));
00232         }
00233         _returnToken = _token;
00234         _saveIndex=0;
00235 }
00236 
00237 void JLexer::mZYY(bool _createToken) {
00238         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00239         _ttype = ZYY;
00240         std::string::size_type _saveIndex;
00241         
00242         match("zyy");
00243         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00244            _token = makeToken(_ttype);
00245            _token->setText(text.substr(_begin, text.length()-_begin));
00246         }
00247         _returnToken = _token;
00248         _saveIndex=0;
00249 }
00250 
00251 void JLexer::mRXX(bool _createToken) {
00252         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00253         _ttype = RXX;
00254         std::string::size_type _saveIndex;
00255         
00256         match("rxx");
00257         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00258            _token = makeToken(_ttype);
00259            _token->setText(text.substr(_begin, text.length()-_begin));
00260         }
00261         _returnToken = _token;
00262         _saveIndex=0;
00263 }
00264 
00265 void JLexer::mRXY(bool _createToken) {
00266         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00267         _ttype = RXY;
00268         std::string::size_type _saveIndex;
00269         
00270         match("rxy");
00271         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00272            _token = makeToken(_ttype);
00273            _token->setText(text.substr(_begin, text.length()-_begin));
00274         }
00275         _returnToken = _token;
00276         _saveIndex=0;
00277 }
00278 
00279 void JLexer::mRYX(bool _createToken) {
00280         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00281         _ttype = RYX;
00282         std::string::size_type _saveIndex;
00283         
00284         match("ryx");
00285         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00286            _token = makeToken(_ttype);
00287            _token->setText(text.substr(_begin, text.length()-_begin));
00288         }
00289         _returnToken = _token;
00290         _saveIndex=0;
00291 }
00292 
00293 void JLexer::mRYY(bool _createToken) {
00294         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00295         _ttype = RYY;
00296         std::string::size_type _saveIndex;
00297         
00298         match("ryy");
00299         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00300            _token = makeToken(_ttype);
00301            _token->setText(text.substr(_begin, text.length()-_begin));
00302         }
00303         _returnToken = _token;
00304         _saveIndex=0;
00305 }
00306 
00307 void JLexer::mTZX(bool _createToken) {
00308         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00309         _ttype = TZX;
00310         std::string::size_type _saveIndex;
00311         
00312         match("tzx");
00313         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00314            _token = makeToken(_ttype);
00315            _token->setText(text.substr(_begin, text.length()-_begin));
00316         }
00317         _returnToken = _token;
00318         _saveIndex=0;
00319 }
00320 
00321 void JLexer::mTZY(bool _createToken) {
00322         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00323         _ttype = TZY;
00324         std::string::size_type _saveIndex;
00325         
00326         match("tzy");
00327         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00328            _token = makeToken(_ttype);
00329            _token->setText(text.substr(_begin, text.length()-_begin));
00330         }
00331         _returnToken = _token;
00332         _saveIndex=0;
00333 }
00334 
00335 void JLexer::mUNITS(bool _createToken) {
00336         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00337         _ttype = UNITS;
00338         std::string::size_type _saveIndex;
00339         
00340         match("units");
00341         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00342            _token = makeToken(_ttype);
00343            _token->setText(text.substr(_begin, text.length()-_begin));
00344         }
00345         _returnToken = _token;
00346         _saveIndex=0;
00347 }
00348 
00349 void JLexer::mSI(bool _createToken) {
00350         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00351         _ttype = SI;
00352         std::string::size_type _saveIndex;
00353         
00354         match("s.i.");
00355         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00356            _token = makeToken(_ttype);
00357            _token->setText(text.substr(_begin, text.length()-_begin));
00358         }
00359         _returnToken = _token;
00360         _saveIndex=0;
00361 }
00362 
00363 void JLexer::mFIELD(bool _createToken) {
00364         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00365         _ttype = FIELD;
00366         std::string::size_type _saveIndex;
00367         
00368         match("field");
00369         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00370            _token = makeToken(_ttype);
00371            _token->setText(text.substr(_begin, text.length()-_begin));
00372         }
00373         _returnToken = _token;
00374         _saveIndex=0;
00375 }
00376 
00377 void JLexer::mELEVATION(bool _createToken) {
00378         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00379         _ttype = ELEVATION;
00380         std::string::size_type _saveIndex;
00381         
00382         match(">elevation");
00383         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00384            _token = makeToken(_ttype);
00385            _token->setText(text.substr(_begin, text.length()-_begin));
00386         }
00387         _returnToken = _token;
00388         _saveIndex=0;
00389 }
00390 
00391 void JLexer::mLONGITUDE(bool _createToken) {
00392         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00393         _ttype = LONGITUDE;
00394         std::string::size_type _saveIndex;
00395         
00396         match(">longitude");
00397         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00398            _token = makeToken(_ttype);
00399            _token->setText(text.substr(_begin, text.length()-_begin));
00400         }
00401         _returnToken = _token;
00402         _saveIndex=0;
00403 }
00404 
00405 void JLexer::mLATITUDE(bool _createToken) {
00406         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00407         _ttype = LATITUDE;
00408         std::string::size_type _saveIndex;
00409         
00410         match(">latitude");
00411         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00412            _token = makeToken(_ttype);
00413            _token->setText(text.substr(_begin, text.length()-_begin));
00414         }
00415         _returnToken = _token;
00416         _saveIndex=0;
00417 }
00418 
00419 void JLexer::mAZIMUTH(bool _createToken) {
00420         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00421         _ttype = AZIMUTH;
00422         std::string::size_type _saveIndex;
00423         
00424         match(">azimuth");
00425         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00426            _token = makeToken(_ttype);
00427            _token->setText(text.substr(_begin, text.length()-_begin));
00428         }
00429         _returnToken = _token;
00430         _saveIndex=0;
00431 }
00432 
00433 void JLexer::mSTATION(bool _createToken) {
00434         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00435         _ttype = STATION;
00436         std::string::size_type _saveIndex;
00437         
00438         match(">station");
00439         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00440            _token = makeToken(_ttype);
00441            _token->setText(text.substr(_begin, text.length()-_begin));
00442         }
00443         _returnToken = _token;
00444         _saveIndex=0;
00445 }
00446 
00447 void JLexer::mEQUAL(bool _createToken) {
00448         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00449         _ttype = EQUAL;
00450         std::string::size_type _saveIndex;
00451         
00452         match('=' /* charlit */ );
00453         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00454            _token = makeToken(_ttype);
00455            _token->setText(text.substr(_begin, text.length()-_begin));
00456         }
00457         _returnToken = _token;
00458         _saveIndex=0;
00459 }
00460 
00461 void JLexer::mPLUS(bool _createToken) {
00462         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00463         _ttype = PLUS;
00464         std::string::size_type _saveIndex;
00465         
00466         match('+' /* charlit */ );
00467         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00468            _token = makeToken(_ttype);
00469            _token->setText(text.substr(_begin, text.length()-_begin));
00470         }
00471         _returnToken = _token;
00472         _saveIndex=0;
00473 }
00474 
00475 void JLexer::mMINUS(bool _createToken) {
00476         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00477         _ttype = MINUS;
00478         std::string::size_type _saveIndex;
00479         
00480         match('-' /* charlit */ );
00481         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00482            _token = makeToken(_ttype);
00483            _token->setText(text.substr(_begin, text.length()-_begin));
00484         }
00485         _returnToken = _token;
00486         _saveIndex=0;
00487 }
00488 
00489 void JLexer::mWS(bool _createToken) {
00490         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00491         _ttype = WS;
00492         std::string::size_type _saveIndex;
00493         
00494         { // ( ... )+
00495         int _cnt55=0;
00496         for (;;) {
00497                 switch ( LA(1)) {
00498                 case 0x20 /* ' ' */ :
00499                 {
00500                         match(' ' /* charlit */ );
00501                         break;
00502                 }
00503                 case 0x9 /* '\t' */ :
00504                 {
00505                         match('\t' /* charlit */ );
00506                         break;
00507                 }
00508                 default:
00509                 {
00510                         if ( _cnt55>=1 ) { goto _loop55; } else {throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00511                 }
00512                 }
00513                 _cnt55++;
00514         }
00515         _loop55:;
00516         }  // ( ... )+
00517 #line 234 "JParser.g"
00518         _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00519 #line 520 "JLexer.cpp"
00520         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00521            _token = makeToken(_ttype);
00522            _token->setText(text.substr(_begin, text.length()-_begin));
00523         }
00524         _returnToken = _token;
00525         _saveIndex=0;
00526 }
00527 
00528 void JLexer::mENTRY(bool _createToken) {
00529         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00530         _ttype = ENTRY;
00531         std::string::size_type _saveIndex;
00532         
00533         {
00534         switch ( LA(1)) {
00535         case 0x2b /* '+' */ :
00536         {
00537                 mPLUS(false);
00538                 break;
00539         }
00540         case 0x2d /* '-' */ :
00541         {
00542                 mMINUS(false);
00543                 break;
00544         }
00545         case 0x61 /* 'a' */ :
00546         case 0x62 /* 'b' */ :
00547         case 0x63 /* 'c' */ :
00548         case 0x64 /* 'd' */ :
00549         case 0x65 /* 'e' */ :
00550         case 0x66 /* 'f' */ :
00551         case 0x67 /* 'g' */ :
00552         case 0x68 /* 'h' */ :
00553         case 0x69 /* 'i' */ :
00554         case 0x6a /* 'j' */ :
00555         case 0x6b /* 'k' */ :
00556         case 0x6c /* 'l' */ :
00557         case 0x6d /* 'm' */ :
00558         case 0x6e /* 'n' */ :
00559         case 0x6f /* 'o' */ :
00560         case 0x70 /* 'p' */ :
00561         case 0x71 /* 'q' */ :
00562         case 0x72 /* 'r' */ :
00563         case 0x73 /* 's' */ :
00564         case 0x74 /* 't' */ :
00565         case 0x75 /* 'u' */ :
00566         case 0x76 /* 'v' */ :
00567         case 0x77 /* 'w' */ :
00568         case 0x78 /* 'x' */ :
00569         case 0x79 /* 'y' */ :
00570         case 0x7a /* 'z' */ :
00571         {
00572                 mCHAR(false);
00573                 break;
00574         }
00575         case 0x30 /* '0' */ :
00576         case 0x31 /* '1' */ :
00577         case 0x32 /* '2' */ :
00578         case 0x33 /* '3' */ :
00579         case 0x34 /* '4' */ :
00580         case 0x35 /* '5' */ :
00581         case 0x36 /* '6' */ :
00582         case 0x37 /* '7' */ :
00583         case 0x38 /* '8' */ :
00584         case 0x39 /* '9' */ :
00585         {
00586                 mDIGIT(false);
00587                 break;
00588         }
00589         default:
00590         {
00591                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00592         }
00593         }
00594         }
00595         { // ( ... )*
00596         for (;;) {
00597                 switch ( LA(1)) {
00598                 case 0x61 /* 'a' */ :
00599                 case 0x62 /* 'b' */ :
00600                 case 0x63 /* 'c' */ :
00601                 case 0x64 /* 'd' */ :
00602                 case 0x65 /* 'e' */ :
00603                 case 0x66 /* 'f' */ :
00604                 case 0x67 /* 'g' */ :
00605                 case 0x68 /* 'h' */ :
00606                 case 0x69 /* 'i' */ :
00607                 case 0x6a /* 'j' */ :
00608                 case 0x6b /* 'k' */ :
00609                 case 0x6c /* 'l' */ :
00610                 case 0x6d /* 'm' */ :
00611                 case 0x6e /* 'n' */ :
00612                 case 0x6f /* 'o' */ :
00613                 case 0x70 /* 'p' */ :
00614                 case 0x71 /* 'q' */ :
00615                 case 0x72 /* 'r' */ :
00616                 case 0x73 /* 's' */ :
00617                 case 0x74 /* 't' */ :
00618                 case 0x75 /* 'u' */ :
00619                 case 0x76 /* 'v' */ :
00620                 case 0x77 /* 'w' */ :
00621                 case 0x78 /* 'x' */ :
00622                 case 0x79 /* 'y' */ :
00623                 case 0x7a /* 'z' */ :
00624                 {
00625                         mCHAR(false);
00626                         break;
00627                 }
00628                 case 0x30 /* '0' */ :
00629                 case 0x31 /* '1' */ :
00630                 case 0x32 /* '2' */ :
00631                 case 0x33 /* '3' */ :
00632                 case 0x34 /* '4' */ :
00633                 case 0x35 /* '5' */ :
00634                 case 0x36 /* '6' */ :
00635                 case 0x37 /* '7' */ :
00636                 case 0x38 /* '8' */ :
00637                 case 0x39 /* '9' */ :
00638                 {
00639                         mDIGIT(false);
00640                         break;
00641                 }
00642                 case 0x23 /* '#' */ :
00643                 case 0x24 /* '$' */ :
00644                 case 0x25 /* '%' */ :
00645                 case 0x26 /* '&' */ :
00646                 case 0x27 /* '\'' */ :
00647                 case 0x28 /* '(' */ :
00648                 case 0x29 /* ')' */ :
00649                 case 0x2a /* '*' */ :
00650                 case 0x2c /* ',' */ :
00651                 case 0x2e /* '.' */ :
00652                 case 0x2f /* '/' */ :
00653                 case 0x3a /* ':' */ :
00654                 case 0x3b /* ';' */ :
00655                 case 0x3c /* '<' */ :
00656                 case 0x3f /* '?' */ :
00657                 case 0x40 /* '@' */ :
00658                 case 0x5b /* '[' */ :
00659                 case 0x5d /* ']' */ :
00660                 case 0x5e /* '^' */ :
00661                 case 0x5f /* '_' */ :
00662                 case 0x7b /* '{' */ :
00663                 case 0x7c /* '|' */ :
00664                 case 0x7d /* '}' */ :
00665                 case 0x7e /* '~' */ :
00666                 {
00667                         mOTHER(false);
00668                         break;
00669                 }
00670                 case 0x2b /* '+' */ :
00671                 {
00672                         mPLUS(false);
00673                         break;
00674                 }
00675                 case 0x2d /* '-' */ :
00676                 {
00677                         mMINUS(false);
00678                         break;
00679                 }
00680                 default:
00681                 {
00682                         goto _loop59;
00683                 }
00684                 }
00685         }
00686         _loop59:;
00687         } // ( ... )*
00688         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00689            _token = makeToken(_ttype);
00690            _token->setText(text.substr(_begin, text.length()-_begin));
00691         }
00692         _returnToken = _token;
00693         _saveIndex=0;
00694 }
00695 
00696 void JLexer::mCHAR(bool _createToken) {
00697         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00698         _ttype = CHAR;
00699         std::string::size_type _saveIndex;
00700         
00701         {
00702         matchRange('a','z');
00703         }
00704         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00705            _token = makeToken(_ttype);
00706            _token->setText(text.substr(_begin, text.length()-_begin));
00707         }
00708         _returnToken = _token;
00709         _saveIndex=0;
00710 }
00711 
00712 void JLexer::mDIGIT(bool _createToken) {
00713         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00714         _ttype = DIGIT;
00715         std::string::size_type _saveIndex;
00716         
00717         matchRange('0','9');
00718         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00719            _token = makeToken(_ttype);
00720            _token->setText(text.substr(_begin, text.length()-_begin));
00721         }
00722         _returnToken = _token;
00723         _saveIndex=0;
00724 }
00725 
00726 void JLexer::mOTHER(bool _createToken) {
00727         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00728         _ttype = OTHER;
00729         std::string::size_type _saveIndex;
00730         
00731         switch ( LA(1)) {
00732         case 0x27 /* '\'' */ :
00733         {
00734                 match('\'' /* charlit */ );
00735                 break;
00736         }
00737         case 0x23 /* '#' */ :
00738         {
00739                 match('#' /* charlit */ );
00740                 break;
00741         }
00742         case 0x24 /* '$' */ :
00743         {
00744                 match('$' /* charlit */ );
00745                 break;
00746         }
00747         case 0x25 /* '%' */ :
00748         {
00749                 match('%' /* charlit */ );
00750                 break;
00751         }
00752         case 0x26 /* '&' */ :
00753         {
00754                 match('&' /* charlit */ );
00755                 break;
00756         }
00757         case 0x28 /* '(' */ :
00758         {
00759                 match('(' /* charlit */ );
00760                 break;
00761         }
00762         case 0x29 /* ')' */ :
00763         {
00764                 match(')' /* charlit */ );
00765                 break;
00766         }
00767         case 0x2a /* '*' */ :
00768         {
00769                 match('*' /* charlit */ );
00770                 break;
00771         }
00772         case 0x2c /* ',' */ :
00773         {
00774                 match(',' /* charlit */ );
00775                 break;
00776         }
00777         case 0x2e /* '.' */ :
00778         {
00779                 match('.' /* charlit */ );
00780                 break;
00781         }
00782         case 0x2f /* '/' */ :
00783         {
00784                 match('/' /* charlit */ );
00785                 break;
00786         }
00787         case 0x3a /* ':' */ :
00788         {
00789                 match(':' /* charlit */ );
00790                 break;
00791         }
00792         case 0x3b /* ';' */ :
00793         {
00794                 match(';' /* charlit */ );
00795                 break;
00796         }
00797         case 0x3c /* '<' */ :
00798         {
00799                 match('<' /* charlit */ );
00800                 break;
00801         }
00802         case 0x3f /* '?' */ :
00803         {
00804                 match('?' /* charlit */ );
00805                 break;
00806         }
00807         case 0x40 /* '@' */ :
00808         {
00809                 match('@' /* charlit */ );
00810                 break;
00811         }
00812         case 0x5b /* '[' */ :
00813         {
00814                 match('[' /* charlit */ );
00815                 break;
00816         }
00817         case 0x5d /* ']' */ :
00818         {
00819                 match(']' /* charlit */ );
00820                 break;
00821         }
00822         case 0x5e /* '^' */ :
00823         {
00824                 match('^' /* charlit */ );
00825                 break;
00826         }
00827         case 0x7b /* '{' */ :
00828         {
00829                 match('{' /* charlit */ );
00830                 break;
00831         }
00832         case 0x7c /* '|' */ :
00833         {
00834                 match('|' /* charlit */ );
00835                 break;
00836         }
00837         case 0x7d /* '}' */ :
00838         {
00839                 match('}' /* charlit */ );
00840                 break;
00841         }
00842         case 0x7e /* '~' */ :
00843         {
00844                 match('~' /* charlit */ );
00845                 break;
00846         }
00847         case 0x5f /* '_' */ :
00848         {
00849                 match('_' /* charlit */ );
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 }
00864 
00865 void JLexer::mCOMMENT(bool _createToken) {
00866         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00867         _ttype = COMMENT;
00868         std::string::size_type _saveIndex;
00869         
00870         match('#' /* charlit */ );
00871         { // ( ... )*
00872         for (;;) {
00873                 if ((_tokenSet_1.member(LA(1)))) {
00874                         {
00875                         match(_tokenSet_1);
00876                         }
00877                 }
00878                 else {
00879                         goto _loop63;
00880                 }
00881                 
00882         }
00883         _loop63:;
00884         } // ( ... )*
00885         mNEWLINE(false);
00886 #line 246 "JParser.g"
00887         
00888                                 //$setType(ANTLR_USE_NAMESPACE(antlr)Token::SKIP);
00889                         
00890 #line 891 "JLexer.cpp"
00891         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00892            _token = makeToken(_ttype);
00893            _token->setText(text.substr(_begin, text.length()-_begin));
00894         }
00895         _returnToken = _token;
00896         _saveIndex=0;
00897 }
00898 
00899 void JLexer::mNEWLINE(bool _createToken) {
00900         int _ttype; antlr::RefToken _token; std::string::size_type _begin = text.length();
00901         _ttype = NEWLINE;
00902         std::string::size_type _saveIndex;
00903         
00904         {
00905         switch ( LA(1)) {
00906         case 0xa /* '\n' */ :
00907         {
00908                 match('\n' /* charlit */ );
00909                 break;
00910         }
00911         case 0xd /* '\r' */ :
00912         {
00913                 match('\r' /* charlit */ );
00914                 match('\n' /* charlit */ );
00915                 break;
00916         }
00917         default:
00918         {
00919                 throw antlr::NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00920         }
00921         }
00922         }
00923 #line 254 "JParser.g"
00924         newline();
00925 #line 926 "JLexer.cpp"
00926         if ( _createToken && _token==antlr::nullToken && _ttype!=antlr::Token::SKIP ) {
00927            _token = makeToken(_ttype);
00928            _token->setText(text.substr(_begin, text.length()-_begin));
00929         }
00930         _returnToken = _token;
00931         _saveIndex=0;
00932 }
00933 
00934 
00935 const unsigned long JLexer::_tokenSet_0_data_[] = { 0UL, 67053568UL, 0UL, 134217726UL, 0UL, 0UL, 0UL, 0UL };
00936 const antlr::BitSet JLexer::_tokenSet_0(_tokenSet_0_data_,8);
00937 const unsigned long JLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL };
00938 // 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
00939 // 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   
00940 const antlr::BitSet JLexer::_tokenSet_1(_tokenSet_1_data_,8);
00941
Generated on Thu Nov 22 13:58:25 2007 for GPLIB++ by  doxygen 1.5.1