KDevelop API Documentation

PascalLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "pascal.g" -> "PascalLexer.cpp"$ */
00002 #include "PascalLexer.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 "pascal.g"
00012 #line 13 "PascalLexer.cpp"
00013 PascalLexer::PascalLexer(ANTLR_USE_NAMESPACE(std)istream& in)
00014     : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),false)
00015 {
00016     initLiterals();
00017 }
00018 
00019 PascalLexer::PascalLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
00020     : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,false)
00021 {
00022     initLiterals();
00023 }
00024 
00025 PascalLexer::PascalLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
00026     : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,false)
00027 {
00028     initLiterals();
00029 }
00030 
00031 void PascalLexer::initLiterals()
00032 {
00033     literals["until"] = 146;
00034     literals["xor"] = 123;
00035     literals["abstract"] = 99;
00036     literals["shortint"] = 69;
00037     literals["with"] = 150;
00038     literals["packed"] = 91;
00039     literals["inherited"] = 172;
00040     literals["break"] = 168;
00041     literals["smallint"] = 70;
00042     literals["safecall"] = 64;
00043     literals["constructor"] = 102;
00044     literals["continue"] = 169;
00045     literals["uses"] = 30;
00046     literals["for"] = 147;
00047     literals["else"] = 142;
00048     literals["is"] = 119;
00049     literals["of"] = 51;
00050     literals["and"] = 128;
00051     literals["integer"] = 68;
00052     literals["byte"] = 73;
00053     literals["nil"] = 161;
00054     literals["begin"] = 34;
00055     literals["interface"] = 32;
00056     literals["as"] = 165;
00057     literals["div"] = 126;
00058     literals["write"] = 110;
00059     literals["qword"] = 76;
00060     literals["procedure"] = 47;
00061     literals["shl"] = 129;
00062     literals["var"] = 45;
00063     literals["private"] = 100;
00064     literals["function"] = 49;
00065     literals["unit"] = 31;
00066     literals["downto"] = 149;
00067     literals["name"] = 29;
00068     literals["resourcestring"] = 42;
00069     literals["register"] = 57;
00070     literals["popstack"] = 61;
00071     literals["label"] = 40;
00072     literals["try"] = 155;
00073     literals["raise"] = 154;
00074     literals["not"] = 131;
00075     literals["record"] = 92;
00076     literals["forward"] = 48;
00077     literals["in"] = 118;
00078     literals["except"] = 156;
00079     literals["file"] = 95;
00080     literals["operator"] = 153;
00081     literals["pascal"] = 58;
00082     literals["finalization"] = 39;
00083     literals["cdecl"] = 59;
00084     literals["extended"] = 86;
00085     literals["external"] = 52;
00086     literals["destructor"] = 103;
00087     literals["real"] = 83;
00088     literals["virtual"] = 98;
00089     literals["chr"] = 160;
00090     literals["near"] = 65;
00091     literals["object"] = 97;
00092     literals["public"] = 53;
00093     literals["repeat"] = 145;
00094     literals["library"] = 23;
00095     literals["false"] = 133;
00096     literals["longint"] = 71;
00097     literals["saveregisters"] = 62;
00098     literals["to"] = 148;
00099     literals["asm"] = 166;
00100     literals["case"] = 93;
00101     literals["export"] = 56;
00102     literals["true"] = 132;
00103     literals["do"] = 144;
00104     literals["stdcall"] = 60;
00105     literals["program"] = 35;
00106     literals["absolute"] = 164;
00107     literals["override"] = 105;
00108     literals["then"] = 141;
00109     literals["set"] = 94;
00110     literals["protected"] = 101;
00111     literals["or"] = 122;
00112     literals["word"] = 74;
00113     literals["finally"] = 157;
00114     literals["char"] = 80;
00115     literals["if"] = 140;
00116     literals["far"] = 66;
00117     literals["const"] = 41;
00118     literals["index"] = 28;
00119     literals["assembler"] = 167;
00120     literals["cardinal"] = 75;
00121     literals["string"] = 88;
00122     literals["dispose"] = 170;
00123     literals["read"] = 109;
00124     literals["default"] = 111;
00125     literals["new"] = 173;
00126     literals["array"] = 50;
00127     literals["self"] = 174;
00128     literals["end"] = 25;
00129     literals["single"] = 84;
00130     literals["property"] = 108;
00131     literals["mod"] = 127;
00132     literals["goto"] = 139;
00133     literals["on"] = 158;
00134     literals["comp"] = 87;
00135     literals["initialization"] = 38;
00136     literals["class"] = 104;
00137     literals["int64"] = 72;
00138     literals["published"] = 107;
00139     literals["nodefault"] = 112;
00140     literals["inline"] = 63;
00141     literals["while"] = 143;
00142     literals["boolean"] = 77;
00143     literals["type"] = 44;
00144     literals["double"] = 85;
00145     literals["implementation"] = 33;
00146     literals["exports"] = 26;
00147     literals["alias"] = 54;
00148     literals["exit"] = 171;
00149     literals["shr"] = 130;
00150 }
00151 
00152 ANTLR_USE_NAMESPACE(antlr)RefToken PascalLexer::nextToken()
00153 {
00154     ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00155     for (;;) {
00156         ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00157         int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
00158         resetText();
00159         try {   // for lexical and char stream error handling
00160             switch ( LA(1)) {
00161             case static_cast<unsigned char>(','):
00162             {
00163                 mCOMMA(true);
00164                 theRetToken=_returnToken;
00165                 break;
00166             }
00167             case static_cast<unsigned char>(';'):
00168             {
00169                 mSEMI(true);
00170                 theRetToken=_returnToken;
00171                 break;
00172             }
00173             case static_cast<unsigned char>('='):
00174             {
00175                 mEQUAL(true);
00176                 theRetToken=_returnToken;
00177                 break;
00178             }
00179             case static_cast<unsigned char>(')'):
00180             {
00181                 mRPAREN(true);
00182                 theRetToken=_returnToken;
00183                 break;
00184             }
00185             case static_cast<unsigned char>('['):
00186             {
00187                 mLBRACK(true);
00188                 theRetToken=_returnToken;
00189                 break;
00190             }
00191             case static_cast<unsigned char>(']'):
00192             {
00193                 mRBRACK(true);
00194                 theRetToken=_returnToken;
00195                 break;
00196             }
00197             case static_cast<unsigned char>('^'):
00198             {
00199                 mPOINTER(true);
00200                 theRetToken=_returnToken;
00201                 break;
00202             }
00203             case static_cast<unsigned char>('@'):
00204             {
00205                 mAT(true);
00206                 theRetToken=_returnToken;
00207                 break;
00208             }
00209             case static_cast<unsigned char>('}'):
00210             {
00211                 mRCURLY(true);
00212                 theRetToken=_returnToken;
00213                 break;
00214             }
00215             case static_cast<unsigned char>('\t'):
00216             case static_cast<unsigned char>('\n'):
00217             case static_cast<unsigned char>('\14'):
00218             case static_cast<unsigned char>('\r'):
00219             case static_cast<unsigned char>(' '):
00220             {
00221                 mWS(true);
00222                 theRetToken=_returnToken;
00223                 break;
00224             }
00225             case static_cast<unsigned char>('a'):
00226             case static_cast<unsigned char>('b'):
00227             case static_cast<unsigned char>('c'):
00228             case static_cast<unsigned char>('d'):
00229             case static_cast<unsigned char>('e'):
00230             case static_cast<unsigned char>('f'):
00231             case static_cast<unsigned char>('g'):
00232             case static_cast<unsigned char>('h'):
00233             case static_cast<unsigned char>('i'):
00234             case static_cast<unsigned char>('j'):
00235             case static_cast<unsigned char>('k'):
00236             case static_cast<unsigned char>('l'):
00237             case static_cast<unsigned char>('m'):
00238             case static_cast<unsigned char>('n'):
00239             case static_cast<unsigned char>('o'):
00240             case static_cast<unsigned char>('p'):
00241             case static_cast<unsigned char>('q'):
00242             case static_cast<unsigned char>('r'):
00243             case static_cast<unsigned char>('s'):
00244             case static_cast<unsigned char>('t'):
00245             case static_cast<unsigned char>('u'):
00246             case static_cast<unsigned char>('v'):
00247             case static_cast<unsigned char>('w'):
00248             case static_cast<unsigned char>('x'):
00249             case static_cast<unsigned char>('y'):
00250             case static_cast<unsigned char>('z'):
00251             {
00252                 mIDENT(true);
00253                 theRetToken=_returnToken;
00254                 break;
00255             }
00256             case static_cast<unsigned char>('\''):
00257             {
00258                 mSTRING_LITERAL(true);
00259                 theRetToken=_returnToken;
00260                 break;
00261             }
00262             case static_cast<unsigned char>('0'):
00263             case static_cast<unsigned char>('1'):
00264             case static_cast<unsigned char>('2'):
00265             case static_cast<unsigned char>('3'):
00266             case static_cast<unsigned char>('4'):
00267             case static_cast<unsigned char>('5'):
00268             case static_cast<unsigned char>('6'):
00269             case static_cast<unsigned char>('7'):
00270             case static_cast<unsigned char>('8'):
00271             case static_cast<unsigned char>('9'):
00272             {
00273                 mNUM_INT(true);
00274                 theRetToken=_returnToken;
00275                 break;
00276             }
00277             default:
00278                 if ((LA(1) == static_cast<unsigned char>(':')) && (LA(2) == static_cast<unsigned char>('='))) {
00279                     mASSIGN(true);
00280                     theRetToken=_returnToken;
00281                 }
00282                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('>'))) {
00283                     mNOT_EQUAL(true);
00284                     theRetToken=_returnToken;
00285                 }
00286                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('='))) {
00287                     mLE(true);
00288                     theRetToken=_returnToken;
00289                 }
00290                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('='))) {
00291                     mGE(true);
00292                     theRetToken=_returnToken;
00293                 }
00294                 else if ((LA(1) == static_cast<unsigned char>('(')) && (LA(2) == static_cast<unsigned char>('.'))) {
00295                     mLBRACK2(true);
00296                     theRetToken=_returnToken;
00297                 }
00298                 else if ((LA(1) == static_cast<unsigned char>('.')) && (LA(2) == static_cast<unsigned char>(')'))) {
00299                     mRBRACK2(true);
00300                     theRetToken=_returnToken;
00301                 }
00302                 else if ((LA(1) == static_cast<unsigned char>('+')) && (LA(2) == static_cast<unsigned char>('='))) {
00303                     mPLUSEQ(true);
00304                     theRetToken=_returnToken;
00305                 }
00306                 else if ((LA(1) == static_cast<unsigned char>('-')) && (LA(2) == static_cast<unsigned char>('='))) {
00307                     mMINUSEQ(true);
00308                     theRetToken=_returnToken;
00309                 }
00310                 else if ((LA(1) == static_cast<unsigned char>('*')) && (LA(2) == static_cast<unsigned char>('='))) {
00311                     mSTAREQ(true);
00312                     theRetToken=_returnToken;
00313                 }
00314                 else if ((LA(1) == static_cast<unsigned char>('/')) && (LA(2) == static_cast<unsigned char>('='))) {
00315                     mSLASHQE(true);
00316                     theRetToken=_returnToken;
00317                 }
00318                 else if ((LA(1) == static_cast<unsigned char>('(')) && (LA(2) == static_cast<unsigned char>('*'))) {
00319                     mCOMMENT_1(true);
00320                     theRetToken=_returnToken;
00321                 }
00322                 else if ((LA(1) == static_cast<unsigned char>('{')) && ((LA(2) >= static_cast<unsigned char>('\0') && LA(2) <= static_cast<unsigned char>('\377')))) {
00323                     mCOMMENT_2(true);
00324                     theRetToken=_returnToken;
00325                 }
00326                 else if ((LA(1) == static_cast<unsigned char>('/')) && (LA(2) == static_cast<unsigned char>('/'))) {
00327                     mCOMMENT_3(true);
00328                     theRetToken=_returnToken;
00329                 }
00330                 else if ((LA(1) == static_cast<unsigned char>('+')) && (true)) {
00331                     mPLUS(true);
00332                     theRetToken=_returnToken;
00333                 }
00334                 else if ((LA(1) == static_cast<unsigned char>('-')) && (true)) {
00335                     mMINUS(true);
00336                     theRetToken=_returnToken;
00337                 }
00338                 else if ((LA(1) == static_cast<unsigned char>('*')) && (true)) {
00339                     mSTAR(true);
00340                     theRetToken=_returnToken;
00341                 }
00342                 else if ((LA(1) == static_cast<unsigned char>('/')) && (true)) {
00343                     mSLASH(true);
00344                     theRetToken=_returnToken;
00345                 }
00346                 else if ((LA(1) == static_cast<unsigned char>(':')) && (true)) {
00347                     mCOLON(true);
00348                     theRetToken=_returnToken;
00349                 }
00350                 else if ((LA(1) == static_cast<unsigned char>('<')) && (true)) {
00351                     mLTH(true);
00352                     theRetToken=_returnToken;
00353                 }
00354                 else if ((LA(1) == static_cast<unsigned char>('>')) && (true)) {
00355                     mGT(true);
00356                     theRetToken=_returnToken;
00357                 }
00358                 else if ((LA(1) == static_cast<unsigned char>('(')) && (true)) {
00359                     mLPAREN(true);
00360                     theRetToken=_returnToken;
00361                 }
00362                 else if ((LA(1) == static_cast<unsigned char>('.')) && (true)) {
00363                     mDOT(true);
00364                     theRetToken=_returnToken;
00365                 }
00366                 else if ((LA(1) == static_cast<unsigned char>('{')) && (true)) {
00367                     mLCURLY(true);
00368                     theRetToken=_returnToken;
00369                 }
00370             else {
00371                 if (LA(1)==EOF_CHAR)
00372                 {
00373                     uponEOF();
00374                     _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
00375                 }
00376                 else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00377             }
00378             }
00379             if ( !_returnToken )
00380                 goto tryAgain; // found SKIP token
00381 
00382             _ttype = _returnToken->getType();
00383             _returnToken->setType(_ttype);
00384             return _returnToken;
00385         }
00386         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
00387                 throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
00388         }
00389         catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
00390             throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
00391         }
00392         catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
00393             throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
00394         }
00395 tryAgain:;
00396     }
00397 }
00398 
00399 void PascalLexer::mPLUS(bool _createToken) {
00400     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00401     _ttype = PLUS;
00402     int _saveIndex;
00403     
00404     match(static_cast<unsigned char>('+'));
00405     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00406        _token = makeToken(_ttype);
00407        _token->setText(text.substr(_begin, text.length()-_begin));
00408     }
00409     _returnToken = _token;
00410     _saveIndex=0;
00411 }
00412 
00413 void PascalLexer::mMINUS(bool _createToken) {
00414     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00415     _ttype = MINUS;
00416     int _saveIndex;
00417     
00418     match(static_cast<unsigned char>('-'));
00419     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00420        _token = makeToken(_ttype);
00421        _token->setText(text.substr(_begin, text.length()-_begin));
00422     }
00423     _returnToken = _token;
00424     _saveIndex=0;
00425 }
00426 
00427 void PascalLexer::mSTAR(bool _createToken) {
00428     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00429     _ttype = STAR;
00430     int _saveIndex;
00431     
00432     match(static_cast<unsigned char>('*'));
00433     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00434        _token = makeToken(_ttype);
00435        _token->setText(text.substr(_begin, text.length()-_begin));
00436     }
00437     _returnToken = _token;
00438     _saveIndex=0;
00439 }
00440 
00441 void PascalLexer::mSLASH(bool _createToken) {
00442     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00443     _ttype = SLASH;
00444     int _saveIndex;
00445     
00446     match(static_cast<unsigned char>('/'));
00447     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00448        _token = makeToken(_ttype);
00449        _token->setText(text.substr(_begin, text.length()-_begin));
00450     }
00451     _returnToken = _token;
00452     _saveIndex=0;
00453 }
00454 
00455 void PascalLexer::mASSIGN(bool _createToken) {
00456     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00457     _ttype = ASSIGN;
00458     int _saveIndex;
00459     
00460     match(":=");
00461     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00462        _token = makeToken(_ttype);
00463        _token->setText(text.substr(_begin, text.length()-_begin));
00464     }
00465     _returnToken = _token;
00466     _saveIndex=0;
00467 }
00468 
00469 void PascalLexer::mCOMMA(bool _createToken) {
00470     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00471     _ttype = COMMA;
00472     int _saveIndex;
00473     
00474     match(static_cast<unsigned char>(','));
00475     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00476        _token = makeToken(_ttype);
00477        _token->setText(text.substr(_begin, text.length()-_begin));
00478     }
00479     _returnToken = _token;
00480     _saveIndex=0;
00481 }
00482 
00483 void PascalLexer::mSEMI(bool _createToken) {
00484     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00485     _ttype = SEMI;
00486     int _saveIndex;
00487     
00488     match(static_cast<unsigned char>(';'));
00489     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00490        _token = makeToken(_ttype);
00491        _token->setText(text.substr(_begin, text.length()-_begin));
00492     }
00493     _returnToken = _token;
00494     _saveIndex=0;
00495 }
00496 
00497 void PascalLexer::mCOLON(bool _createToken) {
00498     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00499     _ttype = COLON;
00500     int _saveIndex;
00501     
00502     match(static_cast<unsigned char>(':'));
00503     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00504        _token = makeToken(_ttype);
00505        _token->setText(text.substr(_begin, text.length()-_begin));
00506     }
00507     _returnToken = _token;
00508     _saveIndex=0;
00509 }
00510 
00511 void PascalLexer::mEQUAL(bool _createToken) {
00512     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00513     _ttype = EQUAL;
00514     int _saveIndex;
00515     
00516     match(static_cast<unsigned char>('='));
00517     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00518        _token = makeToken(_ttype);
00519        _token->setText(text.substr(_begin, text.length()-_begin));
00520     }
00521     _returnToken = _token;
00522     _saveIndex=0;
00523 }
00524 
00525 void PascalLexer::mNOT_EQUAL(bool _createToken) {
00526     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00527     _ttype = NOT_EQUAL;
00528     int _saveIndex;
00529     
00530     match("<>");
00531     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00532        _token = makeToken(_ttype);
00533        _token->setText(text.substr(_begin, text.length()-_begin));
00534     }
00535     _returnToken = _token;
00536     _saveIndex=0;
00537 }
00538 
00539 void PascalLexer::mLTH(bool _createToken) {
00540     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00541     _ttype = LTH;
00542     int _saveIndex;
00543     
00544     match(static_cast<unsigned char>('<'));
00545     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00546        _token = makeToken(_ttype);
00547        _token->setText(text.substr(_begin, text.length()-_begin));
00548     }
00549     _returnToken = _token;
00550     _saveIndex=0;
00551 }
00552 
00553 void PascalLexer::mLE(bool _createToken) {
00554     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00555     _ttype = LE;
00556     int _saveIndex;
00557     
00558     match("<=");
00559     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00560        _token = makeToken(_ttype);
00561        _token->setText(text.substr(_begin, text.length()-_begin));
00562     }
00563     _returnToken = _token;
00564     _saveIndex=0;
00565 }
00566 
00567 void PascalLexer::mGE(bool _createToken) {
00568     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00569     _ttype = GE;
00570     int _saveIndex;
00571     
00572     match(">=");
00573     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00574        _token = makeToken(_ttype);
00575        _token->setText(text.substr(_begin, text.length()-_begin));
00576     }
00577     _returnToken = _token;
00578     _saveIndex=0;
00579 }
00580 
00581 void PascalLexer::mGT(bool _createToken) {
00582     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00583     _ttype = GT;
00584     int _saveIndex;
00585     
00586     match(static_cast<unsigned char>('>'));
00587     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00588        _token = makeToken(_ttype);
00589        _token->setText(text.substr(_begin, text.length()-_begin));
00590     }
00591     _returnToken = _token;
00592     _saveIndex=0;
00593 }
00594 
00595 void PascalLexer::mLPAREN(bool _createToken) {
00596     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00597     _ttype = LPAREN;
00598     int _saveIndex;
00599     
00600     match(static_cast<unsigned char>('('));
00601     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00602        _token = makeToken(_ttype);
00603        _token->setText(text.substr(_begin, text.length()-_begin));
00604     }
00605     _returnToken = _token;
00606     _saveIndex=0;
00607 }
00608 
00609 void PascalLexer::mRPAREN(bool _createToken) {
00610     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00611     _ttype = RPAREN;
00612     int _saveIndex;
00613     
00614     match(static_cast<unsigned char>(')'));
00615     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00616        _token = makeToken(_ttype);
00617        _token->setText(text.substr(_begin, text.length()-_begin));
00618     }
00619     _returnToken = _token;
00620     _saveIndex=0;
00621 }
00622 
00623 void PascalLexer::mLBRACK(bool _createToken) {
00624     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00625     _ttype = LBRACK;
00626     int _saveIndex;
00627     
00628     match(static_cast<unsigned char>('['));
00629     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00630        _token = makeToken(_ttype);
00631        _token->setText(text.substr(_begin, text.length()-_begin));
00632     }
00633     _returnToken = _token;
00634     _saveIndex=0;
00635 }
00636 
00637 void PascalLexer::mLBRACK2(bool _createToken) {
00638     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00639     _ttype = LBRACK2;
00640     int _saveIndex;
00641     
00642     match("(.");
00643     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00644        _token = makeToken(_ttype);
00645        _token->setText(text.substr(_begin, text.length()-_begin));
00646     }
00647     _returnToken = _token;
00648     _saveIndex=0;
00649 }
00650 
00651 void PascalLexer::mRBRACK(bool _createToken) {
00652     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00653     _ttype = RBRACK;
00654     int _saveIndex;
00655     
00656     match(static_cast<unsigned char>(']'));
00657     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00658        _token = makeToken(_ttype);
00659        _token->setText(text.substr(_begin, text.length()-_begin));
00660     }
00661     _returnToken = _token;
00662     _saveIndex=0;
00663 }
00664 
00665 void PascalLexer::mRBRACK2(bool _createToken) {
00666     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00667     _ttype = RBRACK2;
00668     int _saveIndex;
00669     
00670     match(".)");
00671     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00672        _token = makeToken(_ttype);
00673        _token->setText(text.substr(_begin, text.length()-_begin));
00674     }
00675     _returnToken = _token;
00676     _saveIndex=0;
00677 }
00678 
00679 void PascalLexer::mPOINTER(bool _createToken) {
00680     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00681     _ttype = POINTER;
00682     int _saveIndex;
00683     
00684     match(static_cast<unsigned char>('^'));
00685     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00686        _token = makeToken(_ttype);
00687        _token->setText(text.substr(_begin, text.length()-_begin));
00688     }
00689     _returnToken = _token;
00690     _saveIndex=0;
00691 }
00692 
00693 void PascalLexer::mAT(bool _createToken) {
00694     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00695     _ttype = AT;
00696     int _saveIndex;
00697     
00698     match(static_cast<unsigned char>('@'));
00699     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00700        _token = makeToken(_ttype);
00701        _token->setText(text.substr(_begin, text.length()-_begin));
00702     }
00703     _returnToken = _token;
00704     _saveIndex=0;
00705 }
00706 
00707 void PascalLexer::mDOT(bool _createToken) {
00708     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00709     _ttype = DOT;
00710     int _saveIndex;
00711     
00712     match(static_cast<unsigned char>('.'));
00713     {
00714     if ((LA(1) == static_cast<unsigned char>('.'))) {
00715         match(static_cast<unsigned char>('.'));
00716 #line 1124 "pascal.g"
00717         _ttype = DOTDOT;
00718 #line 719 "PascalLexer.cpp"
00719     }
00720     else {
00721     }
00722     
00723     }
00724     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00725        _token = makeToken(_ttype);
00726        _token->setText(text.substr(_begin, text.length()-_begin));
00727     }
00728     _returnToken = _token;
00729     _saveIndex=0;
00730 }
00731 
00732 void PascalLexer::mLCURLY(bool _createToken) {
00733     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00734     _ttype = LCURLY;
00735     int _saveIndex;
00736     
00737     match("{");
00738     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00739        _token = makeToken(_ttype);
00740        _token->setText(text.substr(_begin, text.length()-_begin));
00741     }
00742     _returnToken = _token;
00743     _saveIndex=0;
00744 }
00745 
00746 void PascalLexer::mRCURLY(bool _createToken) {
00747     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00748     _ttype = RCURLY;
00749     int _saveIndex;
00750     
00751     match("}");
00752     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00753        _token = makeToken(_ttype);
00754        _token->setText(text.substr(_begin, text.length()-_begin));
00755     }
00756     _returnToken = _token;
00757     _saveIndex=0;
00758 }
00759 
00760 void PascalLexer::mPLUSEQ(bool _createToken) {
00761     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00762     _ttype = PLUSEQ;
00763     int _saveIndex;
00764     
00765     match("+=");
00766     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00767        _token = makeToken(_ttype);
00768        _token->setText(text.substr(_begin, text.length()-_begin));
00769     }
00770     _returnToken = _token;
00771     _saveIndex=0;
00772 }
00773 
00774 void PascalLexer::mMINUSEQ(bool _createToken) {
00775     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00776     _ttype = MINUSEQ;
00777     int _saveIndex;
00778     
00779     match("-=");
00780     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00781        _token = makeToken(_ttype);
00782        _token->setText(text.substr(_begin, text.length()-_begin));
00783     }
00784     _returnToken = _token;
00785     _saveIndex=0;
00786 }
00787 
00788 void PascalLexer::mSTAREQ(bool _createToken) {
00789     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00790     _ttype = STAREQ;
00791     int _saveIndex;
00792     
00793     match("*=");
00794     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00795        _token = makeToken(_ttype);
00796        _token->setText(text.substr(_begin, text.length()-_begin));
00797     }
00798     _returnToken = _token;
00799     _saveIndex=0;
00800 }
00801 
00802 void PascalLexer::mSLASHQE(bool _createToken) {
00803     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00804     _ttype = SLASHQE;
00805     int _saveIndex;
00806     
00807     match("/=");
00808     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00809        _token = makeToken(_ttype);
00810        _token->setText(text.substr(_begin, text.length()-_begin));
00811     }
00812     _returnToken = _token;
00813     _saveIndex=0;
00814 }
00815 
00816 void PascalLexer::mWS(bool _createToken) {
00817     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00818     _ttype = WS;
00819     int _saveIndex;
00820     
00821     {
00822     switch ( LA(1)) {
00823     case static_cast<unsigned char>(' '):
00824     {
00825         match(static_cast<unsigned char>(' '));
00826         break;
00827     }
00828     case static_cast<unsigned char>('\t'):
00829     {
00830         match(static_cast<unsigned char>('\t'));
00831         break;
00832     }
00833     case static_cast<unsigned char>('\14'):
00834     {
00835         match(static_cast<unsigned char>('\14'));
00836         break;
00837     }
00838     case static_cast<unsigned char>('\n'):
00839     case static_cast<unsigned char>('\r'):
00840     {
00841         {
00842         if ((LA(1) == static_cast<unsigned char>('\r')) && (LA(2) == static_cast<unsigned char>('\n'))) {
00843             match("\r\n");
00844         }
00845         else if ((LA(1) == static_cast<unsigned char>('\r')) && (true)) {
00846             match(static_cast<unsigned char>('\r'));
00847         }
00848         else if ((LA(1) == static_cast<unsigned char>('\n'))) {
00849             match(static_cast<unsigned char>('\n'));
00850         }
00851         else {
00852             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00853         }
00854         
00855         }
00856 #line 1142 "pascal.g"
00857         newline();
00858 #line 859 "PascalLexer.cpp"
00859         break;
00860     }
00861     default:
00862     {
00863         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00864     }
00865     }
00866     }
00867 #line 1144 "pascal.g"
00868     _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00869 #line 870 "PascalLexer.cpp"
00870     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00871        _token = makeToken(_ttype);
00872        _token->setText(text.substr(_begin, text.length()-_begin));
00873     }
00874     _returnToken = _token;
00875     _saveIndex=0;
00876 }
00877 
00878 void PascalLexer::mCOMMENT_1(bool _createToken) {
00879     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00880     _ttype = COMMENT_1;
00881     int _saveIndex;
00882     
00883     match("(*");
00884     { // ( ... )*
00885     for (;;) {
00886         if ((LA(1) == static_cast<unsigned char>('\r')) && (LA(2) == static_cast<unsigned char>('\n')) && ((LA(3) >= static_cast<unsigned char>('\0') && LA(3) <= static_cast<unsigned char>('\377'))) && ((LA(4) >= static_cast<unsigned char>('\0') && LA(4) <= static_cast<unsigned char>('\377')))) {
00887             match(static_cast<unsigned char>('\r'));
00888             match(static_cast<unsigned char>('\n'));
00889 #line 1152 "pascal.g"
00890             newline();
00891 #line 892 "PascalLexer.cpp"
00892         }
00893         else if (((LA(1) == static_cast<unsigned char>('*')) && ((LA(2) >= static_cast<unsigned char>('\0') && LA(2) <= static_cast<unsigned char>('\377'))) && ((LA(3) >= static_cast<unsigned char>('\0') && LA(3) <= static_cast<unsigned char>('\377'))))&&( LA(2) != ')' )) {
00894             match(static_cast<unsigned char>('*'));
00895         }
00896         else if ((LA(1) == static_cast<unsigned char>('\r')) && ((LA(2) >= static_cast<unsigned char>('\0') && LA(2) <= static_cast<unsigned char>('\377'))) && ((LA(3) >= static_cast<unsigned char>('\0') && LA(3) <= static_cast<unsigned char>('\377'))) && (true)) {
00897             match(static_cast<unsigned char>('\r'));
00898 #line 1153 "pascal.g"
00899             newline();
00900 #line 901 "PascalLexer.cpp"
00901         }
00902         else if ((LA(1) == static_cast<unsigned char>('\n'))) {
00903             match(static_cast<unsigned char>('\n'));
00904 #line 1154 "pascal.g"
00905             newline();
00906 #line 907 "PascalLexer.cpp"
00907         }
00908         else if ((_tokenSet_0.member(LA(1)))) {
00909             {
00910             match(_tokenSet_0);
00911             }
00912         }
00913         else {
00914             goto _loop427;
00915         }
00916         
00917     }
00918     _loop427:;
00919     } // ( ... )*
00920     match("*)");
00921 #line 1158 "pascal.g"
00922     _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00923 #line 924 "PascalLexer.cpp"
00924     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00925        _token = makeToken(_ttype);
00926        _token->setText(text.substr(_begin, text.length()-_begin));
00927     }
00928     _returnToken = _token;
00929     _saveIndex=0;
00930 }
00931 
00932 void PascalLexer::mCOMMENT_2(bool _createToken) {
00933     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00934     _ttype = COMMENT_2;
00935     int _saveIndex;
00936     
00937     match(static_cast<unsigned char>('{'));
00938     { // ( ... )*
00939     for (;;) {
00940         if ((LA(1) == static_cast<unsigned char>('\r')) && (LA(2) == static_cast<unsigned char>('\n')) && ((LA(3) >= static_cast<unsigned char>('\0') && LA(3) <= static_cast<unsigned char>('\377'))) && (true)) {
00941             match(static_cast<unsigned char>('\r'));
00942             match(static_cast<unsigned char>('\n'));
00943 #line 1164 "pascal.g"
00944             newline();
00945 #line 946 "PascalLexer.cpp"
00946         }
00947         else if ((LA(1) == static_cast<unsigned char>('\r')) && ((LA(2) >= static_cast<unsigned char>('\0') && LA(2) <= static_cast<unsigned char>('\377'))) && (true) && (true)) {
00948             match(static_cast<unsigned char>('\r'));
00949 #line 1165 "pascal.g"
00950             newline();
00951 #line 952 "PascalLexer.cpp"
00952         }
00953         else if ((LA(1) == static_cast<unsigned char>('\n'))) {
00954             match(static_cast<unsigned char>('\n'));
00955 #line 1166 "pascal.g"
00956             newline();
00957 #line 958 "PascalLexer.cpp"
00958         }
00959         else if ((_tokenSet_1.member(LA(1)))) {
00960             {
00961             match(_tokenSet_1);
00962             }
00963         }
00964         else {
00965             goto _loop431;
00966         }
00967         
00968     }
00969     _loop431:;
00970     } // ( ... )*
00971     match(static_cast<unsigned char>('}'));
00972 #line 1170 "pascal.g"
00973     _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
00974 #line 975 "PascalLexer.cpp"
00975     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00976        _token = makeToken(_ttype);
00977        _token->setText(text.substr(_begin, text.length()-_begin));
00978     }
00979     _returnToken = _token;
00980     _saveIndex=0;
00981 }
00982 
00983 void PascalLexer::mCOMMENT_3(bool _createToken) {
00984     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00985     _ttype = COMMENT_3;
00986     int _saveIndex;
00987     
00988     match("//");
00989     { // ( ... )*
00990     for (;;) {
00991         if ((_tokenSet_2.member(LA(1)))) {
00992             matchNot(static_cast<unsigned char>('\n'));
00993         }
00994         else {
00995             goto _loop434;
00996         }
00997         
00998     }
00999     _loop434:;
01000     } // ( ... )*
01001     match(static_cast<unsigned char>('\n'));
01002 #line 1175 "pascal.g"
01003     _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
01004 #line 1005 "PascalLexer.cpp"
01005     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01006        _token = makeToken(_ttype);
01007        _token->setText(text.substr(_begin, text.length()-_begin));
01008     }
01009     _returnToken = _token;
01010     _saveIndex=0;
01011 }
01012 
01013 void PascalLexer::mIDENT(bool _createToken) {
01014     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01015     _ttype = IDENT;
01016     int _saveIndex;
01017     
01018     {
01019     matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
01020     }
01021     { // ( ... )*
01022     for (;;) {
01023         switch ( LA(1)) {
01024         case static_cast<unsigned char>('a'):
01025         case static_cast<unsigned char>('b'):
01026         case static_cast<unsigned char>('c'):
01027         case static_cast<unsigned char>('d'):
01028         case static_cast<unsigned char>('e'):
01029         case static_cast<unsigned char>('f'):
01030         case static_cast<unsigned char>('g'):
01031         case static_cast<unsigned char>('h'):
01032         case static_cast<unsigned char>('i'):
01033         case static_cast<unsigned char>('j'):
01034         case static_cast<unsigned char>('k'):
01035         case static_cast<unsigned char>('l'):
01036         case static_cast<unsigned char>('m'):
01037         case static_cast<unsigned char>('n'):
01038         case static_cast<unsigned char>('o'):
01039         case static_cast<unsigned char>('p'):
01040         case static_cast<unsigned char>('q'):
01041         case static_cast<unsigned char>('r'):
01042         case static_cast<unsigned char>('s'):
01043         case static_cast<unsigned char>('t'):
01044         case static_cast<unsigned char>('u'):
01045         case static_cast<unsigned char>('v'):
01046         case static_cast<unsigned char>('w'):
01047         case static_cast<unsigned char>('x'):
01048         case static_cast<unsigned char>('y'):
01049         case static_cast<unsigned char>('z'):
01050         {
01051             matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
01052             break;
01053         }
01054         case static_cast<unsigned char>('0'):
01055         case static_cast<unsigned char>('1'):
01056         case static_cast<unsigned char>('2'):
01057         case static_cast<unsigned char>('3'):
01058         case static_cast<unsigned char>('4'):
01059         case static_cast<unsigned char>('5'):
01060         case static_cast<unsigned char>('6'):
01061         case static_cast<unsigned char>('7'):
01062         case static_cast<unsigned char>('8'):
01063         case static_cast<unsigned char>('9'):
01064         {
01065             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01066             break;
01067         }
01068         case static_cast<unsigned char>('_'):
01069         {
01070             match(static_cast<unsigned char>('_'));
01071             break;
01072         }
01073         default:
01074         {
01075             goto _loop438;
01076         }
01077         }
01078     }
01079     _loop438:;
01080     } // ( ... )*
01081     _ttype = testLiteralsTable(_ttype);
01082     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01083        _token = makeToken(_ttype);
01084        _token->setText(text.substr(_begin, text.length()-_begin));
01085     }
01086     _returnToken = _token;
01087     _saveIndex=0;
01088 }
01089 
01090 void PascalLexer::mSTRING_LITERAL(bool _createToken) {
01091     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01092     _ttype = STRING_LITERAL;
01093     int _saveIndex;
01094     
01095     match(static_cast<unsigned char>('\''));
01096     { // ( ... )*
01097     for (;;) {
01098         if ((LA(1) == static_cast<unsigned char>('\'')) && (LA(2) == static_cast<unsigned char>('\''))) {
01099             match("\'\'");
01100         }
01101         else if ((_tokenSet_3.member(LA(1)))) {
01102             {
01103             match(_tokenSet_3);
01104             }
01105         }
01106         else {
01107             goto _loop442;
01108         }
01109         
01110     }
01111     _loop442:;
01112     } // ( ... )*
01113     match(static_cast<unsigned char>('\''));
01114     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01115        _token = makeToken(_ttype);
01116        _token->setText(text.substr(_begin, text.length()-_begin));
01117     }
01118     _returnToken = _token;
01119     _saveIndex=0;
01120 }
01121 
01128 void PascalLexer::mNUM_INT(bool _createToken) {
01129     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01130     _ttype = NUM_INT;
01131     int _saveIndex;
01132     
01133     { // ( ... )+
01134     int _cnt445=0;
01135     for (;;) {
01136         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01137             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01138         }
01139         else {
01140             if ( _cnt445>=1 ) { goto _loop445; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01141         }
01142         
01143         _cnt445++;
01144     }
01145     _loop445:;
01146     }  // ( ... )+
01147     {
01148     if ((LA(1) == static_cast<unsigned char>('e'))) {
01149         mEXPONENT(false);
01150 #line 1204 "pascal.g"
01151         _ttype = NUM_REAL;
01152 #line 1153 "PascalLexer.cpp"
01153     }
01154     else {
01155         {
01156         if (((LA(1) == static_cast<unsigned char>('.')))&&((LA(2)!='.')&&(LA(2)!=')'))) {
01157             match(static_cast<unsigned char>('.'));
01158 #line 1201 "pascal.g"
01159             _ttype = NUM_REAL;
01160 #line 1161 "PascalLexer.cpp"
01161             { // ( ... )+
01162             int _cnt449=0;
01163             for (;;) {
01164                 if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01165                     matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01166                 }
01167                 else {
01168                     if ( _cnt449>=1 ) { goto _loop449; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01169                 }
01170                 
01171                 _cnt449++;
01172             }
01173             _loop449:;
01174             }  // ( ... )+
01175             {
01176             if ((LA(1) == static_cast<unsigned char>('e'))) {
01177                 mEXPONENT(false);
01178             }
01179             else {
01180             }
01181             
01182             }
01183         }
01184         else {
01185         }
01186         
01187         }
01188     }
01189     
01190     }
01191     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01192        _token = makeToken(_ttype);
01193        _token->setText(text.substr(_begin, text.length()-_begin));
01194     }
01195     _returnToken = _token;
01196     _saveIndex=0;
01197 }
01198 
01199 void PascalLexer::mEXPONENT(bool _createToken) {
01200     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01201     _ttype = EXPONENT;
01202     int _saveIndex;
01203     
01204     {
01205     match(static_cast<unsigned char>('e'));
01206     }
01207     {
01208     switch ( LA(1)) {
01209     case static_cast<unsigned char>('+'):
01210     {
01211         match(static_cast<unsigned char>('+'));
01212         break;
01213     }
01214     case static_cast<unsigned char>('-'):
01215     {
01216         match(static_cast<unsigned char>('-'));
01217         break;
01218     }
01219     case static_cast<unsigned char>('0'):
01220     case static_cast<unsigned char>('1'):
01221     case static_cast<unsigned char>('2'):
01222     case static_cast<unsigned char>('3'):
01223     case static_cast<unsigned char>('4'):
01224     case static_cast<unsigned char>('5'):
01225     case static_cast<unsigned char>('6'):
01226     case static_cast<unsigned char>('7'):
01227     case static_cast<unsigned char>('8'):
01228     case static_cast<unsigned char>('9'):
01229     {
01230         break;
01231     }
01232     default:
01233     {
01234         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01235     }
01236     }
01237     }
01238     { // ( ... )+
01239     int _cnt455=0;
01240     for (;;) {
01241         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01242             matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01243         }
01244         else {
01245             if ( _cnt455>=1 ) { goto _loop455; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01246         }
01247         
01248         _cnt455++;
01249     }
01250     _loop455:;
01251     }  // ( ... )+
01252     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01253        _token = makeToken(_ttype);
01254        _token->setText(text.substr(_begin, text.length()-_begin));
01255     }
01256     _returnToken = _token;
01257     _saveIndex=0;
01258 }
01259 
01260 
01261 const unsigned long PascalLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01262 // null EOF null NULL_TREE_LOOKAHEAD BLOCK IDLIST ELIST FUNC_CALL PROC_CALL 
01263 // SCALARTYPE VARIANT_TAG VARIANT_TAG_NO_ID CONSTLIST FIELDLIST ARGDECLS 
01264 // VARDECL ARGDECL ARGLIST TYPEDECL FIELD DOT "library" SEMI "end" "exports" 
01265 // COMMA "index" "name" "uses" "unit" "interface" "implementation" "begin" 
01266 // "program" LPAREN RPAREN "initialization" "finalization" "label" "const" 
01267 // EQUAL "type" "var" COLON "procedure" "forward" "function" "array" "of" 
01268 // "external" "public" "alias" INTERRUPT "export" "register" "pascal" "cdecl" 
01269 // "stdcall" "popstack" "saveregisters" "inline" "safecall" "near" "far" 
01270 // NUM_INT "integer" "shortint" "smallint" "longint" "int64" "byte" "word" 
01271 // "cardinal" "qword" "boolean" BYTEBOOL LONGBOOL "char" DOTDOT ASSIGN 
01272 // "real" "single" "double" "extended" "comp" "string" LBRACK RBRACK "packed" 
01273 // "record" "case" "set" "file" POINTER "object" "virtual" "abstract" "private" 
01274 // "protected" "constructor" "destructor" "class" "override" MESSAGE "published" 
01275 // "property" "read" "write" "default" "nodefault" LE GE LTH GT NOT_EQUAL 
01276 // "in" "is" PLUS MINUS "or" "xor" STAR SLASH "div" "mod" "and" "shl" "shr" 
01277 // "not" "true" "false" AT PLUSEQ MINUSEQ STAREQ SLASHQE "goto" "if" "then" 
01278 // "else" "while" "do" "repeat" "until" "for" "to" "downto" "with" LBRACK2 
01279 // RBRACK2 "operator" "raise" "try" "except" "finally" "on" STRING_LITERAL 
01280 // "chr" "nil" NUM_REAL IDENT "absolute" "as" "asm" "assembler" "break" 
01281 // "continue" "dispose" "exit" "inherited" "new" "self" METHOD ADDSUBOR 
01282 // ASSIGNEQUAL SIGN FUNC NODE_NOT_EMIT MYASTVAR LF LCURLY RCURLY WS COMMENT_1 
01283 // COMMENT_2 COMMENT_3 EXPONENT 
01284 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_0(_tokenSet_0_data_,16);
01285 const unsigned long PascalLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 3758096383UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01286 // null EOF null NULL_TREE_LOOKAHEAD BLOCK IDLIST ELIST FUNC_CALL PROC_CALL 
01287 // SCALARTYPE VARIANT_TAG VARIANT_TAG_NO_ID CONSTLIST FIELDLIST ARGDECLS 
01288 // VARDECL ARGDECL ARGLIST TYPEDECL FIELD DOT "library" SEMI "end" "exports" 
01289 // COMMA "index" "name" "uses" "unit" "interface" "implementation" "begin" 
01290 // "program" LPAREN RPAREN "initialization" "finalization" "label" "const" 
01291 // "resourcestring" EQUAL "type" "var" COLON "procedure" "forward" "function" 
01292 // "array" "of" "external" "public" "alias" INTERRUPT "export" "register" 
01293 // "pascal" "cdecl" "stdcall" "popstack" "saveregisters" "inline" "safecall" 
01294 // "near" "far" NUM_INT "integer" "shortint" "smallint" "longint" "int64" 
01295 // "byte" "word" "cardinal" "qword" "boolean" BYTEBOOL LONGBOOL "char" 
01296 // DOTDOT ASSIGN "real" "single" "double" "extended" "comp" "string" LBRACK 
01297 // RBRACK "packed" "record" "case" "set" "file" POINTER "object" "virtual" 
01298 // "abstract" "private" "protected" "constructor" "destructor" "class" 
01299 // "override" MESSAGE "published" "property" "read" "write" "default" "nodefault" 
01300 // LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR "div" "mod" 
01301 // "and" "shl" "shr" "not" "true" "false" AT PLUSEQ MINUSEQ STAREQ SLASHQE 
01302 // "goto" "if" "then" "else" "while" "do" "repeat" "until" "for" "to" "downto" 
01303 // "with" LBRACK2 RBRACK2 "operator" "raise" "try" "except" "finally" "on" 
01304 // STRING_LITERAL "chr" "nil" NUM_REAL IDENT "absolute" "as" "asm" "assembler" 
01305 // "break" "continue" "dispose" "exit" "inherited" "new" "self" METHOD 
01306 // ADDSUBOR ASSIGNEQUAL SIGN FUNC NODE_NOT_EMIT MYASTVAR LF LCURLY RCURLY 
01307 // WS COMMENT_1 COMMENT_2 COMMENT_3 EXPONENT 
01308 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_1(_tokenSet_1_data_,16);
01309 const unsigned long PascalLexer::_tokenSet_2_data_[] = { 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01310 // null EOF null NULL_TREE_LOOKAHEAD BLOCK IDLIST ELIST FUNC_CALL PROC_CALL 
01311 // SCALARTYPE VARIANT_TAG VARIANT_TAG_NO_ID VARIANT_CASE CONSTLIST FIELDLIST 
01312 // ARGDECLS VARDECL ARGDECL ARGLIST TYPEDECL FIELD DOT "library" SEMI "end" 
01313 // "exports" COMMA "index" "name" "uses" "unit" "interface" "implementation" 
01314 // "begin" "program" LPAREN RPAREN "initialization" "finalization" "label" 
01315 // "const" "resourcestring" EQUAL "type" "var" COLON "procedure" "forward" 
01316 // "function" "array" "of" "external" "public" "alias" INTERRUPT "export" 
01317 // "register" "pascal" "cdecl" "stdcall" "popstack" "saveregisters" "inline" 
01318 // "safecall" "near" "far" NUM_INT "integer" "shortint" "smallint" "longint" 
01319 // "int64" "byte" "word" "cardinal" "qword" "boolean" BYTEBOOL LONGBOOL 
01320 // "char" DOTDOT ASSIGN "real" "single" "double" "extended" "comp" "string" 
01321 // LBRACK RBRACK "packed" "record" "case" "set" "file" POINTER "object" 
01322 // "virtual" "abstract" "private" "protected" "constructor" "destructor" 
01323 // "class" "override" MESSAGE "published" "property" "read" "write" "default" 
01324 // "nodefault" LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR 
01325 // SLASH "div" "mod" "and" "shl" "shr" "not" "true" "false" AT PLUSEQ MINUSEQ 
01326 // STAREQ SLASHQE "goto" "if" "then" "else" "while" "do" "repeat" "until" 
01327 // "for" "to" "downto" "with" LBRACK2 RBRACK2 "operator" "raise" "try" 
01328 // "except" "finally" "on" STRING_LITERAL "chr" "nil" NUM_REAL IDENT "absolute" 
01329 // "as" "asm" "assembler" "break" "continue" "dispose" "exit" "inherited" 
01330 // "new" "self" METHOD ADDSUBOR ASSIGNEQUAL SIGN FUNC NODE_NOT_EMIT MYASTVAR 
01331 // LF LCURLY RCURLY WS COMMENT_1 COMMENT_2 COMMENT_3 EXPONENT 
01332 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_2(_tokenSet_2_data_,16);
01333 const unsigned long PascalLexer::_tokenSet_3_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01334 // null EOF null NULL_TREE_LOOKAHEAD BLOCK IDLIST ELIST FUNC_CALL PROC_CALL 
01335 // SCALARTYPE TYPELIST VARIANT_TAG VARIANT_TAG_NO_ID VARIANT_CASE CONSTLIST 
01336 // FIELDLIST ARGDECLS VARDECL ARGDECL ARGLIST TYPEDECL FIELD DOT "library" 
01337 // SEMI "end" "exports" COMMA "index" "name" "uses" "unit" "interface" 
01338 // "implementation" "begin" "program" LPAREN RPAREN "initialization" "label" 
01339 // "const" "resourcestring" EQUAL "type" "var" COLON "procedure" "forward" 
01340 // "function" "array" "of" "external" "public" "alias" INTERRUPT "export" 
01341 // "register" "pascal" "cdecl" "stdcall" "popstack" "saveregisters" "inline" 
01342 // "safecall" "near" "far" NUM_INT "integer" "shortint" "smallint" "longint" 
01343 // "int64" "byte" "word" "cardinal" "qword" "boolean" BYTEBOOL LONGBOOL 
01344 // "char" DOTDOT ASSIGN "real" "single" "double" "extended" "comp" "string" 
01345 // LBRACK RBRACK "packed" "record" "case" "set" "file" POINTER "object" 
01346 // "virtual" "abstract" "private" "protected" "constructor" "destructor" 
01347 // "class" "override" MESSAGE "published" "property" "read" "write" "default" 
01348 // "nodefault" LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR 
01349 // SLASH "div" "mod" "and" "shl" "shr" "not" "true" "false" AT PLUSEQ MINUSEQ 
01350 // STAREQ SLASHQE "goto" "if" "then" "else" "while" "do" "repeat" "until" 
01351 // "for" "to" "downto" "with" LBRACK2 RBRACK2 "operator" "raise" "try" 
01352 // "except" "finally" "on" STRING_LITERAL "chr" "nil" NUM_REAL IDENT "absolute" 
01353 // "as" "asm" "assembler" "break" "continue" "dispose" "exit" "inherited" 
01354 // "new" "self" METHOD ADDSUBOR ASSIGNEQUAL SIGN FUNC NODE_NOT_EMIT MYASTVAR 
01355 // LF LCURLY RCURLY WS COMMENT_1 COMMENT_2 COMMENT_3 EXPONENT 
01356 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_3(_tokenSet_3_data_,16);
01357 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Feb 22 09:22:32 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003