00001
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 {
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;
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
01055 if (!( LA(3)=='\'' ))
01056 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" LA(3)=='\\'' ");
01057 match("'");
01058 matchNot(EOF);
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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 {
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
01632
01633
01634
01635
01636
01637
01638
01639
01640
01641
01642
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660
01661
01662
01663
01664
01665
01666
01667
01668
01669
01670
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
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
01686
01687
01688
01689
01690
01691
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
01695
01696
01697
01698
01699
01700
01701
01702
01703
01704
01705
01706
01707
01708
01709
01710
01711
01712
01713
01714
01715
01716
01717
01718
01719
01720
01721
01722
01723
01724
01725
01726
01727
01728
01729
01730
01731
01732
01733
01734
01735
01736
01737
01738
01739
01740
01741
01742
01743
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
01747
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
01751
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
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
01758
01759
01760
01761
01762
01763
01764
01765
01766
01767
01768
01769
01770
01771
01772
01773
01774
01775
01776
01777
01778
01779
01780
01781
01782
01783
01784
01785
01786
01787
01788
01789
01790
01791
01792
01793
01794
01795
01796
01797
01798
01799
01800
01801
01802
01803
01804
01805
01806
01807 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaLexer::_tokenSet_7(_tokenSet_7_data_,16);
01808