KDevelop API Documentation

languages/ada/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.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Oct 6 17:38:56 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003