KDevelop API Documentation

AdaLexer.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "ada.g" -> "AdaLexer.cpp"$ */
00002 #include "AdaLexer.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 1506 "ada.g"
00012 
00013 #include "preambles.h"
00014 
00015 #line 16 "AdaLexer.cpp"
00016 AdaLexer::AdaLexer(ANTLR_USE_NAMESPACE(std)istream& in)
00017     : ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),false)
00018 {
00019     initLiterals();
00020 }
00021 
00022 AdaLexer::AdaLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
00023     : ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,false)
00024 {
00025     initLiterals();
00026 }
00027 
00028 AdaLexer::AdaLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
00029     : ANTLR_USE_NAMESPACE(antlr)CharScanner(state,false)
00030 {
00031     initLiterals();
00032 }
00033 
00034 void AdaLexer::initLiterals()
00035 {
00036     literals["until"] = 78;
00037     literals["xor"] = 86;
00038     literals["abstract"] = 40;
00039     literals["reverse"] = 71;
00040     literals["use"] = 13;
00041     literals["requeue"] = 84;
00042     literals["with"] = 11;
00043     literals["task"] = 42;
00044     literals["at"] = 49;
00045     literals["for"] = 47;
00046     literals["else"] = 68;
00047     literals["is"] = 23;
00048     literals["of"] = 55;
00049     literals["range"] = 16;
00050     literals["and"] = 85;
00051     literals["begin"] = 62;
00052     literals["procedure"] = 24;
00053     literals["separate"] = 39;
00054     literals["private"] = 20;
00055     literals["pragma"] = 4;
00056     literals["delay"] = 77;
00057     literals["abort"] = 80;
00058     literals["function"] = 25;
00059     literals["digits"] = 17;
00060     literals["declare"] = 72;
00061     literals["raise"] = 83;
00062     literals["not"] = 87;
00063     literals["record"] = 38;
00064     literals["all"] = 30;
00065     literals["in"] = 32;
00066     literals["generic"] = 61;
00067     literals["terminate"] = 82;
00068     literals["subtype"] = 51;
00069     literals["delta"] = 18;
00070     literals["when"] = 58;
00071     literals["null"] = 37;
00072     literals["entry"] = 46;
00073     literals["elsif"] = 67;
00074     literals["case"] = 57;
00075     literals["others"] = 27;
00076     literals["do"] = 76;
00077     literals["abs"] = 100;
00078     literals["constant"] = 53;
00079     literals["renames"] = 34;
00080     literals["then"] = 66;
00081     literals["exception"] = 52;
00082     literals["protected"] = 43;
00083     literals["accept"] = 75;
00084     literals["or"] = 81;
00085     literals["if"] = 65;
00086     literals["aliased"] = 56;
00087     literals["loop"] = 69;
00088     literals["return"] = 41;
00089     literals["limited"] = 60;
00090     literals["new"] = 26;
00091     literals["array"] = 54;
00092     literals["rem"] = 99;
00093     literals["end"] = 48;
00094     literals["body"] = 22;
00095     literals["mod"] = 50;
00096     literals["goto"] = 74;
00097     literals["tagged"] = 59;
00098     literals["select"] = 79;
00099     literals["while"] = 70;
00100     literals["package"] = 21;
00101     literals["type"] = 14;
00102     literals["access"] = 19;
00103     literals["out"] = 33;
00104     literals["exit"] = 73;
00105 }
00106 
00107 ANTLR_USE_NAMESPACE(antlr)RefToken AdaLexer::nextToken()
00108 {
00109     ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00110     for (;;) {
00111         ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
00112         int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
00113         resetText();
00114         try {   // for lexical and char stream error handling
00115             switch ( LA(1)) {
00116             case static_cast<unsigned char>('|'):
00117             {
00118                 mPIPE(true);
00119                 theRetToken=_returnToken;
00120                 break;
00121             }
00122             case static_cast<unsigned char>('&'):
00123             {
00124                 mCONCAT(true);
00125                 theRetToken=_returnToken;
00126                 break;
00127             }
00128             case static_cast<unsigned char>('+'):
00129             {
00130                 mPLUS(true);
00131                 theRetToken=_returnToken;
00132                 break;
00133             }
00134             case static_cast<unsigned char>('('):
00135             {
00136                 mLPAREN(true);
00137                 theRetToken=_returnToken;
00138                 break;
00139             }
00140             case static_cast<unsigned char>(')'):
00141             {
00142                 mRPAREN(true);
00143                 theRetToken=_returnToken;
00144                 break;
00145             }
00146             case static_cast<unsigned char>(','):
00147             {
00148                 mCOMMA(true);
00149                 theRetToken=_returnToken;
00150                 break;
00151             }
00152             case static_cast<unsigned char>(';'):
00153             {
00154                 mSEMI(true);
00155                 theRetToken=_returnToken;
00156                 break;
00157             }
00158             case static_cast<unsigned char>('a'):
00159             case static_cast<unsigned char>('b'):
00160             case static_cast<unsigned char>('c'):
00161             case static_cast<unsigned char>('d'):
00162             case static_cast<unsigned char>('e'):
00163             case static_cast<unsigned char>('f'):
00164             case static_cast<unsigned char>('g'):
00165             case static_cast<unsigned char>('h'):
00166             case static_cast<unsigned char>('i'):
00167             case static_cast<unsigned char>('j'):
00168             case static_cast<unsigned char>('k'):
00169             case static_cast<unsigned char>('l'):
00170             case static_cast<unsigned char>('m'):
00171             case static_cast<unsigned char>('n'):
00172             case static_cast<unsigned char>('o'):
00173             case static_cast<unsigned char>('p'):
00174             case static_cast<unsigned char>('q'):
00175             case static_cast<unsigned char>('r'):
00176             case static_cast<unsigned char>('s'):
00177             case static_cast<unsigned char>('t'):
00178             case static_cast<unsigned char>('u'):
00179             case static_cast<unsigned char>('v'):
00180             case static_cast<unsigned char>('w'):
00181             case static_cast<unsigned char>('x'):
00182             case static_cast<unsigned char>('y'):
00183             case static_cast<unsigned char>('z'):
00184             {
00185                 mIDENTIFIER(true);
00186                 theRetToken=_returnToken;
00187                 break;
00188             }
00189             case static_cast<unsigned char>('"'):
00190             {
00191                 mCHAR_STRING(true);
00192                 theRetToken=_returnToken;
00193                 break;
00194             }
00195             case static_cast<unsigned char>('0'):
00196             case static_cast<unsigned char>('1'):
00197             case static_cast<unsigned char>('2'):
00198             case static_cast<unsigned char>('3'):
00199             case static_cast<unsigned char>('4'):
00200             case static_cast<unsigned char>('5'):
00201             case static_cast<unsigned char>('6'):
00202             case static_cast<unsigned char>('7'):
00203             case static_cast<unsigned char>('8'):
00204             case static_cast<unsigned char>('9'):
00205             {
00206                 mNUMERIC_LIT(true);
00207                 theRetToken=_returnToken;
00208                 break;
00209             }
00210             case static_cast<unsigned char>('\t'):
00211             case static_cast<unsigned char>('\n'):
00212             case static_cast<unsigned char>('\14'):
00213             case static_cast<unsigned char>('\r'):
00214             case static_cast<unsigned char>(' '):
00215             {
00216                 mWS_(true);
00217                 theRetToken=_returnToken;
00218                 break;
00219             }
00220             default:
00221                 if ((LA(1) == static_cast<unsigned char>('-')) && (LA(2) == static_cast<unsigned char>('-')) && ((LA(3) >= static_cast<unsigned char>('\3') && LA(3) <= static_cast<unsigned char>('\377')))) {
00222                     mCOMMENT(true);
00223                     theRetToken=_returnToken;
00224                 }
00225                 else if ((LA(1) == static_cast<unsigned char>('-')) && (LA(2) == static_cast<unsigned char>('-')) && (true)) {
00226                     mCOMMENT_INTRO(true);
00227                     theRetToken=_returnToken;
00228                 }
00229                 else if ((LA(1) == static_cast<unsigned char>('.')) && (LA(2) == static_cast<unsigned char>('.'))) {
00230                     mDOT_DOT(true);
00231                     theRetToken=_returnToken;
00232                 }
00233                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('<'))) {
00234                     mLT_LT(true);
00235                     theRetToken=_returnToken;
00236                 }
00237                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('>'))) {
00238                     mBOX(true);
00239                     theRetToken=_returnToken;
00240                 }
00241                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('>'))) {
00242                     mGT_GT(true);
00243                     theRetToken=_returnToken;
00244                 }
00245                 else if ((LA(1) == static_cast<unsigned char>(':')) && (LA(2) == static_cast<unsigned char>('='))) {
00246                     mASSIGN(true);
00247                     theRetToken=_returnToken;
00248                 }
00249                 else if ((LA(1) == static_cast<unsigned char>('=')) && (LA(2) == static_cast<unsigned char>('>'))) {
00250                     mRIGHT_SHAFT(true);
00251                     theRetToken=_returnToken;
00252                 }
00253                 else if ((LA(1) == static_cast<unsigned char>('/')) && (LA(2) == static_cast<unsigned char>('='))) {
00254                     mNE(true);
00255                     theRetToken=_returnToken;
00256                 }
00257                 else if ((LA(1) == static_cast<unsigned char>('<')) && (LA(2) == static_cast<unsigned char>('='))) {
00258                     mLE(true);
00259                     theRetToken=_returnToken;
00260                 }
00261                 else if ((LA(1) == static_cast<unsigned char>('>')) && (LA(2) == static_cast<unsigned char>('='))) {
00262                     mGE(true);
00263                     theRetToken=_returnToken;
00264                 }
00265                 else if ((LA(1) == static_cast<unsigned char>('*')) && (LA(2) == static_cast<unsigned char>('*'))) {
00266                     mEXPON(true);
00267                     theRetToken=_returnToken;
00268                 }
00269                 else if (((LA(1) == static_cast<unsigned char>('\'')) && ((LA(2) >= static_cast<unsigned char>('\3') && LA(2) <= static_cast<unsigned char>('\377'))))&&( LA(3)=='\'' )) {
00270                     mCHARACTER_LITERAL(true);
00271                     theRetToken=_returnToken;
00272                 }
00273                 else if ((LA(1) == static_cast<unsigned char>('.')) && (true)) {
00274                     mDOT(true);
00275                     theRetToken=_returnToken;
00276                 }
00277                 else if ((LA(1) == static_cast<unsigned char>('=')) && (true)) {
00278                     mEQ(true);
00279                     theRetToken=_returnToken;
00280                 }
00281                 else if ((LA(1) == static_cast<unsigned char>('<')) && (true)) {
00282                     mLT_(true);
00283                     theRetToken=_returnToken;
00284                 }
00285                 else if ((LA(1) == static_cast<unsigned char>('>')) && (true)) {
00286                     mGT(true);
00287                     theRetToken=_returnToken;
00288                 }
00289                 else if ((LA(1) == static_cast<unsigned char>('-')) && (true)) {
00290                     mMINUS(true);
00291                     theRetToken=_returnToken;
00292                 }
00293                 else if ((LA(1) == static_cast<unsigned char>('*')) && (true)) {
00294                     mSTAR(true);
00295                     theRetToken=_returnToken;
00296                 }
00297                 else if ((LA(1) == static_cast<unsigned char>('/')) && (true)) {
00298                     mDIV(true);
00299                     theRetToken=_returnToken;
00300                 }
00301                 else if ((LA(1) == static_cast<unsigned char>(':')) && (true)) {
00302                     mCOLON(true);
00303                     theRetToken=_returnToken;
00304                 }
00305                 else if (((LA(1) == static_cast<unsigned char>('\'')) && (true))&&( LA(3)!='\'' )) {
00306                     mTIC(true);
00307                     theRetToken=_returnToken;
00308                 }
00309             else {
00310                 if (LA(1)==EOF_CHAR)
00311                 {
00312                     uponEOF();
00313                     _returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
00314                 }
00315                 else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
00316             }
00317             }
00318             if ( !_returnToken )
00319                 goto tryAgain; // found SKIP token
00320 
00321             _ttype = _returnToken->getType();
00322             _returnToken->setType(_ttype);
00323             return _returnToken;
00324         }
00325         catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
00326             {
00327                 reportError(e);
00328                 consume();
00329             }
00330         }
00331         catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
00332             throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
00333         }
00334         catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
00335             throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
00336         }
00337 tryAgain:;
00338     }
00339 }
00340 
00341 void AdaLexer::mCOMMENT_INTRO(bool _createToken) {
00342     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00343     _ttype = COMMENT_INTRO;
00344     int _saveIndex;
00345     
00346     try {      // for error handling
00347         match("--");
00348     }
00349     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00350         reportError(ex);
00351         consume();
00352         consumeUntil(_tokenSet_0);
00353     }
00354     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00355        _token = makeToken(_ttype);
00356        _token->setText(text.substr(_begin, text.length()-_begin));
00357     }
00358     _returnToken = _token;
00359     _saveIndex=0;
00360 }
00361 
00362 void AdaLexer::mDOT_DOT(bool _createToken) {
00363     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00364     _ttype = DOT_DOT;
00365     int _saveIndex;
00366     
00367     try {      // for error handling
00368         match("..");
00369     }
00370     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00371         reportError(ex);
00372         consume();
00373         consumeUntil(_tokenSet_1);
00374     }
00375     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00376        _token = makeToken(_ttype);
00377        _token->setText(text.substr(_begin, text.length()-_begin));
00378     }
00379     _returnToken = _token;
00380     _saveIndex=0;
00381 }
00382 
00383 void AdaLexer::mLT_LT(bool _createToken) {
00384     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00385     _ttype = LT_LT;
00386     int _saveIndex;
00387     
00388     try {      // for error handling
00389         match("<<");
00390     }
00391     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00392         reportError(ex);
00393         consume();
00394         consumeUntil(_tokenSet_1);
00395     }
00396     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00397        _token = makeToken(_ttype);
00398        _token->setText(text.substr(_begin, text.length()-_begin));
00399     }
00400     _returnToken = _token;
00401     _saveIndex=0;
00402 }
00403 
00404 void AdaLexer::mBOX(bool _createToken) {
00405     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00406     _ttype = BOX;
00407     int _saveIndex;
00408     
00409     try {      // for error handling
00410         match("<>");
00411     }
00412     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00413         reportError(ex);
00414         consume();
00415         consumeUntil(_tokenSet_1);
00416     }
00417     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00418        _token = makeToken(_ttype);
00419        _token->setText(text.substr(_begin, text.length()-_begin));
00420     }
00421     _returnToken = _token;
00422     _saveIndex=0;
00423 }
00424 
00425 void AdaLexer::mGT_GT(bool _createToken) {
00426     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00427     _ttype = GT_GT;
00428     int _saveIndex;
00429     
00430     try {      // for error handling
00431         match(">>");
00432     }
00433     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00434         reportError(ex);
00435         consume();
00436         consumeUntil(_tokenSet_1);
00437     }
00438     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00439        _token = makeToken(_ttype);
00440        _token->setText(text.substr(_begin, text.length()-_begin));
00441     }
00442     _returnToken = _token;
00443     _saveIndex=0;
00444 }
00445 
00446 void AdaLexer::mASSIGN(bool _createToken) {
00447     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00448     _ttype = ASSIGN;
00449     int _saveIndex;
00450     
00451     try {      // for error handling
00452         match(":=");
00453     }
00454     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00455         reportError(ex);
00456         consume();
00457         consumeUntil(_tokenSet_1);
00458     }
00459     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00460        _token = makeToken(_ttype);
00461        _token->setText(text.substr(_begin, text.length()-_begin));
00462     }
00463     _returnToken = _token;
00464     _saveIndex=0;
00465 }
00466 
00467 void AdaLexer::mRIGHT_SHAFT(bool _createToken) {
00468     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00469     _ttype = RIGHT_SHAFT;
00470     int _saveIndex;
00471     
00472     try {      // for error handling
00473         match("=>");
00474     }
00475     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00476         reportError(ex);
00477         consume();
00478         consumeUntil(_tokenSet_1);
00479     }
00480     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00481        _token = makeToken(_ttype);
00482        _token->setText(text.substr(_begin, text.length()-_begin));
00483     }
00484     _returnToken = _token;
00485     _saveIndex=0;
00486 }
00487 
00488 void AdaLexer::mNE(bool _createToken) {
00489     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00490     _ttype = NE;
00491     int _saveIndex;
00492     
00493     try {      // for error handling
00494         match("/=");
00495     }
00496     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00497         reportError(ex);
00498         consume();
00499         consumeUntil(_tokenSet_1);
00500     }
00501     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00502        _token = makeToken(_ttype);
00503        _token->setText(text.substr(_begin, text.length()-_begin));
00504     }
00505     _returnToken = _token;
00506     _saveIndex=0;
00507 }
00508 
00509 void AdaLexer::mLE(bool _createToken) {
00510     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00511     _ttype = LE;
00512     int _saveIndex;
00513     
00514     try {      // for error handling
00515         match("<=");
00516     }
00517     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00518         reportError(ex);
00519         consume();
00520         consumeUntil(_tokenSet_1);
00521     }
00522     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00523        _token = makeToken(_ttype);
00524        _token->setText(text.substr(_begin, text.length()-_begin));
00525     }
00526     _returnToken = _token;
00527     _saveIndex=0;
00528 }
00529 
00530 void AdaLexer::mGE(bool _createToken) {
00531     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00532     _ttype = GE;
00533     int _saveIndex;
00534     
00535     try {      // for error handling
00536         match(">=");
00537     }
00538     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00539         reportError(ex);
00540         consume();
00541         consumeUntil(_tokenSet_1);
00542     }
00543     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00544        _token = makeToken(_ttype);
00545        _token->setText(text.substr(_begin, text.length()-_begin));
00546     }
00547     _returnToken = _token;
00548     _saveIndex=0;
00549 }
00550 
00551 void AdaLexer::mEXPON(bool _createToken) {
00552     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00553     _ttype = EXPON;
00554     int _saveIndex;
00555     
00556     try {      // for error handling
00557         match("**");
00558     }
00559     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00560         reportError(ex);
00561         consume();
00562         consumeUntil(_tokenSet_1);
00563     }
00564     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00565        _token = makeToken(_ttype);
00566        _token->setText(text.substr(_begin, text.length()-_begin));
00567     }
00568     _returnToken = _token;
00569     _saveIndex=0;
00570 }
00571 
00572 void AdaLexer::mPIPE(bool _createToken) {
00573     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00574     _ttype = PIPE;
00575     int _saveIndex;
00576     
00577     try {      // for error handling
00578         match(static_cast<unsigned char>('|'));
00579     }
00580     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00581         reportError(ex);
00582         consume();
00583         consumeUntil(_tokenSet_1);
00584     }
00585     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00586        _token = makeToken(_ttype);
00587        _token->setText(text.substr(_begin, text.length()-_begin));
00588     }
00589     _returnToken = _token;
00590     _saveIndex=0;
00591 }
00592 
00593 void AdaLexer::mCONCAT(bool _createToken) {
00594     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00595     _ttype = CONCAT;
00596     int _saveIndex;
00597     
00598     try {      // for error handling
00599         match(static_cast<unsigned char>('&'));
00600     }
00601     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00602         reportError(ex);
00603         consume();
00604         consumeUntil(_tokenSet_1);
00605     }
00606     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00607        _token = makeToken(_ttype);
00608        _token->setText(text.substr(_begin, text.length()-_begin));
00609     }
00610     _returnToken = _token;
00611     _saveIndex=0;
00612 }
00613 
00614 void AdaLexer::mDOT(bool _createToken) {
00615     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00616     _ttype = DOT;
00617     int _saveIndex;
00618     
00619     try {      // for error handling
00620         match(static_cast<unsigned char>('.'));
00621     }
00622     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00623         reportError(ex);
00624         consume();
00625         consumeUntil(_tokenSet_1);
00626     }
00627     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00628        _token = makeToken(_ttype);
00629        _token->setText(text.substr(_begin, text.length()-_begin));
00630     }
00631     _returnToken = _token;
00632     _saveIndex=0;
00633 }
00634 
00635 void AdaLexer::mEQ(bool _createToken) {
00636     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00637     _ttype = EQ;
00638     int _saveIndex;
00639     
00640     try {      // for error handling
00641         match(static_cast<unsigned char>('='));
00642     }
00643     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00644         reportError(ex);
00645         consume();
00646         consumeUntil(_tokenSet_1);
00647     }
00648     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00649        _token = makeToken(_ttype);
00650        _token->setText(text.substr(_begin, text.length()-_begin));
00651     }
00652     _returnToken = _token;
00653     _saveIndex=0;
00654 }
00655 
00656 void AdaLexer::mLT_(bool _createToken) {
00657     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00658     _ttype = LT_;
00659     int _saveIndex;
00660     
00661     try {      // for error handling
00662         match(static_cast<unsigned char>('<'));
00663     }
00664     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00665         reportError(ex);
00666         consume();
00667         consumeUntil(_tokenSet_1);
00668     }
00669     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00670        _token = makeToken(_ttype);
00671        _token->setText(text.substr(_begin, text.length()-_begin));
00672     }
00673     _returnToken = _token;
00674     _saveIndex=0;
00675 }
00676 
00677 void AdaLexer::mGT(bool _createToken) {
00678     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00679     _ttype = GT;
00680     int _saveIndex;
00681     
00682     try {      // for error handling
00683         match(static_cast<unsigned char>('>'));
00684     }
00685     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00686         reportError(ex);
00687         consume();
00688         consumeUntil(_tokenSet_1);
00689     }
00690     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00691        _token = makeToken(_ttype);
00692        _token->setText(text.substr(_begin, text.length()-_begin));
00693     }
00694     _returnToken = _token;
00695     _saveIndex=0;
00696 }
00697 
00698 void AdaLexer::mPLUS(bool _createToken) {
00699     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00700     _ttype = PLUS;
00701     int _saveIndex;
00702     
00703     try {      // for error handling
00704         match(static_cast<unsigned char>('+'));
00705     }
00706     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00707         reportError(ex);
00708         consume();
00709         consumeUntil(_tokenSet_1);
00710     }
00711     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00712        _token = makeToken(_ttype);
00713        _token->setText(text.substr(_begin, text.length()-_begin));
00714     }
00715     _returnToken = _token;
00716     _saveIndex=0;
00717 }
00718 
00719 void AdaLexer::mMINUS(bool _createToken) {
00720     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00721     _ttype = MINUS;
00722     int _saveIndex;
00723     
00724     try {      // for error handling
00725         match(static_cast<unsigned char>('-'));
00726     }
00727     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00728         reportError(ex);
00729         consume();
00730         consumeUntil(_tokenSet_1);
00731     }
00732     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00733        _token = makeToken(_ttype);
00734        _token->setText(text.substr(_begin, text.length()-_begin));
00735     }
00736     _returnToken = _token;
00737     _saveIndex=0;
00738 }
00739 
00740 void AdaLexer::mSTAR(bool _createToken) {
00741     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00742     _ttype = STAR;
00743     int _saveIndex;
00744     
00745     try {      // for error handling
00746         match(static_cast<unsigned char>('*'));
00747     }
00748     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00749         reportError(ex);
00750         consume();
00751         consumeUntil(_tokenSet_1);
00752     }
00753     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00754        _token = makeToken(_ttype);
00755        _token->setText(text.substr(_begin, text.length()-_begin));
00756     }
00757     _returnToken = _token;
00758     _saveIndex=0;
00759 }
00760 
00761 void AdaLexer::mDIV(bool _createToken) {
00762     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00763     _ttype = DIV;
00764     int _saveIndex;
00765     
00766     try {      // for error handling
00767         match(static_cast<unsigned char>('/'));
00768     }
00769     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00770         reportError(ex);
00771         consume();
00772         consumeUntil(_tokenSet_1);
00773     }
00774     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00775        _token = makeToken(_ttype);
00776        _token->setText(text.substr(_begin, text.length()-_begin));
00777     }
00778     _returnToken = _token;
00779     _saveIndex=0;
00780 }
00781 
00782 void AdaLexer::mLPAREN(bool _createToken) {
00783     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00784     _ttype = LPAREN;
00785     int _saveIndex;
00786     
00787     try {      // for error handling
00788         match(static_cast<unsigned char>('('));
00789     }
00790     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00791         reportError(ex);
00792         consume();
00793         consumeUntil(_tokenSet_1);
00794     }
00795     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00796        _token = makeToken(_ttype);
00797        _token->setText(text.substr(_begin, text.length()-_begin));
00798     }
00799     _returnToken = _token;
00800     _saveIndex=0;
00801 }
00802 
00803 void AdaLexer::mRPAREN(bool _createToken) {
00804     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00805     _ttype = RPAREN;
00806     int _saveIndex;
00807     
00808     try {      // for error handling
00809         match(static_cast<unsigned char>(')'));
00810     }
00811     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00812         reportError(ex);
00813         consume();
00814         consumeUntil(_tokenSet_1);
00815     }
00816     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00817        _token = makeToken(_ttype);
00818        _token->setText(text.substr(_begin, text.length()-_begin));
00819     }
00820     _returnToken = _token;
00821     _saveIndex=0;
00822 }
00823 
00824 void AdaLexer::mCOLON(bool _createToken) {
00825     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00826     _ttype = COLON;
00827     int _saveIndex;
00828     
00829     try {      // for error handling
00830         match(static_cast<unsigned char>(':'));
00831     }
00832     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00833         reportError(ex);
00834         consume();
00835         consumeUntil(_tokenSet_1);
00836     }
00837     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00838        _token = makeToken(_ttype);
00839        _token->setText(text.substr(_begin, text.length()-_begin));
00840     }
00841     _returnToken = _token;
00842     _saveIndex=0;
00843 }
00844 
00845 void AdaLexer::mCOMMA(bool _createToken) {
00846     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00847     _ttype = COMMA;
00848     int _saveIndex;
00849     
00850     try {      // for error handling
00851         match(static_cast<unsigned char>(','));
00852     }
00853     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00854         reportError(ex);
00855         consume();
00856         consumeUntil(_tokenSet_1);
00857     }
00858     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00859        _token = makeToken(_ttype);
00860        _token->setText(text.substr(_begin, text.length()-_begin));
00861     }
00862     _returnToken = _token;
00863     _saveIndex=0;
00864 }
00865 
00866 void AdaLexer::mSEMI(bool _createToken) {
00867     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00868     _ttype = SEMI;
00869     int _saveIndex;
00870     
00871     try {      // for error handling
00872         match(static_cast<unsigned char>(';'));
00873     }
00874     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00875         reportError(ex);
00876         consume();
00877         consumeUntil(_tokenSet_1);
00878     }
00879     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00880        _token = makeToken(_ttype);
00881        _token->setText(text.substr(_begin, text.length()-_begin));
00882     }
00883     _returnToken = _token;
00884     _saveIndex=0;
00885 }
00886 
00887 void AdaLexer::mTIC(bool _createToken) {
00888     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00889     _ttype = TIC;
00890     int _saveIndex;
00891     
00892     try {      // for error handling
00893         if (!( LA(3)!='\'' ))
00894             throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(3)!='\\'' ");
00895         match(static_cast<unsigned char>('\''));
00896     }
00897     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00898         reportError(ex);
00899         consume();
00900         consumeUntil(_tokenSet_1);
00901     }
00902     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
00903        _token = makeToken(_ttype);
00904        _token->setText(text.substr(_begin, text.length()-_begin));
00905     }
00906     _returnToken = _token;
00907     _saveIndex=0;
00908 }
00909 
00910 void AdaLexer::mIDENTIFIER(bool _createToken) {
00911     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
00912     _ttype = IDENTIFIER;
00913     int _saveIndex;
00914     
00915     try {      // for error handling
00916         {
00917         matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
00918         }
00919         { // ( ... )*
00920         for (;;) {
00921             if ((_tokenSet_2.member(LA(1)))) {
00922                 {
00923                 switch ( LA(1)) {
00924                 case static_cast<unsigned char>('_'):
00925                 {
00926                     match(static_cast<unsigned char>('_'));
00927                     break;
00928                 }
00929                 case static_cast<unsigned char>('0'):
00930                 case static_cast<unsigned char>('1'):
00931                 case static_cast<unsigned char>('2'):
00932                 case static_cast<unsigned char>('3'):
00933                 case static_cast<unsigned char>('4'):
00934                 case static_cast<unsigned char>('5'):
00935                 case static_cast<unsigned char>('6'):
00936                 case static_cast<unsigned char>('7'):
00937                 case static_cast<unsigned char>('8'):
00938                 case static_cast<unsigned char>('9'):
00939                 case static_cast<unsigned char>('a'):
00940                 case static_cast<unsigned char>('b'):
00941                 case static_cast<unsigned char>('c'):
00942                 case static_cast<unsigned char>('d'):
00943                 case static_cast<unsigned char>('e'):
00944                 case static_cast<unsigned char>('f'):
00945                 case static_cast<unsigned char>('g'):
00946                 case static_cast<unsigned char>('h'):
00947                 case static_cast<unsigned char>('i'):
00948                 case static_cast<unsigned char>('j'):
00949                 case static_cast<unsigned char>('k'):
00950                 case static_cast<unsigned char>('l'):
00951                 case static_cast<unsigned char>('m'):
00952                 case static_cast<unsigned char>('n'):
00953                 case static_cast<unsigned char>('o'):
00954                 case static_cast<unsigned char>('p'):
00955                 case static_cast<unsigned char>('q'):
00956                 case static_cast<unsigned char>('r'):
00957                 case static_cast<unsigned char>('s'):
00958                 case static_cast<unsigned char>('t'):
00959                 case static_cast<unsigned char>('u'):
00960                 case static_cast<unsigned char>('v'):
00961                 case static_cast<unsigned char>('w'):
00962                 case static_cast<unsigned char>('x'):
00963                 case static_cast<unsigned char>('y'):
00964                 case static_cast<unsigned char>('z'):
00965                 {
00966                     break;
00967                 }
00968                 default:
00969                 {
00970                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
00971                 }
00972                 }
00973                 }
00974                 {
00975                 switch ( LA(1)) {
00976                 case static_cast<unsigned char>('a'):
00977                 case static_cast<unsigned char>('b'):
00978                 case static_cast<unsigned char>('c'):
00979                 case static_cast<unsigned char>('d'):
00980                 case static_cast<unsigned char>('e'):
00981                 case static_cast<unsigned char>('f'):
00982                 case static_cast<unsigned char>('g'):
00983                 case static_cast<unsigned char>('h'):
00984                 case static_cast<unsigned char>('i'):
00985                 case static_cast<unsigned char>('j'):
00986                 case static_cast<unsigned char>('k'):
00987                 case static_cast<unsigned char>('l'):
00988                 case static_cast<unsigned char>('m'):
00989                 case static_cast<unsigned char>('n'):
00990                 case static_cast<unsigned char>('o'):
00991                 case static_cast<unsigned char>('p'):
00992                 case static_cast<unsigned char>('q'):
00993                 case static_cast<unsigned char>('r'):
00994                 case static_cast<unsigned char>('s'):
00995                 case static_cast<unsigned char>('t'):
00996                 case static_cast<unsigned char>('u'):
00997                 case static_cast<unsigned char>('v'):
00998                 case static_cast<unsigned char>('w'):
00999                 case static_cast<unsigned char>('x'):
01000                 case static_cast<unsigned char>('y'):
01001                 case static_cast<unsigned char>('z'):
01002                 {
01003                     matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('z'));
01004                     break;
01005                 }
01006                 case static_cast<unsigned char>('0'):
01007                 case static_cast<unsigned char>('1'):
01008                 case static_cast<unsigned char>('2'):
01009                 case static_cast<unsigned char>('3'):
01010                 case static_cast<unsigned char>('4'):
01011                 case static_cast<unsigned char>('5'):
01012                 case static_cast<unsigned char>('6'):
01013                 case static_cast<unsigned char>('7'):
01014                 case static_cast<unsigned char>('8'):
01015                 case static_cast<unsigned char>('9'):
01016                 {
01017                     matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01018                     break;
01019                 }
01020                 default:
01021                 {
01022                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01023                 }
01024                 }
01025                 }
01026             }
01027             else {
01028                 goto _loop508;
01029             }
01030             
01031         }
01032         _loop508:;
01033         } // ( ... )*
01034     }
01035     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01036         reportError(ex);
01037         consume();
01038         consumeUntil(_tokenSet_1);
01039     }
01040     _ttype = testLiteralsTable(_ttype);
01041     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01042        _token = makeToken(_ttype);
01043        _token->setText(text.substr(_begin, text.length()-_begin));
01044     }
01045     _returnToken = _token;
01046     _saveIndex=0;
01047 }
01048 
01049 void AdaLexer::mCHARACTER_LITERAL(bool _createToken) {
01050     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01051     _ttype = CHARACTER_LITERAL;
01052     int _saveIndex;
01053     
01054     try {      // for error handling
01055         if (!( LA(3)=='\'' ))
01056             throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(3)=='\\'' ");
01057         match("'");
01058         matchNot(EOF/*_CHAR*/);
01059         match("'");
01060     }
01061     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01062         reportError(ex);
01063         consume();
01064         consumeUntil(_tokenSet_1);
01065     }
01066     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01067        _token = makeToken(_ttype);
01068        _token->setText(text.substr(_begin, text.length()-_begin));
01069     }
01070     _returnToken = _token;
01071     _saveIndex=0;
01072 }
01073 
01074 void AdaLexer::mCHAR_STRING(bool _createToken) {
01075     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01076     _ttype = CHAR_STRING;
01077     int _saveIndex;
01078     
01079     try {      // for error handling
01080         match(static_cast<unsigned char>('"'));
01081         { // ( ... )*
01082         for (;;) {
01083             if ((LA(1) == static_cast<unsigned char>('"')) && (LA(2) == static_cast<unsigned char>('"'))) {
01084                 match("\"\"");
01085             }
01086             else if ((_tokenSet_3.member(LA(1)))) {
01087                 {
01088                 match(_tokenSet_3);
01089                 }
01090             }
01091             else {
01092                 goto _loop513;
01093             }
01094             
01095         }
01096         _loop513:;
01097         } // ( ... )*
01098         match(static_cast<unsigned char>('"'));
01099     }
01100     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01101         reportError(ex);
01102         consume();
01103         consumeUntil(_tokenSet_1);
01104     }
01105     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01106        _token = makeToken(_ttype);
01107        _token->setText(text.substr(_begin, text.length()-_begin));
01108     }
01109     _returnToken = _token;
01110     _saveIndex=0;
01111 }
01112 
01113 void AdaLexer::mNUMERIC_LIT(bool _createToken) {
01114     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01115     _ttype = NUMERIC_LIT;
01116     int _saveIndex;
01117     
01118     try {      // for error handling
01119         { // ( ... )+
01120         int _cnt516=0;
01121         for (;;) {
01122             if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01123                 mDIGIT(false);
01124             }
01125             else {
01126                 if ( _cnt516>=1 ) { goto _loop516; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01127             }
01128             
01129             _cnt516++;
01130         }
01131         _loop516:;
01132         }  // ( ... )+
01133         {
01134         switch ( LA(1)) {
01135         case static_cast<unsigned char>('#'):
01136         {
01137             match(static_cast<unsigned char>('#'));
01138             mBASED_INTEGER(false);
01139             {
01140             switch ( LA(1)) {
01141             case static_cast<unsigned char>('.'):
01142             {
01143                 match(static_cast<unsigned char>('.'));
01144                 mBASED_INTEGER(false);
01145                 break;
01146             }
01147             case static_cast<unsigned char>('#'):
01148             {
01149                 break;
01150             }
01151             default:
01152             {
01153                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01154             }
01155             }
01156             }
01157             match(static_cast<unsigned char>('#'));
01158             break;
01159         }
01160         case static_cast<unsigned char>('_'):
01161         {
01162             { // ( ... )+
01163             int _cnt522=0;
01164             for (;;) {
01165                 if ((LA(1) == static_cast<unsigned char>('_'))) {
01166                     match(static_cast<unsigned char>('_'));
01167                     { // ( ... )+
01168                     int _cnt521=0;
01169                     for (;;) {
01170                         if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01171                             mDIGIT(false);
01172                         }
01173                         else {
01174                             if ( _cnt521>=1 ) { goto _loop521; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01175                         }
01176                         
01177                         _cnt521++;
01178                     }
01179                     _loop521:;
01180                     }  // ( ... )+
01181                 }
01182                 else {
01183                     if ( _cnt522>=1 ) { goto _loop522; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01184                 }
01185                 
01186                 _cnt522++;
01187             }
01188             _loop522:;
01189             }  // ( ... )+
01190             break;
01191         }
01192         default:
01193             {
01194             }
01195         }
01196         }
01197         {
01198         if (((LA(1) == static_cast<unsigned char>('.') || LA(1) == static_cast<unsigned char>('e')))&&( LA(2)!='.' )) {
01199             {
01200             switch ( LA(1)) {
01201             case static_cast<unsigned char>('.'):
01202             {
01203                 match(static_cast<unsigned char>('.'));
01204                 { // ( ... )+
01205                 int _cnt526=0;
01206                 for (;;) {
01207                     if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01208                         mDIGIT(false);
01209                     }
01210                     else {
01211                         if ( _cnt526>=1 ) { goto _loop526; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01212                     }
01213                     
01214                     _cnt526++;
01215                 }
01216                 _loop526:;
01217                 }  // ( ... )+
01218                 { // ( ... )*
01219                 for (;;) {
01220                     if ((LA(1) == static_cast<unsigned char>('_'))) {
01221                         match(static_cast<unsigned char>('_'));
01222                         { // ( ... )+
01223                         int _cnt529=0;
01224                         for (;;) {
01225                             if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01226                                 mDIGIT(false);
01227                             }
01228                             else {
01229                                 if ( _cnt529>=1 ) { goto _loop529; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01230                             }
01231                             
01232                             _cnt529++;
01233                         }
01234                         _loop529:;
01235                         }  // ( ... )+
01236                     }
01237                     else {
01238                         goto _loop530;
01239                     }
01240                     
01241                 }
01242                 _loop530:;
01243                 } // ( ... )*
01244                 {
01245                 if ((LA(1) == static_cast<unsigned char>('e'))) {
01246                     mEXPONENT(false);
01247                 }
01248                 else {
01249                 }
01250                 
01251                 }
01252                 break;
01253             }
01254             case static_cast<unsigned char>('e'):
01255             {
01256                 mEXPONENT(false);
01257                 break;
01258             }
01259             default:
01260             {
01261                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01262             }
01263             }
01264             }
01265         }
01266         else {
01267         }
01268         
01269         }
01270     }
01271     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01272         reportError(ex);
01273         consume();
01274         consumeUntil(_tokenSet_1);
01275     }
01276     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01277        _token = makeToken(_ttype);
01278        _token->setText(text.substr(_begin, text.length()-_begin));
01279     }
01280     _returnToken = _token;
01281     _saveIndex=0;
01282 }
01283 
01284 void AdaLexer::mDIGIT(bool _createToken) {
01285     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01286     _ttype = DIGIT;
01287     int _saveIndex;
01288     
01289     try {      // for error handling
01290         {
01291         matchRange(static_cast<unsigned char>('0'),static_cast<unsigned char>('9'));
01292         }
01293     }
01294     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01295         reportError(ex);
01296         consume();
01297         consumeUntil(_tokenSet_4);
01298     }
01299     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01300        _token = makeToken(_ttype);
01301        _token->setText(text.substr(_begin, text.length()-_begin));
01302     }
01303     _returnToken = _token;
01304     _saveIndex=0;
01305 }
01306 
01307 void AdaLexer::mBASED_INTEGER(bool _createToken) {
01308     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01309     _ttype = BASED_INTEGER;
01310     int _saveIndex;
01311     
01312     try {      // for error handling
01313         {
01314         mEXTENDED_DIGIT(false);
01315         }
01316         { // ( ... )*
01317         for (;;) {
01318             if ((_tokenSet_5.member(LA(1)))) {
01319                 {
01320                 switch ( LA(1)) {
01321                 case static_cast<unsigned char>('_'):
01322                 {
01323                     match(static_cast<unsigned char>('_'));
01324                     break;
01325                 }
01326                 case static_cast<unsigned char>('0'):
01327                 case static_cast<unsigned char>('1'):
01328                 case static_cast<unsigned char>('2'):
01329                 case static_cast<unsigned char>('3'):
01330                 case static_cast<unsigned char>('4'):
01331                 case static_cast<unsigned char>('5'):
01332                 case static_cast<unsigned char>('6'):
01333                 case static_cast<unsigned char>('7'):
01334                 case static_cast<unsigned char>('8'):
01335                 case static_cast<unsigned char>('9'):
01336                 case static_cast<unsigned char>('a'):
01337                 case static_cast<unsigned char>('b'):
01338                 case static_cast<unsigned char>('c'):
01339                 case static_cast<unsigned char>('d'):
01340                 case static_cast<unsigned char>('e'):
01341                 case static_cast<unsigned char>('f'):
01342                 {
01343                     break;
01344                 }
01345                 default:
01346                 {
01347                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01348                 }
01349                 }
01350                 }
01351                 mEXTENDED_DIGIT(false);
01352             }
01353             else {
01354                 goto _loop545;
01355             }
01356             
01357         }
01358         _loop545:;
01359         } // ( ... )*
01360     }
01361     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01362         reportError(ex);
01363         consume();
01364         consumeUntil(_tokenSet_6);
01365     }
01366     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01367        _token = makeToken(_ttype);
01368        _token->setText(text.substr(_begin, text.length()-_begin));
01369     }
01370     _returnToken = _token;
01371     _saveIndex=0;
01372 }
01373 
01374 void AdaLexer::mEXPONENT(bool _createToken) {
01375     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01376     _ttype = EXPONENT;
01377     int _saveIndex;
01378     
01379     try {      // for error handling
01380         {
01381         match(static_cast<unsigned char>('e'));
01382         }
01383         {
01384         switch ( LA(1)) {
01385         case static_cast<unsigned char>('+'):
01386         {
01387             match(static_cast<unsigned char>('+'));
01388             break;
01389         }
01390         case static_cast<unsigned char>('-'):
01391         {
01392             match(static_cast<unsigned char>('-'));
01393             break;
01394         }
01395         case static_cast<unsigned char>('0'):
01396         case static_cast<unsigned char>('1'):
01397         case static_cast<unsigned char>('2'):
01398         case static_cast<unsigned char>('3'):
01399         case static_cast<unsigned char>('4'):
01400         case static_cast<unsigned char>('5'):
01401         case static_cast<unsigned char>('6'):
01402         case static_cast<unsigned char>('7'):
01403         case static_cast<unsigned char>('8'):
01404         case static_cast<unsigned char>('9'):
01405         {
01406             break;
01407         }
01408         default:
01409         {
01410             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01411         }
01412         }
01413         }
01414         { // ( ... )+
01415         int _cnt538=0;
01416         for (;;) {
01417             if (((LA(1) >= static_cast<unsigned char>('0') && LA(1) <= static_cast<unsigned char>('9')))) {
01418                 mDIGIT(false);
01419             }
01420             else {
01421                 if ( _cnt538>=1 ) { goto _loop538; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
01422             }
01423             
01424             _cnt538++;
01425         }
01426         _loop538:;
01427         }  // ( ... )+
01428     }
01429     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01430         reportError(ex);
01431         consume();
01432         consumeUntil(_tokenSet_1);
01433     }
01434     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01435        _token = makeToken(_ttype);
01436        _token->setText(text.substr(_begin, text.length()-_begin));
01437     }
01438     _returnToken = _token;
01439     _saveIndex=0;
01440 }
01441 
01442 void AdaLexer::mEXTENDED_DIGIT(bool _createToken) {
01443     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01444     _ttype = EXTENDED_DIGIT;
01445     int _saveIndex;
01446     
01447     try {      // for error handling
01448         {
01449         switch ( LA(1)) {
01450         case static_cast<unsigned char>('0'):
01451         case static_cast<unsigned char>('1'):
01452         case static_cast<unsigned char>('2'):
01453         case static_cast<unsigned char>('3'):
01454         case static_cast<unsigned char>('4'):
01455         case static_cast<unsigned char>('5'):
01456         case static_cast<unsigned char>('6'):
01457         case static_cast<unsigned char>('7'):
01458         case static_cast<unsigned char>('8'):
01459         case static_cast<unsigned char>('9'):
01460         {
01461             mDIGIT(false);
01462             break;
01463         }
01464         case static_cast<unsigned char>('a'):
01465         case static_cast<unsigned char>('b'):
01466         case static_cast<unsigned char>('c'):
01467         case static_cast<unsigned char>('d'):
01468         case static_cast<unsigned char>('e'):
01469         case static_cast<unsigned char>('f'):
01470         {
01471             matchRange(static_cast<unsigned char>('a'),static_cast<unsigned char>('f'));
01472             break;
01473         }
01474         default:
01475         {
01476             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01477         }
01478         }
01479         }
01480     }
01481     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01482         reportError(ex);
01483         consume();
01484         consumeUntil(_tokenSet_4);
01485     }
01486     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01487        _token = makeToken(_ttype);
01488        _token->setText(text.substr(_begin, text.length()-_begin));
01489     }
01490     _returnToken = _token;
01491     _saveIndex=0;
01492 }
01493 
01494 void AdaLexer::mWS_(bool _createToken) {
01495     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01496     _ttype = WS_;
01497     int _saveIndex;
01498     
01499     try {      // for error handling
01500         {
01501         switch ( LA(1)) {
01502         case static_cast<unsigned char>(' '):
01503         {
01504             match(static_cast<unsigned char>(' '));
01505             break;
01506         }
01507         case static_cast<unsigned char>('\t'):
01508         {
01509             match(static_cast<unsigned char>('\t'));
01510             break;
01511         }
01512         case static_cast<unsigned char>('\14'):
01513         {
01514             match(static_cast<unsigned char>('\14'));
01515             break;
01516         }
01517         case static_cast<unsigned char>('\n'):
01518         case static_cast<unsigned char>('\r'):
01519         {
01520             {
01521             if ((LA(1) == static_cast<unsigned char>('\r')) && (LA(2) == static_cast<unsigned char>('\n'))) {
01522                 match("\r\n");
01523             }
01524             else if ((LA(1) == static_cast<unsigned char>('\r')) && (true)) {
01525                 match(static_cast<unsigned char>('\r'));
01526             }
01527             else if ((LA(1) == static_cast<unsigned char>('\n'))) {
01528                 match(static_cast<unsigned char>('\n'));
01529             }
01530             else {
01531                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01532             }
01533             
01534             }
01535 #line 1939 "ada.g"
01536             newline();
01537 #line 1538 "AdaLexer.cpp"
01538             break;
01539         }
01540         default:
01541         {
01542             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01543         }
01544         }
01545         }
01546 #line 1941 "ada.g"
01547         _ttype = antlr::Token::SKIP;
01548 #line 1549 "AdaLexer.cpp"
01549     }
01550     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01551         reportError(ex);
01552         consume();
01553         consumeUntil(_tokenSet_1);
01554     }
01555     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01556        _token = makeToken(_ttype);
01557        _token->setText(text.substr(_begin, text.length()-_begin));
01558     }
01559     _returnToken = _token;
01560     _saveIndex=0;
01561 }
01562 
01563 void AdaLexer::mCOMMENT(bool _createToken) {
01564     int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; int _begin=text.length();
01565     _ttype = COMMENT;
01566     int _saveIndex;
01567     
01568     try {      // for error handling
01569         {
01570         mCOMMENT_INTRO(false);
01571         { // ( ... )*
01572         for (;;) {
01573             if ((_tokenSet_7.member(LA(1)))) {
01574                 {
01575                 match(_tokenSet_7);
01576                 }
01577             }
01578             else {
01579                 goto _loop553;
01580             }
01581             
01582         }
01583         _loop553:;
01584         } // ( ... )*
01585         {
01586         switch ( LA(1)) {
01587         case static_cast<unsigned char>('\n'):
01588         {
01589             match(static_cast<unsigned char>('\n'));
01590             break;
01591         }
01592         case static_cast<unsigned char>('\r'):
01593         {
01594             match(static_cast<unsigned char>('\r'));
01595             {
01596             if ((LA(1) == static_cast<unsigned char>('\n'))) {
01597                 match(static_cast<unsigned char>('\n'));
01598             }
01599             else {
01600             }
01601             
01602             }
01603             break;
01604         }
01605         default:
01606         {
01607             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
01608         }
01609         }
01610         }
01611         }
01612 #line 1946 "ada.g"
01613         _ttype = antlr::Token::SKIP; newline();
01614 #line 1615 "AdaLexer.cpp"
01615     }
01616     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01617         reportError(ex);
01618         consume();
01619         consumeUntil(_tokenSet_1);
01620     }
01621     if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
01622        _token = makeToken(_ttype);
01623        _token->setText(text.substr(_begin, text.length()-_begin));
01624     }
01625     _returnToken = _token;
01626     _saveIndex=0;
01627 }
01628 
01629 
01630 const unsigned long AdaLexer::_tokenSet_0_data_[] = { 4294967288UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01631 // NULL_TREE_LOOKAHEAD "pragma" IDENTIFIER SEMI LPAREN COMMA RPAREN RIGHT_SHAFT 
01632 // "with" DOT "use" "type" TIC "range" "digits" "delta" "access" "private" 
01633 // "package" "body" "is" "procedure" "function" "new" "others" PIPE DOT_DOT 
01634 // "all" COLON "in" "out" "renames" CHARACTER_LITERAL CHAR_STRING "null" 
01635 // "record" "separate" "abstract" "return" "task" "protected" BOX ASSIGN 
01636 // "entry" "for" "end" "at" "mod" "subtype" "exception" "constant" "array" 
01637 // "of" "aliased" "case" "when" "tagged" "limited" "generic" "begin" LT_LT 
01638 // GT_GT "if" "then" "elsif" "else" "loop" "while" "reverse" "declare" 
01639 // "exit" "goto" "accept" "do" "delay" "until" "select" "abort" "or" "terminate" 
01640 // "raise" "requeue" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT 
01641 // STAR DIV "rem" "abs" EXPON NUMERIC_LIT ABORTABLE_PART ABORT_STATEMENT 
01642 // ABSTRACT_SUBPROGRAM_DECLARATION ACCEPT_ALTERNATIVE ACCEPT_STATEMENT 
01643 // ALLOCATOR ASSIGNMENT_STATEMENT ASYNCHRONOUS_SELECT ATTRIBUTE_DEFINITION_CLAUSE 
01644 // AT_CLAUSE BLOCK_STATEMENT CASE_STATEMENT CASE_STATEMENT_ALTERNATIVE 
01645 // CODE_STATEMENT COMPONENT_DECLARATION COMPONENT_LIST CONDITION CONDITIONAL_ENTRY_CALL 
01646 // CONTEXT_CLAUSE DECLARATIVE_ITEM DECLARATIVE_PART DEFINING_IDENTIFIER_LIST 
01647 // DELAY_ALTERNATIVE DELAY_STATEMENT DELTA_CONSTRAINT DIGITS_CONSTRAINT 
01648 // DISCRETE_RANGE DISCRIMINANT_ASSOCIATION DISCRIMINANT_CONSTRAINT DISCRIMINANT_SPECIFICATION 
01649 // ENTRY_BODY ENTRY_CALL_ALTERNATIVE ENTRY_CALL_STATEMENT ENTRY_DECLARATION 
01650 // ENTRY_INDEX_SPECIFICATION ENUMERATION_REPESENTATION_CLAUSE EXCEPTION_DECLARATION 
01651 // EXCEPTION_HANDLER EXCEPTION_RENAMING_DECLARATION EXIT_STATEMENT FORMAL_PACKAGE_DECLARATION 
01652 // FORMAL_TYPE_DECLARATION FULL_TYPE_DECLARATION GENERIC_FORMAL_PART GENERIC_INSTANTIATION 
01653 // GENERIC_PACKAGE_DECLARATION GENERIC_RENAMING_DECLARATION GENERIC_SUBPROGRAM_DECLARATION 
01654 // GOTO_STATEMENT HANDLED_SEQUENCE_OF_STATEMENTS IF_STATEMENT INCOMPLETE_TYPE_DECLARATION 
01655 // INDEXED_COMPONENT INDEX_CONSTRAINT LIBRARY_ITEM LOOP_STATEMENT NAME 
01656 // NULL_STATEMENT NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION 
01657 // OPERATOR_SYMBOL PACKAGE_BODY PACKAGE_BODY_STUB PACKAGE_RENAMING_DECLARATION 
01658 // PACKAGE_SPECIFICATION PARAMETER_SPECIFICATION PREFIX PRIMARY PRIVATE_EXTENSION_DECLARATION 
01659 // PRIVATE_TYPE_DECLARATION PROCEDURE_CALL_STATEMENT PROTECTED_BODY PROTECTED_BODY_STUB 
01660 // PROTECTED_TYPE_DECLARATION RAISE_STATEMENT RANGE_ATTRIBUTE_REFERENCE 
01661 // RECORD_REPRESENTATION_CLAUSE REQUEUE_STATEMENT RETURN_STATEMENT SELECTIVE_ACCEPT 
01662 // SELECT_ALTERNATIVE SELECT_STATEMENT SEQUENCE_OF_STATEMENTS SINGLE_PROTECTED_DECLARATION 
01663 // SINGLE_TASK_DECLARATION STATEMENT SUBPROGRAM_BODY SUBPROGRAM_BODY_STUB 
01664 // SUBPROGRAM_DECLARATION SUBPROGRAM_RENAMING_DECLARATION SUBTYPE_DECLARATION 
01665 // SUBTYPE_INDICATION SUBTYPE_MARK SUBUNIT TASK_BODY TASK_BODY_STUB TASK_TYPE_DECLARATION 
01666 // TERMINATE_ALTERNATIVE TIMED_ENTRY_CALL TRIGGERING_ALTERNATIVE TYPE_DECLARATION 
01667 // USE_CLAUSE USE_TYPE_CLAUSE VARIANT VARIANT_PART WITH_CLAUSE ABSTRACT_FUNCTION_DECLARATION 
01668 // ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION 
01669 // ACCESS_TO_PROCEDURE_DECLARATION ACCESS_TYPE_DECLARATION ARRAY_OBJECT_DECLARATION 
01670 // ARRAY_TYPE_DECLARATION AND_THEN BASIC_DECLARATIVE_ITEMS_OPT BLOCK_BODY 
01671 // BLOCK_BODY_OPT CALL_STATEMENT COMPONENT_CLAUSES_OPT COMPONENT_ITEMS 
01672 // COND_CLAUSE DECIMAL_FIXED_POINT_DECLARATION DECLARE_OPT DERIVED_RECORD_EXTENSION 
01673 // DERIVED_TYPE_DECLARATION DISCRETE_SUBTYPE_DEF_OPT DISCRIMINANT_SPECIFICATIONS 
01674 // DISCRIM_PART_OPT ELSE_OPT ELSIFS_OPT ENTRY_INDEX_OPT ENUMERATION_TYPE_DECLARATION 
01675 // EXCEPT_HANDLER_PART_OPT EXTENSION_OPT FLOATING_POINT_DECLARATION FORMAL_DECIMAL_FIXED_POINT_DECLARATION 
01676 // FORMAL_DISCRETE_TYPE_DECLARATION FORMAL_FLOATING_POINT_DECLARATION FORMAL_FUNCTION_DECLARATION 
01677 // FORMAL_MODULAR_TYPE_DECLARATION FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION 
01678 // FORMAL_ORDINARY_FIXED_POINT_DECLARATION FORMAL_PART_OPT FORMAL_PRIVATE_EXTENSION_DECLARATION 
01679 // FORMAL_PRIVATE_TYPE_DECLARATION FORMAL_PROCEDURE_DECLARATION FORMAL_SIGNED_INTEGER_TYPE_DECLARATION 
01680 // FUNCTION_BODY FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION 
01681 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_0(_tokenSet_0_data_,16);
01682 const unsigned long AdaLexer::_tokenSet_1_data_[] = { 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01683 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_1(_tokenSet_1_data_,10);
01684 const unsigned long AdaLexer::_tokenSet_2_data_[] = { 0UL, 67043328UL, 2147483648UL, 134217726UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01685 // "end" "at" "mod" "subtype" "exception" "constant" "array" "of" "aliased" 
01686 // "case" MINUS STAR DIV "rem" "abs" EXPON NUMERIC_LIT ABORTABLE_PART ABORT_STATEMENT 
01687 // ABSTRACT_SUBPROGRAM_DECLARATION ACCEPT_ALTERNATIVE ACCEPT_STATEMENT 
01688 // ALLOCATOR ASSIGNMENT_STATEMENT ASYNCHRONOUS_SELECT ATTRIBUTE_DEFINITION_CLAUSE 
01689 // AT_CLAUSE BLOCK_STATEMENT CASE_STATEMENT CASE_STATEMENT_ALTERNATIVE 
01690 // CODE_STATEMENT COMPONENT_DECLARATION COMPONENT_LIST CONDITION CONDITIONAL_ENTRY_CALL 
01691 // CONTEXT_CLAUSE DECLARATIVE_ITEM 
01692 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_2(_tokenSet_2_data_,10);
01693 const unsigned long AdaLexer::_tokenSet_3_data_[] = { 4294967288UL, 4294967291UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01694 // NULL_TREE_LOOKAHEAD "pragma" IDENTIFIER SEMI LPAREN COMMA RPAREN RIGHT_SHAFT 
01695 // "with" DOT "use" "type" TIC "range" "digits" "delta" "access" "private" 
01696 // "package" "body" "is" "procedure" "function" "new" "others" PIPE DOT_DOT 
01697 // "all" COLON "in" "out" CHARACTER_LITERAL CHAR_STRING "null" "record" 
01698 // "separate" "abstract" "return" "task" "protected" BOX ASSIGN "entry" 
01699 // "for" "end" "at" "mod" "subtype" "exception" "constant" "array" "of" 
01700 // "aliased" "case" "when" "tagged" "limited" "generic" "begin" LT_LT GT_GT 
01701 // "if" "then" "elsif" "else" "loop" "while" "reverse" "declare" "exit" 
01702 // "goto" "accept" "do" "delay" "until" "select" "abort" "or" "terminate" 
01703 // "raise" "requeue" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT 
01704 // STAR DIV "rem" "abs" EXPON NUMERIC_LIT ABORTABLE_PART ABORT_STATEMENT 
01705 // ABSTRACT_SUBPROGRAM_DECLARATION ACCEPT_ALTERNATIVE ACCEPT_STATEMENT 
01706 // ALLOCATOR ASSIGNMENT_STATEMENT ASYNCHRONOUS_SELECT ATTRIBUTE_DEFINITION_CLAUSE 
01707 // AT_CLAUSE BLOCK_STATEMENT CASE_STATEMENT CASE_STATEMENT_ALTERNATIVE 
01708 // CODE_STATEMENT COMPONENT_DECLARATION COMPONENT_LIST CONDITION CONDITIONAL_ENTRY_CALL 
01709 // CONTEXT_CLAUSE DECLARATIVE_ITEM DECLARATIVE_PART DEFINING_IDENTIFIER_LIST 
01710 // DELAY_ALTERNATIVE DELAY_STATEMENT DELTA_CONSTRAINT DIGITS_CONSTRAINT 
01711 // DISCRETE_RANGE DISCRIMINANT_ASSOCIATION DISCRIMINANT_CONSTRAINT DISCRIMINANT_SPECIFICATION 
01712 // ENTRY_BODY ENTRY_CALL_ALTERNATIVE ENTRY_CALL_STATEMENT ENTRY_DECLARATION 
01713 // ENTRY_INDEX_SPECIFICATION ENUMERATION_REPESENTATION_CLAUSE EXCEPTION_DECLARATION 
01714 // EXCEPTION_HANDLER EXCEPTION_RENAMING_DECLARATION EXIT_STATEMENT FORMAL_PACKAGE_DECLARATION 
01715 // FORMAL_TYPE_DECLARATION FULL_TYPE_DECLARATION GENERIC_FORMAL_PART GENERIC_INSTANTIATION 
01716 // GENERIC_PACKAGE_DECLARATION GENERIC_RENAMING_DECLARATION GENERIC_SUBPROGRAM_DECLARATION 
01717 // GOTO_STATEMENT HANDLED_SEQUENCE_OF_STATEMENTS IF_STATEMENT INCOMPLETE_TYPE_DECLARATION 
01718 // INDEXED_COMPONENT INDEX_CONSTRAINT LIBRARY_ITEM LOOP_STATEMENT NAME 
01719 // NULL_STATEMENT NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION 
01720 // OPERATOR_SYMBOL PACKAGE_BODY PACKAGE_BODY_STUB PACKAGE_RENAMING_DECLARATION 
01721 // PACKAGE_SPECIFICATION PARAMETER_SPECIFICATION PREFIX PRIMARY PRIVATE_EXTENSION_DECLARATION 
01722 // PRIVATE_TYPE_DECLARATION PROCEDURE_CALL_STATEMENT PROTECTED_BODY PROTECTED_BODY_STUB 
01723 // PROTECTED_TYPE_DECLARATION RAISE_STATEMENT RANGE_ATTRIBUTE_REFERENCE 
01724 // RECORD_REPRESENTATION_CLAUSE REQUEUE_STATEMENT RETURN_STATEMENT SELECTIVE_ACCEPT 
01725 // SELECT_ALTERNATIVE SELECT_STATEMENT SEQUENCE_OF_STATEMENTS SINGLE_PROTECTED_DECLARATION 
01726 // SINGLE_TASK_DECLARATION STATEMENT SUBPROGRAM_BODY SUBPROGRAM_BODY_STUB 
01727 // SUBPROGRAM_DECLARATION SUBPROGRAM_RENAMING_DECLARATION SUBTYPE_DECLARATION 
01728 // SUBTYPE_INDICATION SUBTYPE_MARK SUBUNIT TASK_BODY TASK_BODY_STUB TASK_TYPE_DECLARATION 
01729 // TERMINATE_ALTERNATIVE TIMED_ENTRY_CALL TRIGGERING_ALTERNATIVE TYPE_DECLARATION 
01730 // USE_CLAUSE USE_TYPE_CLAUSE VARIANT VARIANT_PART WITH_CLAUSE ABSTRACT_FUNCTION_DECLARATION 
01731 // ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION 
01732 // ACCESS_TO_PROCEDURE_DECLARATION ACCESS_TYPE_DECLARATION ARRAY_OBJECT_DECLARATION 
01733 // ARRAY_TYPE_DECLARATION AND_THEN BASIC_DECLARATIVE_ITEMS_OPT BLOCK_BODY 
01734 // BLOCK_BODY_OPT CALL_STATEMENT COMPONENT_CLAUSES_OPT COMPONENT_ITEMS 
01735 // COND_CLAUSE DECIMAL_FIXED_POINT_DECLARATION DECLARE_OPT DERIVED_RECORD_EXTENSION 
01736 // DERIVED_TYPE_DECLARATION DISCRETE_SUBTYPE_DEF_OPT DISCRIMINANT_SPECIFICATIONS 
01737 // DISCRIM_PART_OPT ELSE_OPT ELSIFS_OPT ENTRY_INDEX_OPT ENUMERATION_TYPE_DECLARATION 
01738 // EXCEPT_HANDLER_PART_OPT EXTENSION_OPT FLOATING_POINT_DECLARATION FORMAL_DECIMAL_FIXED_POINT_DECLARATION 
01739 // FORMAL_DISCRETE_TYPE_DECLARATION FORMAL_FLOATING_POINT_DECLARATION FORMAL_FUNCTION_DECLARATION 
01740 // FORMAL_MODULAR_TYPE_DECLARATION FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION 
01741 // FORMAL_ORDINARY_FIXED_POINT_DECLARATION FORMAL_PART_OPT FORMAL_PRIVATE_EXTENSION_DECLARATION 
01742 // FORMAL_PRIVATE_TYPE_DECLARATION FORMAL_PROCEDURE_DECLARATION FORMAL_SIGNED_INTEGER_TYPE_DECLARATION 
01743 // FUNCTION_BODY FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION 
01744 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_3(_tokenSet_3_data_,16);
01745 const unsigned long AdaLexer::_tokenSet_4_data_[] = { 0UL, 67059720UL, 2147483648UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01746 // CHARACTER_LITERAL "entry" "end" "at" "mod" "subtype" "exception" "constant" 
01747 // "array" "of" "aliased" "case" MINUS STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
01748 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_4(_tokenSet_4_data_,10);
01749 const unsigned long AdaLexer::_tokenSet_5_data_[] = { 0UL, 67043328UL, 2147483648UL, 126UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01750 // "end" "at" "mod" "subtype" "exception" "constant" "array" "of" "aliased" 
01751 // "case" MINUS STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
01752 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_5(_tokenSet_5_data_,10);
01753 const unsigned long AdaLexer::_tokenSet_6_data_[] = { 0UL, 16392UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01754 // CHARACTER_LITERAL "entry" 
01755 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_6(_tokenSet_6_data_,10);
01756 const unsigned long AdaLexer::_tokenSet_7_data_[] = { 4294958072UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
01757 // NULL_TREE_LOOKAHEAD "pragma" IDENTIFIER SEMI LPAREN COMMA RPAREN "with" 
01758 // DOT "type" TIC "range" "digits" "delta" "access" "private" "package" 
01759 // "body" "is" "procedure" "function" "new" "others" PIPE DOT_DOT "all" 
01760 // COLON "in" "out" "renames" CHARACTER_LITERAL CHAR_STRING "null" "record" 
01761 // "separate" "abstract" "return" "task" "protected" BOX ASSIGN "entry" 
01762 // "for" "end" "at" "mod" "subtype" "exception" "constant" "array" "of" 
01763 // "aliased" "case" "when" "tagged" "limited" "generic" "begin" LT_LT GT_GT 
01764 // "if" "then" "elsif" "else" "loop" "while" "reverse" "declare" "exit" 
01765 // "goto" "accept" "do" "delay" "until" "select" "abort" "or" "terminate" 
01766 // "raise" "requeue" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT 
01767 // STAR DIV "rem" "abs" EXPON NUMERIC_LIT ABORTABLE_PART ABORT_STATEMENT 
01768 // ABSTRACT_SUBPROGRAM_DECLARATION ACCEPT_ALTERNATIVE ACCEPT_STATEMENT 
01769 // ALLOCATOR ASSIGNMENT_STATEMENT ASYNCHRONOUS_SELECT ATTRIBUTE_DEFINITION_CLAUSE 
01770 // AT_CLAUSE BLOCK_STATEMENT CASE_STATEMENT CASE_STATEMENT_ALTERNATIVE 
01771 // CODE_STATEMENT COMPONENT_DECLARATION COMPONENT_LIST CONDITION CONDITIONAL_ENTRY_CALL 
01772 // CONTEXT_CLAUSE DECLARATIVE_ITEM DECLARATIVE_PART DEFINING_IDENTIFIER_LIST 
01773 // DELAY_ALTERNATIVE DELAY_STATEMENT DELTA_CONSTRAINT DIGITS_CONSTRAINT 
01774 // DISCRETE_RANGE DISCRIMINANT_ASSOCIATION DISCRIMINANT_CONSTRAINT DISCRIMINANT_SPECIFICATION 
01775 // ENTRY_BODY ENTRY_CALL_ALTERNATIVE ENTRY_CALL_STATEMENT ENTRY_DECLARATION 
01776 // ENTRY_INDEX_SPECIFICATION ENUMERATION_REPESENTATION_CLAUSE EXCEPTION_DECLARATION 
01777 // EXCEPTION_HANDLER EXCEPTION_RENAMING_DECLARATION EXIT_STATEMENT FORMAL_PACKAGE_DECLARATION 
01778 // FORMAL_TYPE_DECLARATION FULL_TYPE_DECLARATION GENERIC_FORMAL_PART GENERIC_INSTANTIATION 
01779 // GENERIC_PACKAGE_DECLARATION GENERIC_RENAMING_DECLARATION GENERIC_SUBPROGRAM_DECLARATION 
01780 // GOTO_STATEMENT HANDLED_SEQUENCE_OF_STATEMENTS IF_STATEMENT INCOMPLETE_TYPE_DECLARATION 
01781 // INDEXED_COMPONENT INDEX_CONSTRAINT LIBRARY_ITEM LOOP_STATEMENT NAME 
01782 // NULL_STATEMENT NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION 
01783 // OPERATOR_SYMBOL PACKAGE_BODY PACKAGE_BODY_STUB PACKAGE_RENAMING_DECLARATION 
01784 // PACKAGE_SPECIFICATION PARAMETER_SPECIFICATION PREFIX PRIMARY PRIVATE_EXTENSION_DECLARATION 
01785 // PRIVATE_TYPE_DECLARATION PROCEDURE_CALL_STATEMENT PROTECTED_BODY PROTECTED_BODY_STUB 
01786 // PROTECTED_TYPE_DECLARATION RAISE_STATEMENT RANGE_ATTRIBUTE_REFERENCE 
01787 // RECORD_REPRESENTATION_CLAUSE REQUEUE_STATEMENT RETURN_STATEMENT SELECTIVE_ACCEPT 
01788 // SELECT_ALTERNATIVE SELECT_STATEMENT SEQUENCE_OF_STATEMENTS SINGLE_PROTECTED_DECLARATION 
01789 // SINGLE_TASK_DECLARATION STATEMENT SUBPROGRAM_BODY SUBPROGRAM_BODY_STUB 
01790 // SUBPROGRAM_DECLARATION SUBPROGRAM_RENAMING_DECLARATION SUBTYPE_DECLARATION 
01791 // SUBTYPE_INDICATION SUBTYPE_MARK SUBUNIT TASK_BODY TASK_BODY_STUB TASK_TYPE_DECLARATION 
01792 // TERMINATE_ALTERNATIVE TIMED_ENTRY_CALL TRIGGERING_ALTERNATIVE TYPE_DECLARATION 
01793 // USE_CLAUSE USE_TYPE_CLAUSE VARIANT VARIANT_PART WITH_CLAUSE ABSTRACT_FUNCTION_DECLARATION 
01794 // ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION 
01795 // ACCESS_TO_PROCEDURE_DECLARATION ACCESS_TYPE_DECLARATION ARRAY_OBJECT_DECLARATION 
01796 // ARRAY_TYPE_DECLARATION AND_THEN BASIC_DECLARATIVE_ITEMS_OPT BLOCK_BODY 
01797 // BLOCK_BODY_OPT CALL_STATEMENT COMPONENT_CLAUSES_OPT COMPONENT_ITEMS 
01798 // COND_CLAUSE DECIMAL_FIXED_POINT_DECLARATION DECLARE_OPT DERIVED_RECORD_EXTENSION 
01799 // DERIVED_TYPE_DECLARATION DISCRETE_SUBTYPE_DEF_OPT DISCRIMINANT_SPECIFICATIONS 
01800 // DISCRIM_PART_OPT ELSE_OPT ELSIFS_OPT ENTRY_INDEX_OPT ENUMERATION_TYPE_DECLARATION 
01801 // EXCEPT_HANDLER_PART_OPT EXTENSION_OPT FLOATING_POINT_DECLARATION FORMAL_DECIMAL_FIXED_POINT_DECLARATION 
01802 // FORMAL_DISCRETE_TYPE_DECLARATION FORMAL_FLOATING_POINT_DECLARATION FORMAL_FUNCTION_DECLARATION 
01803 // FORMAL_MODULAR_TYPE_DECLARATION FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION 
01804 // FORMAL_ORDINARY_FIXED_POINT_DECLARATION FORMAL_PART_OPT FORMAL_PRIVATE_EXTENSION_DECLARATION 
01805 // FORMAL_PRIVATE_TYPE_DECLARATION FORMAL_PROCEDURE_DECLARATION FORMAL_SIGNED_INTEGER_TYPE_DECLARATION 
01806 // FUNCTION_BODY FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION 
01807 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_7(_tokenSet_7_data_,16);
01808 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:42 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003