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