00001
00002
#include "AdaParser.hpp"
00003
#include <antlr/NoViableAltException.hpp>
00004
#include <antlr/SemanticException.hpp>
00005
#include <antlr/ASTFactory.hpp>
00006
#line 1 "ada.g"
00007
#line 8 "AdaParser.cpp"
00008 AdaParser::AdaParser(
ANTLR_USE_NAMESPACE(antlr)
TokenBuffer& tokenBuf,
int k)
00009 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(tokenBuf,k)
00010 {
00011 }
00012
00013 AdaParser::AdaParser(
ANTLR_USE_NAMESPACE(antlr)
TokenBuffer& tokenBuf)
00014 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(tokenBuf,2)
00015 {
00016 }
00017
00018 AdaParser::AdaParser(
ANTLR_USE_NAMESPACE(antlr)
TokenStream& lexer,
int k)
00019 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(lexer,k)
00020 {
00021 }
00022
00023 AdaParser::AdaParser(
ANTLR_USE_NAMESPACE(antlr)
TokenStream& lexer)
00024 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(lexer,2)
00025 {
00026 }
00027
00028 AdaParser::AdaParser(
const ANTLR_USE_NAMESPACE(antlr)
ParserSharedInputState& state)
00029 :
ANTLR_USE_NAMESPACE(antlr)
LLkParser(state,2)
00030 {
00031 }
00032
00033 void AdaParser::compilation_unit() {
00034
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00035
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00036
RefAdaAST compilation_unit_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00037
00038
try {
00039
context_items_opt();
00040
if (inputState->guessing==0) {
00041 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00042 }
00043 {
00044
switch ( LA(1)) {
00045
case PRIVATE:
00046
case PACKAGE:
00047
case PROCEDURE:
00048
case FUNCTION:
00049
case GENERIC:
00050 {
00051
library_item();
00052
if (inputState->guessing==0) {
00053 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00054 }
00055
break;
00056 }
00057
case SEPARATE:
00058 {
00059
subunit();
00060
if (inputState->guessing==0) {
00061 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00062 }
00063
break;
00064 }
00065
default:
00066 {
00067
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00068 }
00069 }
00070 }
00071 {
00072
for (;;) {
00073
if ((LA(1) == PRAGMA)) {
00074
pragma();
00075
if (inputState->guessing==0) {
00076 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00077 }
00078 }
00079
else {
00080
goto _loop4;
00081 }
00082
00083 }
00084 _loop4:;
00085 }
00086 compilation_unit_AST = (currentAST.
root);
00087 }
00088
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00089
if( inputState->guessing == 0 ) {
00090
reportError(ex);
00091 consume();
00092 consumeUntil(
_tokenSet_0);
00093 }
else {
00094
throw;
00095 }
00096 }
00097
returnAST = compilation_unit_AST;
00098 }
00099
00100 void AdaParser::context_items_opt() {
00101
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00102
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00103
RefAdaAST context_items_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00104
00105
try {
00106 {
00107
for (;;) {
00108
if ((LA(1) == PRAGMA)) {
00109
pragma();
00110
if (inputState->guessing==0) {
00111 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00112 }
00113 }
00114
else {
00115
goto _loop14;
00116 }
00117
00118 }
00119 _loop14:;
00120 }
00121 {
00122
for (;;) {
00123
if ((LA(1) == WITH)) {
00124
with_clause();
00125
if (inputState->guessing==0) {
00126 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00127 }
00128 {
00129
for (;;) {
00130
switch ( LA(1)) {
00131
case USE:
00132 {
00133
use_clause();
00134
if (inputState->guessing==0) {
00135 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00136 }
00137
break;
00138 }
00139
case PRAGMA:
00140 {
00141
pragma();
00142
if (inputState->guessing==0) {
00143 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00144 }
00145
break;
00146 }
00147
default:
00148 {
00149
goto _loop17;
00150 }
00151 }
00152 }
00153 _loop17:;
00154 }
00155 }
00156
else {
00157
goto _loop18;
00158 }
00159
00160 }
00161 _loop18:;
00162 }
00163
if ( inputState->guessing==0 ) {
00164 context_items_opt_AST =
RefAdaAST(currentAST.
root);
00165
#line 86 "ada.g"
00166
context_items_opt_AST =
00167
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CONTEXT_CLAUSE,
"CONTEXT_CLAUSE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(context_items_opt_AST.get()))));
00168
#line 169 "AdaParser.cpp"
00169
currentAST.
root = context_items_opt_AST;
00170
if ( context_items_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00171 context_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00172 currentAST.
child = context_items_opt_AST->getFirstChild();
00173
else
00174 currentAST.
child = context_items_opt_AST;
00175 currentAST.
advanceChildToEnd();
00176 }
00177 context_items_opt_AST = (currentAST.
root);
00178 }
00179
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00180
if( inputState->guessing == 0 ) {
00181
reportError(ex);
00182 consume();
00183 consumeUntil(
_tokenSet_1);
00184 }
else {
00185
throw;
00186 }
00187 }
00188
returnAST = context_items_opt_AST;
00189 }
00190
00191 void AdaParser::library_item() {
00192
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00193
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00194
RefAdaAST library_item_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00195
00196
try {
00197
private_opt();
00198
if (inputState->guessing==0) {
00199 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00200 }
00201 {
00202
switch ( LA(1)) {
00203
case PACKAGE:
00204 {
00205
lib_pkg_spec_or_body();
00206
if (inputState->guessing==0) {
00207 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00208 }
00209
break;
00210 }
00211
case PROCEDURE:
00212
case FUNCTION:
00213 {
00214
subprog_decl_or_rename_or_inst_or_body(
true);
00215
if (inputState->guessing==0) {
00216 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00217 }
00218
break;
00219 }
00220
case GENERIC:
00221 {
00222
generic_decl(
true);
00223
if (inputState->guessing==0) {
00224 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00225 }
00226
break;
00227 }
00228
default:
00229 {
00230
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00231 }
00232 }
00233 }
00234
if ( inputState->guessing==0 ) {
00235 library_item_AST =
RefAdaAST(currentAST.
root);
00236
#line 133 "ada.g"
00237
library_item_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LIBRARY_ITEM,
"LIBRARY_ITEM").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(library_item_AST.get()))));
00238
#line 239 "AdaParser.cpp"
00239
currentAST.
root = library_item_AST;
00240
if ( library_item_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
00241 library_item_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
00242 currentAST.
child = library_item_AST->getFirstChild();
00243
else
00244 currentAST.
child = library_item_AST;
00245 currentAST.
advanceChildToEnd();
00246 }
00247 library_item_AST = (currentAST.
root);
00248 }
00249
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00250
if( inputState->guessing == 0 ) {
00251
reportError(ex);
00252 consume();
00253 consumeUntil(
_tokenSet_2);
00254 }
else {
00255
throw;
00256 }
00257 }
00258
returnAST = library_item_AST;
00259 }
00260
00261 void AdaParser::subunit() {
00262
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00263
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00264
RefAdaAST subunit_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00265
ANTLR_USE_NAMESPACE(antlr)
RefToken sep =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00266
RefAdaAST sep_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00267
00268
try {
00269 sep = LT(1);
00270
if ( inputState->guessing == 0 ) {
00271 sep_AST = astFactory->create(sep);
00272 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(sep_AST.get()));
00273 }
00274 match(SEPARATE);
00275 match(LPAREN);
00276
compound_name();
00277
if (inputState->guessing==0) {
00278 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00279 }
00280 match(RPAREN);
00281
if ( inputState->guessing==0 ) {
00282
#line 1472 "ada.g"
00283
Set(sep_AST, SUBUNIT);
00284
#line 285 "AdaParser.cpp"
00285
}
00286 {
00287
switch ( LA(1)) {
00288
case PROCEDURE:
00289
case FUNCTION:
00290 {
00291
subprogram_body();
00292
if (inputState->guessing==0) {
00293 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00294 }
00295
break;
00296 }
00297
case PACKAGE:
00298 {
00299
package_body();
00300
if (inputState->guessing==0) {
00301 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00302 }
00303
break;
00304 }
00305
case TASK:
00306 {
00307
task_body();
00308
if (inputState->guessing==0) {
00309 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00310 }
00311
break;
00312 }
00313
case PROTECTED:
00314 {
00315
protected_body();
00316
if (inputState->guessing==0) {
00317 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00318 }
00319
break;
00320 }
00321
default:
00322 {
00323
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00324 }
00325 }
00326 }
00327 subunit_AST = (currentAST.
root);
00328 }
00329
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00330
if( inputState->guessing == 0 ) {
00331
reportError(ex);
00332 consume();
00333 consumeUntil(
_tokenSet_2);
00334 }
else {
00335
throw;
00336 }
00337 }
00338
returnAST = subunit_AST;
00339 }
00340
00341 void AdaParser::pragma() {
00342
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00343
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00344
RefAdaAST pragma_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00345
00346
try {
00347
RefAdaAST tmp3_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00348
if ( inputState->guessing == 0 ) {
00349 tmp3_AST = astFactory->create(LT(1));
00350 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp3_AST.get()));
00351 }
00352 match(PRAGMA);
00353
RefAdaAST tmp4_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00354
if ( inputState->guessing == 0 ) {
00355 tmp4_AST = astFactory->create(LT(1));
00356 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp4_AST.get()));
00357 }
00358 match(IDENTIFIER);
00359
pragma_args_opt();
00360
if (inputState->guessing==0) {
00361 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00362 }
00363 match(SEMI);
00364 pragma_AST = (currentAST.
root);
00365 }
00366
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00367
if( inputState->guessing == 0 ) {
00368
reportError(ex);
00369 consume();
00370 consumeUntil(
_tokenSet_3);
00371 }
else {
00372
throw;
00373 }
00374 }
00375
returnAST = pragma_AST;
00376 }
00377
00378 void AdaParser::pragma_args_opt() {
00379
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00380
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00381
RefAdaAST pragma_args_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00382
00383
try {
00384 {
00385
switch ( LA(1)) {
00386
case LPAREN:
00387 {
00388 match(LPAREN);
00389
pragma_arg();
00390
if (inputState->guessing==0) {
00391 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00392 }
00393 {
00394
for (;;) {
00395
if ((LA(1) == COMMA)) {
00396 match(COMMA);
00397
pragma_arg();
00398
if (inputState->guessing==0) {
00399 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00400 }
00401 }
00402
else {
00403
goto _loop9;
00404 }
00405
00406 }
00407 _loop9:;
00408 }
00409 match(RPAREN);
00410
break;
00411 }
00412
case SEMI:
00413 {
00414
break;
00415 }
00416
default:
00417 {
00418
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00419 }
00420 }
00421 }
00422 pragma_args_opt_AST = (currentAST.
root);
00423 }
00424
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00425
if( inputState->guessing == 0 ) {
00426
reportError(ex);
00427 consume();
00428 consumeUntil(
_tokenSet_4);
00429 }
else {
00430
throw;
00431 }
00432 }
00433
returnAST = pragma_args_opt_AST;
00434 }
00435
00436 void AdaParser::pragma_arg() {
00437
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00438
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00439
RefAdaAST pragma_arg_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00440
00441
try {
00442 {
00443
if ((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT)) {
00444
RefAdaAST tmp9_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00445
if ( inputState->guessing == 0 ) {
00446 tmp9_AST = astFactory->create(LT(1));
00447 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp9_AST.get()));
00448 }
00449 match(IDENTIFIER);
00450
RefAdaAST tmp10_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00451
if ( inputState->guessing == 0 ) {
00452 tmp10_AST = astFactory->create(LT(1));
00453 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp10_AST.get()));
00454 }
00455 match(RIGHT_SHAFT);
00456 }
00457
else if ((
_tokenSet_5.member(LA(1))) && (
_tokenSet_6.member(LA(2)))) {
00458 }
00459
else {
00460
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00461 }
00462
00463 }
00464
expression();
00465
if (inputState->guessing==0) {
00466 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00467 }
00468 pragma_arg_AST = (currentAST.
root);
00469 }
00470
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00471
if( inputState->guessing == 0 ) {
00472
reportError(ex);
00473 consume();
00474 consumeUntil(
_tokenSet_7);
00475 }
else {
00476
throw;
00477 }
00478 }
00479
returnAST = pragma_arg_AST;
00480 }
00481
00482 void AdaParser::expression() {
00483
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00484
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00485
RefAdaAST expression_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00486
ANTLR_USE_NAMESPACE(antlr)
RefToken a =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00487
RefAdaAST a_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00488
ANTLR_USE_NAMESPACE(antlr)
RefToken o =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00489
RefAdaAST o_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00490
00491
try {
00492
relation();
00493
if (inputState->guessing==0) {
00494 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00495 }
00496 {
00497
for (;;) {
00498
switch ( LA(1)) {
00499
case AND:
00500 {
00501 a = LT(1);
00502
if ( inputState->guessing == 0 ) {
00503 a_AST = astFactory->create(a);
00504 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get()));
00505 }
00506 match(AND);
00507 {
00508
switch ( LA(1)) {
00509
case THEN:
00510 {
00511 match(THEN);
00512
if ( inputState->guessing==0 ) {
00513
#line 1392 "ada.g"
00514
Set (a_AST, AND_THEN);
00515
#line 516 "AdaParser.cpp"
00516
}
00517
break;
00518 }
00519
case IDENTIFIER:
00520
case LPAREN:
00521
case NEW:
00522
case CHARACTER_LITERAL:
00523
case CHAR_STRING:
00524
case NuLL:
00525
case NOT:
00526
case PLUS:
00527
case MINUS:
00528
case ABS:
00529
case NUMERIC_LIT:
00530 {
00531
break;
00532 }
00533
default:
00534 {
00535
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00536 }
00537 }
00538 }
00539
relation();
00540
if (inputState->guessing==0) {
00541 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00542 }
00543
break;
00544 }
00545
case OR:
00546 {
00547 o = LT(1);
00548
if ( inputState->guessing == 0 ) {
00549 o_AST = astFactory->create(o);
00550 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(o_AST.get()));
00551 }
00552 match(OR);
00553 {
00554
switch ( LA(1)) {
00555
case ELSE:
00556 {
00557 match(ELSE);
00558
if ( inputState->guessing==0 ) {
00559
#line 1393 "ada.g"
00560
Set (o_AST, OR_ELSE);
00561
#line 562 "AdaParser.cpp"
00562
}
00563
break;
00564 }
00565
case IDENTIFIER:
00566
case LPAREN:
00567
case NEW:
00568
case CHARACTER_LITERAL:
00569
case CHAR_STRING:
00570
case NuLL:
00571
case NOT:
00572
case PLUS:
00573
case MINUS:
00574
case ABS:
00575
case NUMERIC_LIT:
00576 {
00577
break;
00578 }
00579
default:
00580 {
00581
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00582 }
00583 }
00584 }
00585
relation();
00586
if (inputState->guessing==0) {
00587 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00588 }
00589
break;
00590 }
00591
case XOR:
00592 {
00593
RefAdaAST tmp13_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00594
if ( inputState->guessing == 0 ) {
00595 tmp13_AST = astFactory->create(LT(1));
00596 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp13_AST.get()));
00597 }
00598 match(XOR);
00599
relation();
00600
if (inputState->guessing==0) {
00601 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00602 }
00603
break;
00604 }
00605
default:
00606 {
00607
goto _loop445;
00608 }
00609 }
00610 }
00611 _loop445:;
00612 }
00613 expression_AST = (currentAST.
root);
00614 }
00615
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00616
if( inputState->guessing == 0 ) {
00617
reportError(ex);
00618 consume();
00619 consumeUntil(
_tokenSet_8);
00620 }
else {
00621
throw;
00622 }
00623 }
00624
returnAST = expression_AST;
00625 }
00626
00627 void AdaParser::with_clause() {
00628
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00629
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00630
RefAdaAST with_clause_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00631
ANTLR_USE_NAMESPACE(antlr)
RefToken w =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00632
RefAdaAST w_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00633
00634
try {
00635 w = LT(1);
00636
if ( inputState->guessing == 0 ) {
00637 w_AST = astFactory->create(w);
00638 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
00639 }
00640 match(WITH);
00641
c_name_list();
00642
if (inputState->guessing==0) {
00643 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00644 }
00645 match(SEMI);
00646
if ( inputState->guessing==0 ) {
00647
#line 94 "ada.g"
00648
Set(w_AST, WITH_CLAUSE);
00649
#line 650 "AdaParser.cpp"
00650
}
00651 with_clause_AST = (currentAST.
root);
00652 }
00653
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00654
if( inputState->guessing == 0 ) {
00655
reportError(ex);
00656 consume();
00657 consumeUntil(
_tokenSet_9);
00658 }
else {
00659
throw;
00660 }
00661 }
00662
returnAST = with_clause_AST;
00663 }
00664
00665 void AdaParser::use_clause() {
00666
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00667
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00668
RefAdaAST use_clause_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00669
ANTLR_USE_NAMESPACE(antlr)
RefToken u =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
00670
RefAdaAST u_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00671
00672
try {
00673 u = LT(1);
00674
if ( inputState->guessing == 0 ) {
00675 u_AST = astFactory->create(u);
00676 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(u_AST.get()));
00677 }
00678 match(USE);
00679 {
00680
switch ( LA(1)) {
00681
case TYPE:
00682 {
00683 match(TYPE);
00684
subtype_mark();
00685
if (inputState->guessing==0) {
00686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00687 }
00688 {
00689
for (;;) {
00690
if ((LA(1) == COMMA)) {
00691 match(COMMA);
00692
subtype_mark();
00693
if (inputState->guessing==0) {
00694 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00695 }
00696 }
00697
else {
00698
goto _loop29;
00699 }
00700
00701 }
00702 _loop29:;
00703 }
00704
if ( inputState->guessing==0 ) {
00705
#line 108 "ada.g"
00706
Set(u_AST, USE_TYPE_CLAUSE);
00707
#line 708 "AdaParser.cpp"
00708
}
00709
break;
00710 }
00711
case IDENTIFIER:
00712 {
00713
c_name_list();
00714
if (inputState->guessing==0) {
00715 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00716 }
00717
if ( inputState->guessing==0 ) {
00718
#line 109 "ada.g"
00719
Set(u_AST, USE_CLAUSE);
00720
#line 721 "AdaParser.cpp"
00721
}
00722
break;
00723 }
00724
default:
00725 {
00726
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00727 }
00728 }
00729 }
00730 match(SEMI);
00731 use_clause_AST = (currentAST.
root);
00732 }
00733
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00734
if( inputState->guessing == 0 ) {
00735
reportError(ex);
00736 consume();
00737 consumeUntil(
_tokenSet_10);
00738 }
else {
00739
throw;
00740 }
00741 }
00742
returnAST = use_clause_AST;
00743 }
00744
00745 void AdaParser::c_name_list() {
00746
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00747
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00748
RefAdaAST c_name_list_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00749
00750
try {
00751
compound_name();
00752
if (inputState->guessing==0) {
00753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00754 }
00755 {
00756
for (;;) {
00757
if ((LA(1) == COMMA)) {
00758 match(COMMA);
00759
compound_name();
00760
if (inputState->guessing==0) {
00761 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00762 }
00763 }
00764
else {
00765
goto _loop22;
00766 }
00767
00768 }
00769 _loop22:;
00770 }
00771 c_name_list_AST = (currentAST.
root);
00772 }
00773
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00774
if( inputState->guessing == 0 ) {
00775
reportError(ex);
00776 consume();
00777 consumeUntil(
_tokenSet_4);
00778 }
else {
00779
throw;
00780 }
00781 }
00782
returnAST = c_name_list_AST;
00783 }
00784
00785 void AdaParser::compound_name() {
00786
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00787
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00788
RefAdaAST compound_name_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00789
00790
try {
00791
RefAdaAST tmp19_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00792
if ( inputState->guessing == 0 ) {
00793 tmp19_AST = astFactory->create(LT(1));
00794 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp19_AST.get()));
00795 }
00796 match(IDENTIFIER);
00797 {
00798
for (;;) {
00799
if ((LA(1) == DOT)) {
00800
RefAdaAST tmp20_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00801
if ( inputState->guessing == 0 ) {
00802 tmp20_AST = astFactory->create(LT(1));
00803 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp20_AST.get()));
00804 }
00805 match(DOT);
00806
RefAdaAST tmp21_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00807
if ( inputState->guessing == 0 ) {
00808 tmp21_AST = astFactory->create(LT(1));
00809 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp21_AST.get()));
00810 }
00811 match(IDENTIFIER);
00812 }
00813
else {
00814
goto _loop25;
00815 }
00816
00817 }
00818 _loop25:;
00819 }
00820 compound_name_AST = (currentAST.
root);
00821 }
00822
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00823
if( inputState->guessing == 0 ) {
00824
reportError(ex);
00825 consume();
00826 consumeUntil(
_tokenSet_11);
00827 }
else {
00828
throw;
00829 }
00830 }
00831
returnAST = compound_name_AST;
00832 }
00833
00834 void AdaParser::subtype_mark() {
00835
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00836
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00837
RefAdaAST subtype_mark_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00838
00839
try {
00840
compound_name();
00841
if (inputState->guessing==0) {
00842 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00843 }
00844 {
00845
switch ( LA(1)) {
00846
case TIC:
00847 {
00848
RefAdaAST tmp22_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00849
if ( inputState->guessing == 0 ) {
00850 tmp22_AST = astFactory->create(LT(1));
00851 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp22_AST.get()));
00852 }
00853 match(TIC);
00854
attribute_id();
00855
if (inputState->guessing==0) {
00856 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
00857 }
00858
break;
00859 }
00860
case SEMI:
00861
case LPAREN:
00862
case COMMA:
00863
case RPAREN:
00864
case RIGHT_SHAFT:
00865
case WITH:
00866
case USE:
00867
case RANGE:
00868
case DIGITS:
00869
case DELTA:
00870
case IS:
00871
case PIPE:
00872
case DOT_DOT:
00873
case RENAMES:
00874
case ASSIGN:
00875
case AT:
00876
case THEN:
00877
case LOOP:
00878
case OR:
00879
case AND:
00880
case XOR:
00881 {
00882
break;
00883 }
00884
default:
00885 {
00886
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00887 }
00888 }
00889 }
00890 subtype_mark_AST = (currentAST.
root);
00891 }
00892
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00893
if( inputState->guessing == 0 ) {
00894
reportError(ex);
00895 consume();
00896 consumeUntil(
_tokenSet_12);
00897 }
else {
00898
throw;
00899 }
00900 }
00901
returnAST = subtype_mark_AST;
00902 }
00903
00904 void AdaParser::attribute_id() {
00905
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00906
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00907
RefAdaAST attribute_id_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00908
00909
try {
00910
switch ( LA(1)) {
00911
case RANGE:
00912 {
00913
RefAdaAST tmp23_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00914
if ( inputState->guessing == 0 ) {
00915 tmp23_AST = astFactory->create(LT(1));
00916 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp23_AST.get()));
00917 }
00918 match(RANGE);
00919 attribute_id_AST = (currentAST.
root);
00920
break;
00921 }
00922
case DIGITS:
00923 {
00924
RefAdaAST tmp24_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00925
if ( inputState->guessing == 0 ) {
00926 tmp24_AST = astFactory->create(LT(1));
00927 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp24_AST.get()));
00928 }
00929 match(DIGITS);
00930 attribute_id_AST = (currentAST.
root);
00931
break;
00932 }
00933
case DELTA:
00934 {
00935
RefAdaAST tmp25_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00936
if ( inputState->guessing == 0 ) {
00937 tmp25_AST = astFactory->create(LT(1));
00938 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp25_AST.get()));
00939 }
00940 match(DELTA);
00941 attribute_id_AST = (currentAST.
root);
00942
break;
00943 }
00944
case ACCESS:
00945 {
00946
RefAdaAST tmp26_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00947
if ( inputState->guessing == 0 ) {
00948 tmp26_AST = astFactory->create(LT(1));
00949 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp26_AST.get()));
00950 }
00951 match(ACCESS);
00952 attribute_id_AST = (currentAST.
root);
00953
break;
00954 }
00955
case IDENTIFIER:
00956 {
00957
RefAdaAST tmp27_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00958
if ( inputState->guessing == 0 ) {
00959 tmp27_AST = astFactory->create(LT(1));
00960 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp27_AST.get()));
00961 }
00962 match(IDENTIFIER);
00963 attribute_id_AST = (currentAST.
root);
00964
break;
00965 }
00966
default:
00967 {
00968
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
00969 }
00970 }
00971 }
00972
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00973
if( inputState->guessing == 0 ) {
00974
reportError(ex);
00975 consume();
00976 consumeUntil(
_tokenSet_13);
00977 }
else {
00978
throw;
00979 }
00980 }
00981
returnAST = attribute_id_AST;
00982 }
00983
00984 void AdaParser::private_opt() {
00985
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00986
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
00987
RefAdaAST private_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00988
00989
try {
00990 {
00991
switch ( LA(1)) {
00992
case PRIVATE:
00993 {
00994
RefAdaAST tmp28_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
00995
if ( inputState->guessing == 0 ) {
00996 tmp28_AST = astFactory->create(LT(1));
00997 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp28_AST.get()));
00998 }
00999 match(PRIVATE);
01000
break;
01001 }
01002
case PACKAGE:
01003
case PROCEDURE:
01004
case FUNCTION:
01005
case GENERIC:
01006 {
01007
break;
01008 }
01009
default:
01010 {
01011
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01012 }
01013 }
01014 }
01015
if ( inputState->guessing==0 ) {
01016 private_opt_AST =
RefAdaAST(currentAST.
root);
01017
#line 137 "ada.g"
01018
private_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(private_opt_AST.get()))));
01019
#line 1020 "AdaParser.cpp"
01020
currentAST.
root = private_opt_AST;
01021
if ( private_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
01022 private_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
01023 currentAST.
child = private_opt_AST->getFirstChild();
01024
else
01025 currentAST.
child = private_opt_AST;
01026 currentAST.
advanceChildToEnd();
01027 }
01028 private_opt_AST = (currentAST.
root);
01029 }
01030
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01031
if( inputState->guessing == 0 ) {
01032
reportError(ex);
01033 consume();
01034 consumeUntil(
_tokenSet_14);
01035 }
else {
01036
throw;
01037 }
01038 }
01039
returnAST = private_opt_AST;
01040 }
01041
01042 void AdaParser::lib_pkg_spec_or_body() {
01043
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01044
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01045
RefAdaAST lib_pkg_spec_or_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01046
ANTLR_USE_NAMESPACE(antlr)
RefToken pkg =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01047
RefAdaAST pkg_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01048
01049
try {
01050 pkg = LT(1);
01051
if ( inputState->guessing == 0 ) {
01052 pkg_AST = astFactory->create(pkg);
01053 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get()));
01054 }
01055 match(PACKAGE);
01056 {
01057
switch ( LA(1)) {
01058
case BODY:
01059 {
01060 match(BODY);
01061
def_id(
true);
01062
if (inputState->guessing==0) {
01063 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01064 }
01065 match(IS);
01066
pkg_body_part();
01067
if (inputState->guessing==0) {
01068 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01069 }
01070
end_id_opt();
01071 match(SEMI);
01072
if ( inputState->guessing==0 ) {
01073
#line 143 "ada.g"
01074
Set(pkg_AST, PACKAGE_BODY);
01075
#line 1076 "AdaParser.cpp"
01076
}
01077
break;
01078 }
01079
case IDENTIFIER:
01080 {
01081
def_id(
true);
01082
if (inputState->guessing==0) {
01083 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01084 }
01085
spec_decl_part(pkg_AST);
01086
if (inputState->guessing==0) {
01087 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01088 }
01089
break;
01090 }
01091
default:
01092 {
01093
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01094 }
01095 }
01096 }
01097 lib_pkg_spec_or_body_AST = (currentAST.
root);
01098 }
01099
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01100
if( inputState->guessing == 0 ) {
01101
reportError(ex);
01102 consume();
01103 consumeUntil(
_tokenSet_2);
01104 }
else {
01105
throw;
01106 }
01107 }
01108
returnAST = lib_pkg_spec_or_body_AST;
01109 }
01110
01111 void AdaParser::subprog_decl_or_rename_or_inst_or_body(
01112
bool lib_level
01113 ) {
01114
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01115
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01116
RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01117
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01118
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01119
ANTLR_USE_NAMESPACE(antlr)
RefToken f =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01120
RefAdaAST f_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01121
#line 930 "ada.g"
01122
RefAdaAST t;
01123
#line 1124 "AdaParser.cpp"
01124
01125
try {
01126
switch ( LA(1)) {
01127
case PROCEDURE:
01128 {
01129 p = LT(1);
01130
if ( inputState->guessing == 0 ) {
01131 p_AST = astFactory->create(p);
01132 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
01133 }
01134 match(PROCEDURE);
01135
def_id(lib_level);
01136
if (inputState->guessing==0) {
01137 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01138 }
01139 {
01140
if ((LA(1) == IS) && (LA(2) == NEW)) {
01141
generic_subp_inst();
01142
if (inputState->guessing==0) {
01143 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01144 }
01145
if ( inputState->guessing==0 ) {
01146
#line 934 "ada.g"
01147
Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
01148
#line 1149 "AdaParser.cpp"
01149
}
01150 }
01151
else if ((
_tokenSet_15.member(LA(1))) && (
_tokenSet_16.member(LA(2)))) {
01152
formal_part_opt();
01153
if (inputState->guessing==0) {
01154 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01155 }
01156 {
01157
switch ( LA(1)) {
01158
case RENAMES:
01159 {
01160
renames();
01161
if (inputState->guessing==0) {
01162 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01163 }
01164
if ( inputState->guessing==0 ) {
01165
#line 936 "ada.g"
01166
Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
01167
#line 1168 "AdaParser.cpp"
01168
}
01169
break;
01170 }
01171
case IS:
01172 {
01173 match(IS);
01174 {
01175
switch ( LA(1)) {
01176
case SEPARATE:
01177
case ABSTRACT:
01178 {
01179
separate_or_abstract(p_AST);
01180
if (inputState->guessing==0) {
01181 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01182 }
01183
break;
01184 }
01185
case PRAGMA:
01186
case IDENTIFIER:
01187
case USE:
01188
case TYPE:
01189
case PACKAGE:
01190
case PROCEDURE:
01191
case FUNCTION:
01192
case TASK:
01193
case PROTECTED:
01194
case FOR:
01195
case SUBTYPE:
01196
case GENERIC:
01197
case BEGIN:
01198 {
01199
body_part();
01200
if (inputState->guessing==0) {
01201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01202 }
01203
if ( inputState->guessing==0 ) {
01204
#line 938 "ada.g"
01205
Set(p_AST, PROCEDURE_BODY);
01206
#line 1207 "AdaParser.cpp"
01207
}
01208
break;
01209 }
01210
default:
01211 {
01212
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01213 }
01214 }
01215 }
01216
break;
01217 }
01218
case SEMI:
01219 {
01220
if ( inputState->guessing==0 ) {
01221
#line 940 "ada.g"
01222
pop_def_id();
01223
Set(p_AST, PROCEDURE_DECLARATION);
01224
#line 1225 "AdaParser.cpp"
01225
}
01226
break;
01227 }
01228
default:
01229 {
01230
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01231 }
01232 }
01233 }
01234 match(SEMI);
01235 }
01236
else {
01237
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01238 }
01239
01240 }
01241 subprog_decl_or_rename_or_inst_or_body_AST = (currentAST.
root);
01242
break;
01243 }
01244
case FUNCTION:
01245 {
01246 f = LT(1);
01247
if ( inputState->guessing == 0 ) {
01248 f_AST = astFactory->create(f);
01249 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
01250 }
01251 match(FUNCTION);
01252
def_designator(lib_level);
01253
if (inputState->guessing==0) {
01254 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01255 }
01256 {
01257
switch ( LA(1)) {
01258
case IS:
01259 {
01260
generic_subp_inst();
01261
if (inputState->guessing==0) {
01262 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01263 }
01264
if ( inputState->guessing==0 ) {
01265
#line 947 "ada.g"
01266
Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
01267
#line 1268 "AdaParser.cpp"
01268
}
01269
break;
01270 }
01271
case LPAREN:
01272
case RETURN:
01273 {
01274
function_tail();
01275
if (inputState->guessing==0) {
01276 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01277 }
01278 {
01279
switch ( LA(1)) {
01280
case RENAMES:
01281 {
01282
renames();
01283
if (inputState->guessing==0) {
01284 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01285 }
01286
if ( inputState->guessing==0 ) {
01287
#line 949 "ada.g"
01288
Set(f_AST, FUNCTION_RENAMING_DECLARATION);
01289
#line 1290 "AdaParser.cpp"
01290
}
01291
break;
01292 }
01293
case IS:
01294 {
01295 match(IS);
01296 {
01297
switch ( LA(1)) {
01298
case SEPARATE:
01299
case ABSTRACT:
01300 {
01301
separate_or_abstract(f_AST);
01302
if (inputState->guessing==0) {
01303 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01304 }
01305
break;
01306 }
01307
case PRAGMA:
01308
case IDENTIFIER:
01309
case USE:
01310
case TYPE:
01311
case PACKAGE:
01312
case PROCEDURE:
01313
case FUNCTION:
01314
case TASK:
01315
case PROTECTED:
01316
case FOR:
01317
case SUBTYPE:
01318
case GENERIC:
01319
case BEGIN:
01320 {
01321
body_part();
01322
if (inputState->guessing==0) {
01323 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01324 }
01325
if ( inputState->guessing==0 ) {
01326
#line 951 "ada.g"
01327
Set(f_AST, FUNCTION_BODY);
01328
#line 1329 "AdaParser.cpp"
01329
}
01330
break;
01331 }
01332
default:
01333 {
01334
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01335 }
01336 }
01337 }
01338
break;
01339 }
01340
case SEMI:
01341 {
01342
if ( inputState->guessing==0 ) {
01343
#line 953 "ada.g"
01344
pop_def_id();
01345
Set(f_AST, FUNCTION_DECLARATION);
01346
#line 1347 "AdaParser.cpp"
01347
}
01348
break;
01349 }
01350
default:
01351 {
01352
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01353 }
01354 }
01355 }
01356 match(SEMI);
01357
break;
01358 }
01359
default:
01360 {
01361
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01362 }
01363 }
01364 }
01365 subprog_decl_or_rename_or_inst_or_body_AST = (currentAST.
root);
01366
break;
01367 }
01368
default:
01369 {
01370
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01371 }
01372 }
01373 }
01374
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01375
if( inputState->guessing == 0 ) {
01376
reportError(ex);
01377 consume();
01378 consumeUntil(
_tokenSet_17);
01379 }
else {
01380
throw;
01381 }
01382 }
01383
returnAST = subprog_decl_or_rename_or_inst_or_body_AST;
01384 }
01385
01386 void AdaParser::generic_decl(
01387
bool lib_level
01388 ) {
01389
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01390
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01391
RefAdaAST generic_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01392
ANTLR_USE_NAMESPACE(antlr)
RefToken g =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01393
RefAdaAST g_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01394
01395
try {
01396 g = LT(1);
01397
if ( inputState->guessing == 0 ) {
01398 g_AST = astFactory->create(g);
01399 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(g_AST.get()));
01400 }
01401 match(GENERIC);
01402
generic_formal_part_opt();
01403
if (inputState->guessing==0) {
01404 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01405 }
01406 {
01407
switch ( LA(1)) {
01408
case PACKAGE:
01409 {
01410 match(PACKAGE);
01411
def_id(lib_level);
01412
if (inputState->guessing==0) {
01413 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01414 }
01415 {
01416
switch ( LA(1)) {
01417
case RENAMES:
01418 {
01419
renames();
01420
if (inputState->guessing==0) {
01421 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01422 }
01423
if ( inputState->guessing==0 ) {
01424
#line 851 "ada.g"
01425
Set(g_AST, GENERIC_PACKAGE_RENAMING);
01426
#line 1427 "AdaParser.cpp"
01427
}
01428
break;
01429 }
01430
case IS:
01431 {
01432 match(IS);
01433
pkg_spec_part();
01434
if (inputState->guessing==0) {
01435 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01436 }
01437
if ( inputState->guessing==0 ) {
01438
#line 852 "ada.g"
01439
Set(g_AST, GENERIC_PACKAGE_DECLARATION);
01440
#line 1441 "AdaParser.cpp"
01441
}
01442
break;
01443 }
01444
default:
01445 {
01446
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01447 }
01448 }
01449 }
01450
break;
01451 }
01452
case PROCEDURE:
01453 {
01454 match(PROCEDURE);
01455
def_id(lib_level);
01456
if (inputState->guessing==0) {
01457 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01458 }
01459
formal_part_opt();
01460
if (inputState->guessing==0) {
01461 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01462 }
01463 {
01464
switch ( LA(1)) {
01465
case RENAMES:
01466 {
01467
renames();
01468
if (inputState->guessing==0) {
01469 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01470 }
01471
if ( inputState->guessing==0 ) {
01472
#line 855 "ada.g"
01473
Set(g_AST, GENERIC_PROCEDURE_RENAMING);
01474
#line 1475 "AdaParser.cpp"
01475
}
01476
break;
01477 }
01478
case SEMI:
01479 {
01480
if ( inputState->guessing==0 ) {
01481
#line 858 "ada.g"
01482
Set(g_AST, GENERIC_PROCEDURE_DECLARATION);
pop_def_id();
01483
#line 1484 "AdaParser.cpp"
01484
}
01485
break;
01486 }
01487
default:
01488 {
01489
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01490 }
01491 }
01492 }
01493
break;
01494 }
01495
case FUNCTION:
01496 {
01497 match(FUNCTION);
01498
def_designator(lib_level);
01499
if (inputState->guessing==0) {
01500 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01501 }
01502
function_tail();
01503
if (inputState->guessing==0) {
01504 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01505 }
01506 {
01507
switch ( LA(1)) {
01508
case RENAMES:
01509 {
01510
renames();
01511
if (inputState->guessing==0) {
01512 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01513 }
01514
if ( inputState->guessing==0 ) {
01515
#line 861 "ada.g"
01516
Set(g_AST, GENERIC_FUNCTION_RENAMING);
01517
#line 1518 "AdaParser.cpp"
01518
}
01519
break;
01520 }
01521
case SEMI:
01522 {
01523
if ( inputState->guessing==0 ) {
01524
#line 864 "ada.g"
01525
Set(g_AST, GENERIC_FUNCTION_DECLARATION);
pop_def_id();
01526
#line 1527 "AdaParser.cpp"
01527
}
01528
break;
01529 }
01530
default:
01531 {
01532
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01533 }
01534 }
01535 }
01536
break;
01537 }
01538
default:
01539 {
01540
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01541 }
01542 }
01543 }
01544 match(SEMI);
01545 generic_decl_AST = (currentAST.
root);
01546 }
01547
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01548
if( inputState->guessing == 0 ) {
01549
reportError(ex);
01550 consume();
01551 consumeUntil(
_tokenSet_18);
01552 }
else {
01553
throw;
01554 }
01555 }
01556
returnAST = generic_decl_AST;
01557 }
01558
01559 void AdaParser::def_id(
01560
bool lib_level
01561 ) {
01562
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01563
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01564
RefAdaAST def_id_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01565
RefAdaAST cn_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01566
ANTLR_USE_NAMESPACE(antlr)
RefToken n =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01567
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01568
01569
try {
01570
if (((LA(1) == IDENTIFIER) && (
_tokenSet_19.member(LA(2))))&&( lib_level )) {
01571
compound_name();
01572
if (inputState->guessing==0) {
01573 cn_AST =
returnAST;
01574 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01575 }
01576
if ( inputState->guessing==0 ) {
01577
#line 171 "ada.g"
01578
push_def_id(cn_AST);
01579
#line 1580 "AdaParser.cpp"
01580
}
01581 def_id_AST = (currentAST.
root);
01582 }
01583
else if (((LA(1) == IDENTIFIER) && (
_tokenSet_20.member(LA(2))))&&( !lib_level )) {
01584 n = LT(1);
01585
if ( inputState->guessing == 0 ) {
01586 n_AST = astFactory->create(n);
01587 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
01588 }
01589 match(IDENTIFIER);
01590
if ( inputState->guessing==0 ) {
01591
#line 172 "ada.g"
01592
push_def_id(n_AST);
01593
#line 1594 "AdaParser.cpp"
01594
}
01595 def_id_AST = (currentAST.
root);
01596 }
01597
else {
01598
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01599 }
01600
01601 }
01602
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01603
if( inputState->guessing == 0 ) {
01604
reportError(ex);
01605 consume();
01606 consumeUntil(
_tokenSet_20);
01607 }
else {
01608
throw;
01609 }
01610 }
01611
returnAST = def_id_AST;
01612 }
01613
01614 void AdaParser::pkg_body_part() {
01615
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01616
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01617
RefAdaAST pkg_body_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01618
01619
try {
01620
declarative_part();
01621
if (inputState->guessing==0) {
01622 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01623 }
01624
block_body_opt();
01625
if (inputState->guessing==0) {
01626 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01627 }
01628 pkg_body_part_AST = (currentAST.
root);
01629 }
01630
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01631
if( inputState->guessing == 0 ) {
01632
reportError(ex);
01633 consume();
01634 consumeUntil(
_tokenSet_21);
01635 }
else {
01636
throw;
01637 }
01638 }
01639
returnAST = pkg_body_part_AST;
01640 }
01641
01642 void AdaParser::end_id_opt() {
01643
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01644
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01645
RefAdaAST end_id_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01646
01647
try {
01648 match(END);
01649
id_opt();
01650
if (inputState->guessing==0) {
01651 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01652 }
01653 end_id_opt_AST = (currentAST.
root);
01654 }
01655
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01656
if( inputState->guessing == 0 ) {
01657
reportError(ex);
01658 consume();
01659 consumeUntil(
_tokenSet_4);
01660 }
else {
01661
throw;
01662 }
01663 }
01664
returnAST = end_id_opt_AST;
01665 }
01666
01667 void AdaParser::spec_decl_part(
01668 RefAdaAST pkg
01669 ) {
01670
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01671
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01672
RefAdaAST spec_decl_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01673
01674
try {
01675 {
01676
switch ( LA(1)) {
01677
case IS:
01678 {
01679 match(IS);
01680 {
01681
switch ( LA(1)) {
01682
case NEW:
01683 {
01684
generic_inst();
01685
if (inputState->guessing==0) {
01686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01687 }
01688
if ( inputState->guessing==0 ) {
01689
#line 363 "ada.g"
01690
Set(pkg, GENERIC_PACKAGE_INSTANTIATION);
01691
#line 1692 "AdaParser.cpp"
01692
}
01693
break;
01694 }
01695
case PRAGMA:
01696
case IDENTIFIER:
01697
case USE:
01698
case TYPE:
01699
case PRIVATE:
01700
case PACKAGE:
01701
case PROCEDURE:
01702
case FUNCTION:
01703
case TASK:
01704
case PROTECTED:
01705
case FOR:
01706
case END:
01707
case SUBTYPE:
01708
case GENERIC:
01709 {
01710
pkg_spec_part();
01711
if (inputState->guessing==0) {
01712 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01713 }
01714
if ( inputState->guessing==0 ) {
01715
#line 364 "ada.g"
01716
Set(pkg, PACKAGE_SPECIFICATION);
01717
#line 1718 "AdaParser.cpp"
01718
}
01719
break;
01720 }
01721
default:
01722 {
01723
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01724 }
01725 }
01726 }
01727
break;
01728 }
01729
case RENAMES:
01730 {
01731
renames();
01732
if (inputState->guessing==0) {
01733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01734 }
01735
if ( inputState->guessing==0 ) {
01736
#line 366 "ada.g"
01737
Set(pkg, PACKAGE_RENAMING_DECLARATION);
01738
#line 1739 "AdaParser.cpp"
01739
}
01740
break;
01741 }
01742
default:
01743 {
01744
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01745 }
01746 }
01747 }
01748 match(SEMI);
01749 spec_decl_part_AST = (currentAST.
root);
01750 }
01751
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01752
if( inputState->guessing == 0 ) {
01753
reportError(ex);
01754 consume();
01755 consumeUntil(
_tokenSet_18);
01756 }
else {
01757
throw;
01758 }
01759 }
01760
returnAST = spec_decl_part_AST;
01761 }
01762
01763 void AdaParser::subprog_decl(
01764
bool lib_level
01765 ) {
01766
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01767
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01768
RefAdaAST subprog_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01769
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01770
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01771
ANTLR_USE_NAMESPACE(antlr)
RefToken f =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
01772
RefAdaAST f_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01773
#line 148 "ada.g"
01774
RefAdaAST t;
01775
#line 1776 "AdaParser.cpp"
01776
01777
try {
01778
switch ( LA(1)) {
01779
case PROCEDURE:
01780 {
01781 p = LT(1);
01782
if ( inputState->guessing == 0 ) {
01783 p_AST = astFactory->create(p);
01784 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
01785 }
01786 match(PROCEDURE);
01787
def_id(lib_level);
01788
if (inputState->guessing==0) {
01789 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01790 }
01791 {
01792
if ((LA(1) == IS) && (LA(2) == NEW)) {
01793
generic_subp_inst();
01794
if (inputState->guessing==0) {
01795 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01796 }
01797
if ( inputState->guessing==0 ) {
01798
#line 152 "ada.g"
01799
Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
01800
#line 1801 "AdaParser.cpp"
01801
}
01802 }
01803
else if ((
_tokenSet_15.member(LA(1))) && (
_tokenSet_22.member(LA(2)))) {
01804
formal_part_opt();
01805
if (inputState->guessing==0) {
01806 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01807 }
01808 {
01809
switch ( LA(1)) {
01810
case RENAMES:
01811 {
01812
renames();
01813
if (inputState->guessing==0) {
01814 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01815 }
01816
if ( inputState->guessing==0 ) {
01817
#line 154 "ada.g"
01818
Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
01819
#line 1820 "AdaParser.cpp"
01820
}
01821
break;
01822 }
01823
case SEMI:
01824
case IS:
01825 {
01826
is_separate_or_abstract_or_decl(p_AST);
01827
if (inputState->guessing==0) {
01828 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01829 }
01830
break;
01831 }
01832
default:
01833 {
01834
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01835 }
01836 }
01837 }
01838 match(SEMI);
01839 }
01840
else {
01841
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01842 }
01843
01844 }
01845 subprog_decl_AST = (currentAST.
root);
01846
break;
01847 }
01848
case FUNCTION:
01849 {
01850 f = LT(1);
01851
if ( inputState->guessing == 0 ) {
01852 f_AST = astFactory->create(f);
01853 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
01854 }
01855 match(FUNCTION);
01856
def_designator(lib_level);
01857
if (inputState->guessing==0) {
01858 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01859 }
01860 {
01861
switch ( LA(1)) {
01862
case IS:
01863 {
01864
generic_subp_inst();
01865
if (inputState->guessing==0) {
01866 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01867 }
01868
if ( inputState->guessing==0 ) {
01869
#line 161 "ada.g"
01870
Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
01871
#line 1872 "AdaParser.cpp"
01872
}
01873
break;
01874 }
01875
case LPAREN:
01876
case RETURN:
01877 {
01878
function_tail();
01879
if (inputState->guessing==0) {
01880 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01881 }
01882 {
01883
switch ( LA(1)) {
01884
case RENAMES:
01885 {
01886
renames();
01887
if (inputState->guessing==0) {
01888 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01889 }
01890
if ( inputState->guessing==0 ) {
01891
#line 163 "ada.g"
01892
Set(f_AST, FUNCTION_RENAMING_DECLARATION);
01893
#line 1894 "AdaParser.cpp"
01894
}
01895
break;
01896 }
01897
case SEMI:
01898
case IS:
01899 {
01900
is_separate_or_abstract_or_decl(f_AST);
01901
if (inputState->guessing==0) {
01902 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01903 }
01904
break;
01905 }
01906
default:
01907 {
01908
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01909 }
01910 }
01911 }
01912 match(SEMI);
01913
break;
01914 }
01915
default:
01916 {
01917
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01918 }
01919 }
01920 }
01921 subprog_decl_AST = (currentAST.
root);
01922
break;
01923 }
01924
default:
01925 {
01926
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
01927 }
01928 }
01929 }
01930
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01931
if( inputState->guessing == 0 ) {
01932
reportError(ex);
01933 consume();
01934 consumeUntil(
_tokenSet_23);
01935 }
else {
01936
throw;
01937 }
01938 }
01939
returnAST = subprog_decl_AST;
01940 }
01941
01942 void AdaParser::generic_subp_inst() {
01943
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01944
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01945
RefAdaAST generic_subp_inst_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01946
01947
try {
01948 match(IS);
01949
generic_inst();
01950
if (inputState->guessing==0) {
01951 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01952 }
01953 match(SEMI);
01954 generic_subp_inst_AST = (currentAST.
root);
01955 }
01956
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01957
if( inputState->guessing == 0 ) {
01958
reportError(ex);
01959 consume();
01960 consumeUntil(
_tokenSet_18);
01961 }
else {
01962
throw;
01963 }
01964 }
01965
returnAST = generic_subp_inst_AST;
01966 }
01967
01968 void AdaParser::formal_part_opt() {
01969
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01970
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
01971
RefAdaAST formal_part_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
01972
01973
try {
01974 {
01975
switch ( LA(1)) {
01976
case LPAREN:
01977 {
01978 match(LPAREN);
01979
parameter_specification();
01980
if (inputState->guessing==0) {
01981 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01982 }
01983 {
01984
for (;;) {
01985
if ((LA(1) == SEMI)) {
01986 match(SEMI);
01987
parameter_specification();
01988
if (inputState->guessing==0) {
01989 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
01990 }
01991 }
01992
else {
01993
goto _loop74;
01994 }
01995
01996 }
01997 _loop74:;
01998 }
01999 match(RPAREN);
02000
break;
02001 }
02002
case SEMI:
02003
case IS:
02004
case RENAMES:
02005
case WHEN:
02006
case DO:
02007 {
02008
break;
02009 }
02010
default:
02011 {
02012
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02013 }
02014 }
02015 }
02016
if ( inputState->guessing==0 ) {
02017 formal_part_opt_AST =
RefAdaAST(currentAST.
root);
02018
#line 234 "ada.g"
02019
formal_part_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FORMAL_PART_OPT,
"FORMAL_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(formal_part_opt_AST.get()))));
02020
#line 2021 "AdaParser.cpp"
02021
currentAST.
root = formal_part_opt_AST;
02022
if ( formal_part_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
02023 formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02024 currentAST.
child = formal_part_opt_AST->getFirstChild();
02025
else
02026 currentAST.
child = formal_part_opt_AST;
02027 currentAST.
advanceChildToEnd();
02028 }
02029 formal_part_opt_AST = (currentAST.
root);
02030 }
02031
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02032
if( inputState->guessing == 0 ) {
02033
reportError(ex);
02034 consume();
02035 consumeUntil(
_tokenSet_24);
02036 }
else {
02037
throw;
02038 }
02039 }
02040
returnAST = formal_part_opt_AST;
02041 }
02042
02043 void AdaParser::renames() {
02044
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02045
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02046
RefAdaAST renames_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02047
#line 257 "ada.g"
02048
RefAdaAST dummy;
02049
#line 2050 "AdaParser.cpp"
02050
02051
try {
02052 match(RENAMES);
02053 {
02054
switch ( LA(1)) {
02055
case IDENTIFIER:
02056 {
02057
name();
02058
if (inputState->guessing==0) {
02059 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02060 }
02061
break;
02062 }
02063
case CHAR_STRING:
02064 {
02065 dummy=
definable_operator_symbol();
02066
if (inputState->guessing==0) {
02067 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02068 }
02069
break;
02070 }
02071
default:
02072 {
02073
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02074 }
02075 }
02076 }
02077
if ( inputState->guessing==0 ) {
02078
#line 261 "ada.g"
02079
pop_def_id();
02080
#line 2081 "AdaParser.cpp"
02081
}
02082 renames_AST = (currentAST.
root);
02083 }
02084
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02085
if( inputState->guessing == 0 ) {
02086
reportError(ex);
02087 consume();
02088 consumeUntil(
_tokenSet_4);
02089 }
else {
02090
throw;
02091 }
02092 }
02093
returnAST = renames_AST;
02094 }
02095
02096 void AdaParser::is_separate_or_abstract_or_decl(
02097 RefAdaAST t
02098 ) {
02099
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02100
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02101
RefAdaAST is_separate_or_abstract_or_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02102
02103
try {
02104
switch ( LA(1)) {
02105
case IS:
02106 {
02107 match(IS);
02108
separate_or_abstract(t);
02109
break;
02110 }
02111
case SEMI:
02112 {
02113
if ( inputState->guessing==0 ) {
02114
#line 304 "ada.g"
02115
pop_def_id();
02116
if (t->getType() == AdaTokenTypes::PROCEDURE)
02117
Set(t, PROCEDURE_DECLARATION);
02118
else
02119
Set(t, FUNCTION_DECLARATION);
02120
02121
#line 2122 "AdaParser.cpp"
02122
}
02123
break;
02124 }
02125
default:
02126 {
02127
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02128 }
02129 }
02130 }
02131
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02132
if( inputState->guessing == 0 ) {
02133
reportError(ex);
02134 consume();
02135 consumeUntil(
_tokenSet_4);
02136 }
else {
02137
throw;
02138 }
02139 }
02140
returnAST = is_separate_or_abstract_or_decl_AST;
02141 }
02142
02143 void AdaParser::def_designator(
02144
bool lib_level
02145 ) {
02146
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02147
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02148
RefAdaAST def_designator_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02149
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02150
#line 329 "ada.g"
02151
RefAdaAST d;
02152
#line 2153 "AdaParser.cpp"
02153
02154
try {
02155
if (((LA(1) == IDENTIFIER) && (
_tokenSet_25.member(LA(2))))&&( lib_level )) {
02156
compound_name();
02157
if (inputState->guessing==0) {
02158 n_AST =
returnAST;
02159 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02160 }
02161
if ( inputState->guessing==0 ) {
02162
#line 331 "ada.g"
02163
push_def_id(n_AST);
02164
#line 2165 "AdaParser.cpp"
02165
}
02166 def_designator_AST = (currentAST.
root);
02167 }
02168
else if (((LA(1) == IDENTIFIER || LA(1) == CHAR_STRING) && (LA(2) == LPAREN || LA(2) == IS || LA(2) == RETURN))&&( !lib_level )) {
02169 d=
designator();
02170
if (inputState->guessing==0) {
02171 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02172 }
02173
if ( inputState->guessing==0 ) {
02174
#line 332 "ada.g"
02175
push_def_id(d);
02176
#line 2177 "AdaParser.cpp"
02177
}
02178 def_designator_AST = (currentAST.
root);
02179 }
02180
else {
02181
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02182 }
02183
02184 }
02185
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02186
if( inputState->guessing == 0 ) {
02187
reportError(ex);
02188 consume();
02189 consumeUntil(
_tokenSet_26);
02190 }
else {
02191
throw;
02192 }
02193 }
02194
returnAST = def_designator_AST;
02195 }
02196
02197 void AdaParser::function_tail() {
02198
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02199
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02200
RefAdaAST function_tail_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02201
02202
try {
02203
func_formal_part_opt();
02204
if (inputState->guessing==0) {
02205 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02206 }
02207 match(RETURN);
02208
subtype_mark();
02209
if (inputState->guessing==0) {
02210 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02211 }
02212 function_tail_AST = (currentAST.
root);
02213 }
02214
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02215
if( inputState->guessing == 0 ) {
02216
reportError(ex);
02217 consume();
02218 consumeUntil(
_tokenSet_27);
02219 }
else {
02220
throw;
02221 }
02222 }
02223
returnAST = function_tail_AST;
02224 }
02225
02226 void AdaParser::generic_inst() {
02227
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02228
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02229
RefAdaAST generic_inst_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02230
02231
try {
02232 match(NEW);
02233
compound_name();
02234
if (inputState->guessing==0) {
02235 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02236 }
02237 {
02238
switch ( LA(1)) {
02239
case LPAREN:
02240 {
02241 match(LPAREN);
02242
value_s();
02243
if (inputState->guessing==0) {
02244 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02245 }
02246 match(RPAREN);
02247
break;
02248 }
02249
case SEMI:
02250 {
02251
break;
02252 }
02253
default:
02254 {
02255
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02256 }
02257 }
02258 }
02259
if ( inputState->guessing==0 ) {
02260
#line 179 "ada.g"
02261
pop_def_id();
02262
#line 2263 "AdaParser.cpp"
02263
}
02264 generic_inst_AST = (currentAST.
root);
02265 }
02266
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02267
if( inputState->guessing == 0 ) {
02268
reportError(ex);
02269 consume();
02270 consumeUntil(
_tokenSet_4);
02271 }
else {
02272
throw;
02273 }
02274 }
02275
returnAST = generic_inst_AST;
02276 }
02277
02278 void AdaParser::value_s() {
02279
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02280
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02281
RefAdaAST value_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02282
02283
try {
02284
value();
02285
if (inputState->guessing==0) {
02286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02287 }
02288 {
02289
for (;;) {
02290
if ((LA(1) == COMMA)) {
02291 match(COMMA);
02292
value();
02293
if (inputState->guessing==0) {
02294 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02295 }
02296 }
02297
else {
02298
goto _loop440;
02299 }
02300
02301 }
02302 _loop440:;
02303 }
02304
if ( inputState->guessing==0 ) {
02305 value_s_AST =
RefAdaAST(currentAST.
root);
02306
#line 1380 "ada.g"
02307
value_s_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VALUES,
"VALUES").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(value_s_AST.get()))));
02308
#line 2309 "AdaParser.cpp"
02309
currentAST.
root = value_s_AST;
02310
if ( value_s_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
02311 value_s_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02312 currentAST.
child = value_s_AST->getFirstChild();
02313
else
02314 currentAST.
child = value_s_AST;
02315 currentAST.
advanceChildToEnd();
02316 }
02317 value_s_AST = (currentAST.
root);
02318 }
02319
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02320
if( inputState->guessing == 0 ) {
02321
reportError(ex);
02322 consume();
02323 consumeUntil(
_tokenSet_28);
02324 }
else {
02325
throw;
02326 }
02327 }
02328
returnAST = value_s_AST;
02329 }
02330
02331 void AdaParser::parenth_values() {
02332
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02333
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02334
RefAdaAST parenth_values_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02335
02336
try {
02337 match(LPAREN);
02338
value();
02339
if (inputState->guessing==0) {
02340 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02341 }
02342 {
02343
for (;;) {
02344
if ((LA(1) == COMMA)) {
02345 match(COMMA);
02346
value();
02347
if (inputState->guessing==0) {
02348 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02349 }
02350 }
02351
else {
02352
goto _loop50;
02353 }
02354
02355 }
02356 _loop50:;
02357 }
02358 match(RPAREN);
02359 parenth_values_AST = (currentAST.
root);
02360 }
02361
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02362
if( inputState->guessing == 0 ) {
02363
reportError(ex);
02364 consume();
02365 consumeUntil(
_tokenSet_4);
02366 }
else {
02367
throw;
02368 }
02369 }
02370
returnAST = parenth_values_AST;
02371 }
02372
02373 void AdaParser::value() {
02374
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02375
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02376
RefAdaAST value_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02377
02378
try {
02379 {
02380
switch ( LA(1)) {
02381
case OTHERS:
02382 {
02383
RefAdaAST tmp61_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02384
if ( inputState->guessing == 0 ) {
02385 tmp61_AST = astFactory->create(LT(1));
02386 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp61_AST.get()));
02387 }
02388 match(OTHERS);
02389 match(RIGHT_SHAFT);
02390
expression();
02391
if (inputState->guessing==0) {
02392 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02393 }
02394
break;
02395 }
02396
case IDENTIFIER:
02397
case LPAREN:
02398
case NEW:
02399
case CHARACTER_LITERAL:
02400
case CHAR_STRING:
02401
case NuLL:
02402
case NOT:
02403
case PLUS:
02404
case MINUS:
02405
case ABS:
02406
case NUMERIC_LIT:
02407 {
02408
ranged_expr_s();
02409
if (inputState->guessing==0) {
02410 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02411 }
02412 {
02413
switch ( LA(1)) {
02414
case RIGHT_SHAFT:
02415 {
02416
RefAdaAST tmp63_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02417
if ( inputState->guessing == 0 ) {
02418 tmp63_AST = astFactory->create(LT(1));
02419 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp63_AST.get()));
02420 }
02421 match(RIGHT_SHAFT);
02422
expression();
02423
if (inputState->guessing==0) {
02424 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02425 }
02426
break;
02427 }
02428
case COMMA:
02429
case RPAREN:
02430
case WITH:
02431 {
02432
break;
02433 }
02434
default:
02435 {
02436
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02437 }
02438 }
02439 }
02440
break;
02441 }
02442
default:
02443 {
02444
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02445 }
02446 }
02447 }
02448 value_AST = (currentAST.
root);
02449 }
02450
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02451
if( inputState->guessing == 0 ) {
02452
reportError(ex);
02453 consume();
02454 consumeUntil(
_tokenSet_29);
02455 }
else {
02456
throw;
02457 }
02458 }
02459
returnAST = value_AST;
02460 }
02461
02462 void AdaParser::ranged_expr_s() {
02463
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02464
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02465
RefAdaAST ranged_expr_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02466
02467
try {
02468
ranged_expr();
02469
if (inputState->guessing==0) {
02470 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02471 }
02472 {
02473
for (;;) {
02474
if ((LA(1) == PIPE)) {
02475
RefAdaAST tmp64_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02476
if ( inputState->guessing == 0 ) {
02477 tmp64_AST = astFactory->create(LT(1));
02478 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp64_AST.get()));
02479 }
02480 match(PIPE);
02481
ranged_expr();
02482
if (inputState->guessing==0) {
02483 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02484 }
02485 }
02486
else {
02487
goto _loop56;
02488 }
02489
02490 }
02491 _loop56:;
02492 }
02493 ranged_expr_s_AST = (currentAST.
root);
02494 }
02495
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02496
if( inputState->guessing == 0 ) {
02497
reportError(ex);
02498 consume();
02499 consumeUntil(
_tokenSet_30);
02500 }
else {
02501
throw;
02502 }
02503 }
02504
returnAST = ranged_expr_s_AST;
02505 }
02506
02507 void AdaParser::ranged_expr() {
02508
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02509
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02510
RefAdaAST ranged_expr_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02511
02512
try {
02513
expression();
02514
if (inputState->guessing==0) {
02515 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02516 }
02517 {
02518
switch ( LA(1)) {
02519
case DOT_DOT:
02520 {
02521
RefAdaAST tmp65_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02522
if ( inputState->guessing == 0 ) {
02523 tmp65_AST = astFactory->create(LT(1));
02524 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp65_AST.get()));
02525 }
02526 match(DOT_DOT);
02527
simple_expression();
02528
if (inputState->guessing==0) {
02529 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02530 }
02531
break;
02532 }
02533
case RANGE:
02534 {
02535
RefAdaAST tmp66_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02536
if ( inputState->guessing == 0 ) {
02537 tmp66_AST = astFactory->create(LT(1));
02538 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp66_AST.get()));
02539 }
02540 match(RANGE);
02541
range();
02542
if (inputState->guessing==0) {
02543 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02544 }
02545
break;
02546 }
02547
case COMMA:
02548
case RPAREN:
02549
case RIGHT_SHAFT:
02550
case WITH:
02551
case PIPE:
02552 {
02553
break;
02554 }
02555
default:
02556 {
02557
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02558 }
02559 }
02560 }
02561 ranged_expr_AST = (currentAST.
root);
02562 }
02563
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02564
if( inputState->guessing == 0 ) {
02565
reportError(ex);
02566 consume();
02567 consumeUntil(
_tokenSet_31);
02568 }
else {
02569
throw;
02570 }
02571 }
02572
returnAST = ranged_expr_AST;
02573 }
02574
02575 void AdaParser::simple_expression() {
02576
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02577
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02578
RefAdaAST simple_expression_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02579
02580
try {
02581
signed_term();
02582
if (inputState->guessing==0) {
02583 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02584 }
02585 {
02586
for (;;) {
02587
switch ( LA(1)) {
02588
case PLUS:
02589 {
02590
RefAdaAST tmp67_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02591
if ( inputState->guessing == 0 ) {
02592 tmp67_AST = astFactory->create(LT(1));
02593 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp67_AST.get()));
02594 }
02595 match(PLUS);
02596
signed_term();
02597
if (inputState->guessing==0) {
02598 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02599 }
02600
break;
02601 }
02602
case MINUS:
02603 {
02604
RefAdaAST tmp68_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02605
if ( inputState->guessing == 0 ) {
02606 tmp68_AST = astFactory->create(LT(1));
02607 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp68_AST.get()));
02608 }
02609 match(MINUS);
02610
signed_term();
02611
if (inputState->guessing==0) {
02612 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02613 }
02614
break;
02615 }
02616
case CONCAT:
02617 {
02618
RefAdaAST tmp69_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02619
if ( inputState->guessing == 0 ) {
02620 tmp69_AST = astFactory->create(LT(1));
02621 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp69_AST.get()));
02622 }
02623 match(CONCAT);
02624
signed_term();
02625
if (inputState->guessing==0) {
02626 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02627 }
02628
break;
02629 }
02630
default:
02631 {
02632
goto _loop453;
02633 }
02634 }
02635 }
02636 _loop453:;
02637 }
02638 simple_expression_AST = (currentAST.
root);
02639 }
02640
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02641
if( inputState->guessing == 0 ) {
02642
reportError(ex);
02643 consume();
02644 consumeUntil(
_tokenSet_32);
02645 }
else {
02646
throw;
02647 }
02648 }
02649
returnAST = simple_expression_AST;
02650 }
02651
02652 void AdaParser::range() {
02653
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02654
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02655
RefAdaAST range_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02656
02657
try {
02658 {
02659
bool synPredMatched63 =
false;
02660
if (((
_tokenSet_5.member(LA(1))) && (
_tokenSet_33.member(LA(2))))) {
02661
int _m63 = mark();
02662 synPredMatched63 =
true;
02663 inputState->guessing++;
02664
try {
02665 {
02666
range_dots();
02667 }
02668 }
02669
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
02670 synPredMatched63 =
false;
02671 }
02672 rewind(_m63);
02673 inputState->guessing--;
02674 }
02675
if ( synPredMatched63 ) {
02676
range_dots();
02677
if (inputState->guessing==0) {
02678 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02679 }
02680 }
02681
else if ((LA(1) == IDENTIFIER) && (LA(2) == LPAREN || LA(2) == DOT || LA(2) == TIC)) {
02682
range_attrib_ref();
02683
if (inputState->guessing==0) {
02684 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02685 }
02686 }
02687
else {
02688
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02689 }
02690
02691 }
02692 range_AST = (currentAST.
root);
02693 }
02694
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02695
if( inputState->guessing == 0 ) {
02696
reportError(ex);
02697 consume();
02698 consumeUntil(
_tokenSet_34);
02699 }
else {
02700
throw;
02701 }
02702 }
02703
returnAST = range_AST;
02704 }
02705
02706 void AdaParser::range_constraint() {
02707
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02708
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02709
RefAdaAST range_constraint_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02710
02711
try {
02712 match(RANGE);
02713
range();
02714
if (inputState->guessing==0) {
02715 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02716 }
02717 range_constraint_AST = (currentAST.
root);
02718 }
02719
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02720
if( inputState->guessing == 0 ) {
02721
reportError(ex);
02722 consume();
02723 consumeUntil(
_tokenSet_35);
02724 }
else {
02725
throw;
02726 }
02727 }
02728
returnAST = range_constraint_AST;
02729 }
02730
02731 void AdaParser::range_dots() {
02732
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02733
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02734
RefAdaAST range_dots_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02735
02736
try {
02737
simple_expression();
02738
if (inputState->guessing==0) {
02739 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02740 }
02741
RefAdaAST tmp71_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02742
if ( inputState->guessing == 0 ) {
02743 tmp71_AST = astFactory->create(LT(1));
02744 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp71_AST.get()));
02745 }
02746 match(DOT_DOT);
02747
simple_expression();
02748
if (inputState->guessing==0) {
02749 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02750 }
02751 range_dots_AST = (currentAST.
root);
02752 }
02753
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02754
if( inputState->guessing == 0 ) {
02755
reportError(ex);
02756 consume();
02757 consumeUntil(
_tokenSet_34);
02758 }
else {
02759
throw;
02760 }
02761 }
02762
returnAST = range_dots_AST;
02763 }
02764
02765 void AdaParser::range_attrib_ref() {
02766
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02767
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02768
RefAdaAST range_attrib_ref_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02769
ANTLR_USE_NAMESPACE(antlr)
RefToken r =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02770
RefAdaAST r_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02771
02772
try {
02773
prefix();
02774
if (inputState->guessing==0) {
02775 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02776 }
02777 match(TIC);
02778 r = LT(1);
02779
if ( inputState->guessing == 0 ) {
02780 r_AST = astFactory->create(r);
02781 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
02782 }
02783 match(RANGE);
02784 {
02785
switch ( LA(1)) {
02786
case LPAREN:
02787 {
02788 match(LPAREN);
02789
expression();
02790
if (inputState->guessing==0) {
02791 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02792 }
02793 match(RPAREN);
02794
break;
02795 }
02796
case SEMI:
02797
case COMMA:
02798
case RPAREN:
02799
case RIGHT_SHAFT:
02800
case WITH:
02801
case RANGE:
02802
case DIGITS:
02803
case IS:
02804
case PIPE:
02805
case DOT_DOT:
02806
case ASSIGN:
02807
case THEN:
02808
case LOOP:
02809
case OR:
02810
case AND:
02811
case XOR:
02812 {
02813
break;
02814 }
02815
default:
02816 {
02817
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02818 }
02819 }
02820 }
02821
if ( inputState->guessing==0 ) {
02822
#line 218 "ada.g"
02823
Set(r_AST, RANGE_ATTRIBUTE_REFERENCE);
02824
#line 2825 "AdaParser.cpp"
02825
}
02826 range_attrib_ref_AST = (currentAST.
root);
02827 }
02828
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02829
if( inputState->guessing == 0 ) {
02830
reportError(ex);
02831 consume();
02832 consumeUntil(
_tokenSet_34);
02833 }
else {
02834
throw;
02835 }
02836 }
02837
returnAST = range_attrib_ref_AST;
02838 }
02839
02840 void AdaParser::prefix() {
02841
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02842
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02843
RefAdaAST prefix_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02844
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
02845
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02846
02847
try {
02848
RefAdaAST tmp75_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02849
if ( inputState->guessing == 0 ) {
02850 tmp75_AST = astFactory->create(LT(1));
02851 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp75_AST.get()));
02852 }
02853 match(IDENTIFIER);
02854 {
02855
for (;;) {
02856
switch ( LA(1)) {
02857
case DOT:
02858 {
02859
RefAdaAST tmp76_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02860
if ( inputState->guessing == 0 ) {
02861 tmp76_AST = astFactory->create(LT(1));
02862 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp76_AST.get()));
02863 }
02864 match(DOT);
02865 {
02866
switch ( LA(1)) {
02867
case ALL:
02868 {
02869
RefAdaAST tmp77_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02870
if ( inputState->guessing == 0 ) {
02871 tmp77_AST = astFactory->create(LT(1));
02872 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp77_AST.get()));
02873 }
02874 match(ALL);
02875
break;
02876 }
02877
case IDENTIFIER:
02878 {
02879
RefAdaAST tmp78_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02880
if ( inputState->guessing == 0 ) {
02881 tmp78_AST = astFactory->create(LT(1));
02882 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp78_AST.get()));
02883 }
02884 match(IDENTIFIER);
02885
break;
02886 }
02887
default:
02888 {
02889
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
02890 }
02891 }
02892 }
02893
break;
02894 }
02895
case LPAREN:
02896 {
02897 p = LT(1);
02898
if ( inputState->guessing == 0 ) {
02899 p_AST = astFactory->create(p);
02900 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
02901 }
02902 match(LPAREN);
02903
value_s();
02904
if (inputState->guessing==0) {
02905 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02906 }
02907 match(RPAREN);
02908
if ( inputState->guessing==0 ) {
02909
#line 227 "ada.g"
02910
Set(p_AST, INDEXED_COMPONENT);
02911
#line 2912 "AdaParser.cpp"
02912
}
02913
break;
02914 }
02915
default:
02916 {
02917
goto _loop70;
02918 }
02919 }
02920 }
02921 _loop70:;
02922 }
02923 prefix_AST = (currentAST.
root);
02924 }
02925
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02926
if( inputState->guessing == 0 ) {
02927
reportError(ex);
02928 consume();
02929 consumeUntil(
_tokenSet_36);
02930 }
else {
02931
throw;
02932 }
02933 }
02934
returnAST = prefix_AST;
02935 }
02936
02937 void AdaParser::parameter_specification() {
02938
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02939
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02940
RefAdaAST parameter_specification_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02941
02942
try {
02943
def_ids_colon();
02944
if (inputState->guessing==0) {
02945 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02946 }
02947
mode_opt();
02948
if (inputState->guessing==0) {
02949 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02950 }
02951
subtype_mark();
02952
if (inputState->guessing==0) {
02953 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02954 }
02955
init_opt();
02956
if (inputState->guessing==0) {
02957 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02958 }
02959
if ( inputState->guessing==0 ) {
02960 parameter_specification_AST =
RefAdaAST(currentAST.
root);
02961
#line 239 "ada.g"
02962
parameter_specification_AST =
02963
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_SPECIFICATION,
"PARAMETER_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(parameter_specification_AST.get()))));
02964
#line 2965 "AdaParser.cpp"
02965
currentAST.
root = parameter_specification_AST;
02966
if ( parameter_specification_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
02967 parameter_specification_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
02968 currentAST.
child = parameter_specification_AST->getFirstChild();
02969
else
02970 currentAST.
child = parameter_specification_AST;
02971 currentAST.
advanceChildToEnd();
02972 }
02973 parameter_specification_AST = (currentAST.
root);
02974 }
02975
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02976
if( inputState->guessing == 0 ) {
02977
reportError(ex);
02978 consume();
02979 consumeUntil(
_tokenSet_37);
02980 }
else {
02981
throw;
02982 }
02983 }
02984
returnAST = parameter_specification_AST;
02985 }
02986
02987 void AdaParser::def_ids_colon() {
02988
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02989
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
02990
RefAdaAST def_ids_colon_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
02991
02992
try {
02993
defining_identifier_list();
02994
if (inputState->guessing==0) {
02995 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
02996 }
02997 match(COLON);
02998 def_ids_colon_AST = (currentAST.
root);
02999 }
03000
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03001
if( inputState->guessing == 0 ) {
03002
reportError(ex);
03003 consume();
03004 consumeUntil(
_tokenSet_38);
03005 }
else {
03006
throw;
03007 }
03008 }
03009
returnAST = def_ids_colon_AST;
03010 }
03011
03012 void AdaParser::mode_opt() {
03013
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03014
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03015
RefAdaAST mode_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03016
03017
try {
03018 {
03019
switch ( LA(1)) {
03020
case IN:
03021 {
03022
RefAdaAST tmp81_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03023
if ( inputState->guessing == 0 ) {
03024 tmp81_AST = astFactory->create(LT(1));
03025 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp81_AST.get()));
03026 }
03027 match(IN);
03028 {
03029
switch ( LA(1)) {
03030
case OUT:
03031 {
03032
RefAdaAST tmp82_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03033
if ( inputState->guessing == 0 ) {
03034 tmp82_AST = astFactory->create(LT(1));
03035 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp82_AST.get()));
03036 }
03037 match(OUT);
03038
break;
03039 }
03040
case IDENTIFIER:
03041 {
03042
break;
03043 }
03044
default:
03045 {
03046
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03047 }
03048 }
03049 }
03050
break;
03051 }
03052
case OUT:
03053 {
03054
RefAdaAST tmp83_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03055
if ( inputState->guessing == 0 ) {
03056 tmp83_AST = astFactory->create(LT(1));
03057 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp83_AST.get()));
03058 }
03059 match(OUT);
03060
break;
03061 }
03062
case ACCESS:
03063 {
03064
RefAdaAST tmp84_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03065
if ( inputState->guessing == 0 ) {
03066 tmp84_AST = astFactory->create(LT(1));
03067 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp84_AST.get()));
03068 }
03069 match(ACCESS);
03070
break;
03071 }
03072
case IDENTIFIER:
03073 {
03074
break;
03075 }
03076
default:
03077 {
03078
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03079 }
03080 }
03081 }
03082
if ( inputState->guessing==0 ) {
03083 mode_opt_AST =
RefAdaAST(currentAST.
root);
03084
#line 254 "ada.g"
03085
mode_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mode_opt_AST.get()))));
03086
#line 3087 "AdaParser.cpp"
03087
currentAST.
root = mode_opt_AST;
03088
if ( mode_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03089 mode_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03090 currentAST.
child = mode_opt_AST->getFirstChild();
03091
else
03092 currentAST.
child = mode_opt_AST;
03093 currentAST.
advanceChildToEnd();
03094 }
03095 mode_opt_AST = (currentAST.
root);
03096 }
03097
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03098
if( inputState->guessing == 0 ) {
03099
reportError(ex);
03100 consume();
03101 consumeUntil(
_tokenSet_39);
03102 }
else {
03103
throw;
03104 }
03105 }
03106
returnAST = mode_opt_AST;
03107 }
03108
03109 void AdaParser::init_opt() {
03110
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03111
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03112
RefAdaAST init_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03113
03114
try {
03115 {
03116
switch ( LA(1)) {
03117
case ASSIGN:
03118 {
03119 match(ASSIGN);
03120
expression();
03121
if (inputState->guessing==0) {
03122 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03123 }
03124
break;
03125 }
03126
case SEMI:
03127
case RPAREN:
03128 {
03129
break;
03130 }
03131
default:
03132 {
03133
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03134 }
03135 }
03136 }
03137
if ( inputState->guessing==0 ) {
03138 init_opt_AST =
RefAdaAST(currentAST.
root);
03139
#line 460 "ada.g"
03140
init_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(INIT_OPT,
"INIT_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(init_opt_AST.get()))));
03141
#line 3142 "AdaParser.cpp"
03142
currentAST.
root = init_opt_AST;
03143
if ( init_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03144 init_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03145 currentAST.
child = init_opt_AST->getFirstChild();
03146
else
03147 currentAST.
child = init_opt_AST;
03148 currentAST.
advanceChildToEnd();
03149 }
03150 init_opt_AST = (currentAST.
root);
03151 }
03152
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03153
if( inputState->guessing == 0 ) {
03154
reportError(ex);
03155 consume();
03156 consumeUntil(
_tokenSet_37);
03157 }
else {
03158
throw;
03159 }
03160 }
03161
returnAST = init_opt_AST;
03162 }
03163
03164 void AdaParser::defining_identifier_list() {
03165
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03166
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03167
RefAdaAST defining_identifier_list_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03168
03169
try {
03170
RefAdaAST tmp86_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03171
if ( inputState->guessing == 0 ) {
03172 tmp86_AST = astFactory->create(LT(1));
03173 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp86_AST.get()));
03174 }
03175 match(IDENTIFIER);
03176 {
03177
for (;;) {
03178
if ((LA(1) == COMMA)) {
03179 match(COMMA);
03180
RefAdaAST tmp88_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03181
if ( inputState->guessing == 0 ) {
03182 tmp88_AST = astFactory->create(LT(1));
03183 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp88_AST.get()));
03184 }
03185 match(IDENTIFIER);
03186 }
03187
else {
03188
goto _loop79;
03189 }
03190
03191 }
03192 _loop79:;
03193 }
03194
if ( inputState->guessing==0 ) {
03195 defining_identifier_list_AST =
RefAdaAST(currentAST.
root);
03196
#line 248 "ada.g"
03197
defining_identifier_list_AST =
03198
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DEFINING_IDENTIFIER_LIST,
"DEFINING_IDENTIFIER_LIST").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(defining_identifier_list_AST.get()))));
03199
#line 3200 "AdaParser.cpp"
03200
currentAST.
root = defining_identifier_list_AST;
03201
if ( defining_identifier_list_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03202 defining_identifier_list_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03203 currentAST.
child = defining_identifier_list_AST->getFirstChild();
03204
else
03205 currentAST.
child = defining_identifier_list_AST;
03206 currentAST.
advanceChildToEnd();
03207 }
03208 defining_identifier_list_AST = (currentAST.
root);
03209 }
03210
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03211
if( inputState->guessing == 0 ) {
03212
reportError(ex);
03213 consume();
03214 consumeUntil(
_tokenSet_40);
03215 }
else {
03216
throw;
03217 }
03218 }
03219
returnAST = defining_identifier_list_AST;
03220 }
03221
03222 void AdaParser::name() {
03223
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03224
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03225
RefAdaAST name_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03226
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03227
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03228
#line 264 "ada.g"
03229
RefAdaAST dummy;
03230
#line 3231 "AdaParser.cpp"
03231
03232
try {
03233
RefAdaAST tmp89_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03234
if ( inputState->guessing == 0 ) {
03235 tmp89_AST = astFactory->create(LT(1));
03236 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp89_AST.get()));
03237 }
03238 match(IDENTIFIER);
03239 {
03240
for (;;) {
03241
switch ( LA(1)) {
03242
case DOT:
03243 {
03244
RefAdaAST tmp90_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03245
if ( inputState->guessing == 0 ) {
03246 tmp90_AST = astFactory->create(LT(1));
03247 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp90_AST.get()));
03248 }
03249 match(DOT);
03250 {
03251
switch ( LA(1)) {
03252
case ALL:
03253 {
03254
RefAdaAST tmp91_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03255
if ( inputState->guessing == 0 ) {
03256 tmp91_AST = astFactory->create(LT(1));
03257 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp91_AST.get()));
03258 }
03259 match(ALL);
03260
break;
03261 }
03262
case IDENTIFIER:
03263 {
03264
RefAdaAST tmp92_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03265
if ( inputState->guessing == 0 ) {
03266 tmp92_AST = astFactory->create(LT(1));
03267 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp92_AST.get()));
03268 }
03269 match(IDENTIFIER);
03270
break;
03271 }
03272
case CHARACTER_LITERAL:
03273 {
03274
RefAdaAST tmp93_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03275
if ( inputState->guessing == 0 ) {
03276 tmp93_AST = astFactory->create(LT(1));
03277 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp93_AST.get()));
03278 }
03279 match(CHARACTER_LITERAL);
03280
break;
03281 }
03282
case CHAR_STRING:
03283 {
03284 dummy=
is_operator();
03285
if (inputState->guessing==0) {
03286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03287 }
03288
break;
03289 }
03290
default:
03291 {
03292
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03293 }
03294 }
03295 }
03296
break;
03297 }
03298
case LPAREN:
03299 {
03300 p = LT(1);
03301
if ( inputState->guessing == 0 ) {
03302 p_AST = astFactory->create(p);
03303 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
03304 }
03305 match(LPAREN);
03306
value_s();
03307
if (inputState->guessing==0) {
03308 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03309 }
03310 match(RPAREN);
03311
if ( inputState->guessing==0 ) {
03312
#line 272 "ada.g"
03313
Set(p_AST, INDEXED_COMPONENT);
03314
#line 3315 "AdaParser.cpp"
03315
}
03316
break;
03317 }
03318
case TIC:
03319 {
03320
RefAdaAST tmp95_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03321
if ( inputState->guessing == 0 ) {
03322 tmp95_AST = astFactory->create(LT(1));
03323 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp95_AST.get()));
03324 }
03325 match(TIC);
03326
attribute_id();
03327
if (inputState->guessing==0) {
03328 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03329 }
03330
break;
03331 }
03332
default:
03333 {
03334
goto _loop88;
03335 }
03336 }
03337 }
03338 _loop88:;
03339 }
03340 name_AST = (currentAST.
root);
03341 }
03342
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03343
if( inputState->guessing == 0 ) {
03344
reportError(ex);
03345 consume();
03346 consumeUntil(
_tokenSet_41);
03347 }
else {
03348
throw;
03349 }
03350 }
03351
returnAST = name_AST;
03352 }
03353
03354 RefAdaAST AdaParser::definable_operator_symbol() {
03355
#line 284 "ada.g"
03356
RefAdaAST d;
03357
#line 3358 "AdaParser.cpp"
03358
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03359
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03360
RefAdaAST definable_operator_symbol_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03361
ANTLR_USE_NAMESPACE(antlr)
RefToken op =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03362
RefAdaAST op_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03363
03364
try {
03365
if (!(
definable_operator(LT(1)->getText().c_str()) ))
03366
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" definable_operator(LT(1)->getText().c_str()) ");
03367 op = LT(1);
03368
if ( inputState->guessing == 0 ) {
03369 op_AST = astFactory->create(op);
03370 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(op_AST.get()));
03371 }
03372 match(CHAR_STRING);
03373
if ( inputState->guessing==0 ) {
03374
#line 286 "ada.g"
03375
op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
03376
#line 3377 "AdaParser.cpp"
03377
}
03378 definable_operator_symbol_AST = (currentAST.
root);
03379 }
03380
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03381
if( inputState->guessing == 0 ) {
03382
reportError(ex);
03383 consume();
03384 consumeUntil(
_tokenSet_42);
03385 }
else {
03386
throw;
03387 }
03388 }
03389
returnAST = definable_operator_symbol_AST;
03390
return d;
03391 }
03392
03393 RefAdaAST AdaParser::is_operator() {
03394
#line 279 "ada.g"
03395
RefAdaAST d;
03396
#line 3397 "AdaParser.cpp"
03397
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03398
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03399
RefAdaAST is_operator_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03400
ANTLR_USE_NAMESPACE(antlr)
RefToken op =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03401
RefAdaAST op_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03402
03403
try {
03404
if (!(
is_operator_symbol(LT(1)->getText().c_str()) ))
03405
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" is_operator_symbol(LT(1)->getText().c_str()) ");
03406 op = LT(1);
03407
if ( inputState->guessing == 0 ) {
03408 op_AST = astFactory->create(op);
03409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(op_AST.get()));
03410 }
03411 match(CHAR_STRING);
03412
if ( inputState->guessing==0 ) {
03413
#line 281 "ada.g"
03414
op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
03415
#line 3416 "AdaParser.cpp"
03416
}
03417 is_operator_AST = (currentAST.
root);
03418 }
03419
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03420
if( inputState->guessing == 0 ) {
03421
reportError(ex);
03422 consume();
03423 consumeUntil(
_tokenSet_43);
03424 }
else {
03425
throw;
03426 }
03427 }
03428
returnAST = is_operator_AST;
03429
return d;
03430 }
03431
03432 void AdaParser::parenthesized_primary() {
03433
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03434
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03435
RefAdaAST parenthesized_primary_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03436
ANTLR_USE_NAMESPACE(antlr)
RefToken pp =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03437
RefAdaAST pp_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03438
03439
try {
03440 pp = LT(1);
03441
if ( inputState->guessing == 0 ) {
03442 pp_AST = astFactory->create(pp);
03443 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pp_AST.get()));
03444 }
03445 match(LPAREN);
03446 {
03447
if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
03448
RefAdaAST tmp96_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03449
if ( inputState->guessing == 0 ) {
03450 tmp96_AST = astFactory->create(LT(1));
03451 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp96_AST.get()));
03452 }
03453 match(NuLL);
03454 match(RECORD);
03455 }
03456
else if ((
_tokenSet_44.member(LA(1))) && (
_tokenSet_45.member(LA(2)))) {
03457
value_s();
03458
if (inputState->guessing==0) {
03459 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03460 }
03461
extension_opt();
03462
if (inputState->guessing==0) {
03463 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03464 }
03465 }
03466
else {
03467
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03468 }
03469
03470 }
03471 match(RPAREN);
03472
if ( inputState->guessing==0 ) {
03473
#line 294 "ada.g"
03474
Set(pp_AST, PARENTHESIZED_PRIMARY);
03475
#line 3476 "AdaParser.cpp"
03476
}
03477 parenthesized_primary_AST = (currentAST.
root);
03478 }
03479
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03480
if( inputState->guessing == 0 ) {
03481
reportError(ex);
03482 consume();
03483 consumeUntil(
_tokenSet_43);
03484 }
else {
03485
throw;
03486 }
03487 }
03488
returnAST = parenthesized_primary_AST;
03489 }
03490
03491 void AdaParser::extension_opt() {
03492
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03493
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03494
RefAdaAST extension_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03495
03496
try {
03497 {
03498
switch ( LA(1)) {
03499
case WITH:
03500 {
03501 match(WITH);
03502 {
03503
if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
03504
RefAdaAST tmp100_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03505
if ( inputState->guessing == 0 ) {
03506 tmp100_AST = astFactory->create(LT(1));
03507 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp100_AST.get()));
03508 }
03509 match(NuLL);
03510 match(RECORD);
03511 }
03512
else if ((
_tokenSet_44.member(LA(1))) && (
_tokenSet_46.member(LA(2)))) {
03513
value_s();
03514
if (inputState->guessing==0) {
03515 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03516 }
03517 }
03518
else {
03519
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03520 }
03521
03522 }
03523
break;
03524 }
03525
case RPAREN:
03526 {
03527
break;
03528 }
03529
default:
03530 {
03531
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03532 }
03533 }
03534 }
03535
if ( inputState->guessing==0 ) {
03536 extension_opt_AST =
RefAdaAST(currentAST.
root);
03537
#line 298 "ada.g"
03538
extension_opt_AST =
03539
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXTENSION_OPT,
"EXTENSION_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(extension_opt_AST.get()))));
03540
#line 3541 "AdaParser.cpp"
03541
currentAST.
root = extension_opt_AST;
03542
if ( extension_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03543 extension_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03544 currentAST.
child = extension_opt_AST->getFirstChild();
03545
else
03546 currentAST.
child = extension_opt_AST;
03547 currentAST.
advanceChildToEnd();
03548 }
03549 extension_opt_AST = (currentAST.
root);
03550 }
03551
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03552
if( inputState->guessing == 0 ) {
03553
reportError(ex);
03554 consume();
03555 consumeUntil(
_tokenSet_47);
03556 }
else {
03557
throw;
03558 }
03559 }
03560
returnAST = extension_opt_AST;
03561 }
03562
03563 void AdaParser::separate_or_abstract(
03564 RefAdaAST t
03565 ) {
03566
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03567
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03568
RefAdaAST separate_or_abstract_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03569
03570
try {
03571
switch ( LA(1)) {
03572
case SEPARATE:
03573 {
03574 match(SEPARATE);
03575
if ( inputState->guessing==0 ) {
03576
#line 314 "ada.g"
03577
pop_def_id();
03578
if (t->getType() == AdaTokenTypes::PROCEDURE)
03579
Set(t, PROCEDURE_BODY_STUB);
03580
else
03581
Set(t, FUNCTION_BODY_STUB);
03582
03583
#line 3584 "AdaParser.cpp"
03584
}
03585
break;
03586 }
03587
case ABSTRACT:
03588 {
03589 match(ABSTRACT);
03590
if ( inputState->guessing==0 ) {
03591
#line 321 "ada.g"
03592
pop_def_id();
03593
if (t->getType() == AdaTokenTypes::PROCEDURE)
03594
Set(t, ABSTRACT_PROCEDURE_DECLARATION);
03595
else
03596
Set(t, ABSTRACT_FUNCTION_DECLARATION);
03597
03598
#line 3599 "AdaParser.cpp"
03599
}
03600
break;
03601 }
03602
default:
03603 {
03604
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03605 }
03606 }
03607 }
03608
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03609
if( inputState->guessing == 0 ) {
03610
reportError(ex);
03611 consume();
03612 consumeUntil(
_tokenSet_4);
03613 }
else {
03614
throw;
03615 }
03616 }
03617
returnAST = separate_or_abstract_AST;
03618 }
03619
03620 RefAdaAST AdaParser::designator() {
03621
#line 335 "ada.g"
03622
RefAdaAST d;
03623
#line 3624 "AdaParser.cpp"
03624
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03625
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03626
RefAdaAST designator_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03627
ANTLR_USE_NAMESPACE(antlr)
RefToken n =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03628
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03629
#line 335 "ada.g"
03630
RefAdaAST op;
03631
#line 3632 "AdaParser.cpp"
03632
03633
try {
03634
switch ( LA(1)) {
03635
case CHAR_STRING:
03636 {
03637 op=
definable_operator_symbol();
03638
if (inputState->guessing==0) {
03639 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03640 }
03641
if ( inputState->guessing==0 ) {
03642
#line 337 "ada.g"
03643
d = op;
03644
#line 3645 "AdaParser.cpp"
03645
}
03646 designator_AST = (currentAST.
root);
03647
break;
03648 }
03649
case IDENTIFIER:
03650 {
03651 n = LT(1);
03652
if ( inputState->guessing == 0 ) {
03653 n_AST = astFactory->create(n);
03654 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
03655 }
03656 match(IDENTIFIER);
03657
if ( inputState->guessing==0 ) {
03658
#line 338 "ada.g"
03659
d = n_AST;
03660
#line 3661 "AdaParser.cpp"
03661
}
03662 designator_AST = (currentAST.
root);
03663
break;
03664 }
03665
default:
03666 {
03667
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03668 }
03669 }
03670 }
03671
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03672
if( inputState->guessing == 0 ) {
03673
reportError(ex);
03674 consume();
03675 consumeUntil(
_tokenSet_26);
03676 }
else {
03677
throw;
03678 }
03679 }
03680
returnAST = designator_AST;
03681
return d;
03682 }
03683
03684 void AdaParser::func_formal_part_opt() {
03685
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03686
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03687
RefAdaAST func_formal_part_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03688
03689
try {
03690 {
03691
switch ( LA(1)) {
03692
case LPAREN:
03693 {
03694 match(LPAREN);
03695
func_param();
03696
if (inputState->guessing==0) {
03697 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03698 }
03699 {
03700
for (;;) {
03701
if ((LA(1) == SEMI)) {
03702 match(SEMI);
03703
func_param();
03704
if (inputState->guessing==0) {
03705 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03706 }
03707 }
03708
else {
03709
goto _loop104;
03710 }
03711
03712 }
03713 _loop104:;
03714 }
03715 match(RPAREN);
03716
break;
03717 }
03718
case RETURN:
03719 {
03720
break;
03721 }
03722
default:
03723 {
03724
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03725 }
03726 }
03727 }
03728
if ( inputState->guessing==0 ) {
03729 func_formal_part_opt_AST =
RefAdaAST(currentAST.
root);
03730
#line 347 "ada.g"
03731
func_formal_part_opt_AST =
03732
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FORMAL_PART_OPT,
"FORMAL_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(func_formal_part_opt_AST.get()))));
03733
#line 3734 "AdaParser.cpp"
03734
currentAST.
root = func_formal_part_opt_AST;
03735
if ( func_formal_part_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03736 func_formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03737 currentAST.
child = func_formal_part_opt_AST->getFirstChild();
03738
else
03739 currentAST.
child = func_formal_part_opt_AST;
03740 currentAST.
advanceChildToEnd();
03741 }
03742 func_formal_part_opt_AST = (currentAST.
root);
03743 }
03744
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03745
if( inputState->guessing == 0 ) {
03746
reportError(ex);
03747 consume();
03748 consumeUntil(
_tokenSet_48);
03749 }
else {
03750
throw;
03751 }
03752 }
03753
returnAST = func_formal_part_opt_AST;
03754 }
03755
03756 void AdaParser::func_param() {
03757
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03758
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03759
RefAdaAST func_param_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03760
03761
try {
03762
def_ids_colon();
03763
if (inputState->guessing==0) {
03764 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03765 }
03766
in_access_opt();
03767
if (inputState->guessing==0) {
03768 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03769 }
03770
subtype_mark();
03771
if (inputState->guessing==0) {
03772 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03773 }
03774
init_opt();
03775
if (inputState->guessing==0) {
03776 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03777 }
03778
if ( inputState->guessing==0 ) {
03779 func_param_AST =
RefAdaAST(currentAST.
root);
03780
#line 353 "ada.g"
03781
func_param_AST =
03782
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_SPECIFICATION,
"PARAMETER_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(func_param_AST.get()))));
03783
#line 3784 "AdaParser.cpp"
03784
currentAST.
root = func_param_AST;
03785
if ( func_param_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03786 func_param_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03787 currentAST.
child = func_param_AST->getFirstChild();
03788
else
03789 currentAST.
child = func_param_AST;
03790 currentAST.
advanceChildToEnd();
03791 }
03792 func_param_AST = (currentAST.
root);
03793 }
03794
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03795
if( inputState->guessing == 0 ) {
03796
reportError(ex);
03797 consume();
03798 consumeUntil(
_tokenSet_37);
03799 }
else {
03800
throw;
03801 }
03802 }
03803
returnAST = func_param_AST;
03804 }
03805
03806 void AdaParser::in_access_opt() {
03807
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03808
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03809
RefAdaAST in_access_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03810
03811
try {
03812 {
03813
switch ( LA(1)) {
03814
case IN:
03815 {
03816 match(IN);
03817
break;
03818 }
03819
case ACCESS:
03820 {
03821
RefAdaAST tmp108_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03822
if ( inputState->guessing == 0 ) {
03823 tmp108_AST = astFactory->create(LT(1));
03824 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp108_AST.get()));
03825 }
03826 match(ACCESS);
03827
break;
03828 }
03829
case IDENTIFIER:
03830 {
03831
break;
03832 }
03833
default:
03834 {
03835
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03836 }
03837 }
03838 }
03839
if ( inputState->guessing==0 ) {
03840 in_access_opt_AST =
RefAdaAST(currentAST.
root);
03841
#line 359 "ada.g"
03842
in_access_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(in_access_opt_AST.get()))));
03843
#line 3844 "AdaParser.cpp"
03844
currentAST.
root = in_access_opt_AST;
03845
if ( in_access_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03846 in_access_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03847 currentAST.
child = in_access_opt_AST->getFirstChild();
03848
else
03849 currentAST.
child = in_access_opt_AST;
03850 currentAST.
advanceChildToEnd();
03851 }
03852 in_access_opt_AST = (currentAST.
root);
03853 }
03854
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03855
if( inputState->guessing == 0 ) {
03856
reportError(ex);
03857 consume();
03858 consumeUntil(
_tokenSet_39);
03859 }
else {
03860
throw;
03861 }
03862 }
03863
returnAST = in_access_opt_AST;
03864 }
03865
03866 void AdaParser::pkg_spec_part() {
03867
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03868
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03869
RefAdaAST pkg_spec_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03870
03871
try {
03872
basic_declarative_items_opt();
03873
if (inputState->guessing==0) {
03874 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03875 }
03876 {
03877
switch ( LA(1)) {
03878
case PRIVATE:
03879 {
03880 match(PRIVATE);
03881
basic_declarative_items_opt();
03882
if (inputState->guessing==0) {
03883 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03884 }
03885
break;
03886 }
03887
case END:
03888 {
03889
break;
03890 }
03891
default:
03892 {
03893
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
03894 }
03895 }
03896 }
03897
end_id_opt();
03898 pkg_spec_part_AST = (currentAST.
root);
03899 }
03900
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03901
if( inputState->guessing == 0 ) {
03902
reportError(ex);
03903 consume();
03904 consumeUntil(
_tokenSet_4);
03905 }
else {
03906
throw;
03907 }
03908 }
03909
returnAST = pkg_spec_part_AST;
03910 }
03911
03912 void AdaParser::basic_declarative_items_opt() {
03913
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03914
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03915
RefAdaAST basic_declarative_items_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03916
03917
try {
03918 {
03919
for (;;) {
03920
switch ( LA(1)) {
03921
case IDENTIFIER:
03922
case USE:
03923
case TYPE:
03924
case PACKAGE:
03925
case PROCEDURE:
03926
case FUNCTION:
03927
case TASK:
03928
case PROTECTED:
03929
case FOR:
03930
case SUBTYPE:
03931
case GENERIC:
03932 {
03933
basic_decl_item();
03934
if (inputState->guessing==0) {
03935 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03936 }
03937
break;
03938 }
03939
case PRAGMA:
03940 {
03941
pragma();
03942
if (inputState->guessing==0) {
03943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
03944 }
03945
break;
03946 }
03947
default:
03948 {
03949
goto _loop115;
03950 }
03951 }
03952 }
03953 _loop115:;
03954 }
03955
if ( inputState->guessing==0 ) {
03956 basic_declarative_items_opt_AST =
RefAdaAST(currentAST.
root);
03957
#line 377 "ada.g"
03958
basic_declarative_items_opt_AST =
03959
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,
"BASIC_DECLARATIVE_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(basic_declarative_items_opt_AST.get()))));
03960
#line 3961 "AdaParser.cpp"
03961
currentAST.
root = basic_declarative_items_opt_AST;
03962
if ( basic_declarative_items_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
03963 basic_declarative_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
03964 currentAST.
child = basic_declarative_items_opt_AST->getFirstChild();
03965
else
03966 currentAST.
child = basic_declarative_items_opt_AST;
03967 currentAST.
advanceChildToEnd();
03968 }
03969 basic_declarative_items_opt_AST = (currentAST.
root);
03970 }
03971
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03972
if( inputState->guessing == 0 ) {
03973
reportError(ex);
03974 consume();
03975 consumeUntil(
_tokenSet_49);
03976 }
else {
03977
throw;
03978 }
03979 }
03980
returnAST = basic_declarative_items_opt_AST;
03981 }
03982
03983 void AdaParser::basic_decl_item() {
03984
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03985
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
03986
RefAdaAST basic_decl_item_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03987
ANTLR_USE_NAMESPACE(antlr)
RefToken pkg =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03988
RefAdaAST pkg_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03989
ANTLR_USE_NAMESPACE(antlr)
RefToken tsk =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03990
RefAdaAST tsk_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03991
ANTLR_USE_NAMESPACE(antlr)
RefToken pro =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
03992
RefAdaAST pro_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
03993
03994
try {
03995
switch ( LA(1)) {
03996
case PACKAGE:
03997 {
03998 pkg = LT(1);
03999
if ( inputState->guessing == 0 ) {
04000 pkg_AST = astFactory->create(pkg);
04001 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get()));
04002 }
04003 match(PACKAGE);
04004
def_id(
false);
04005
if (inputState->guessing==0) {
04006 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04007 }
04008
spec_decl_part(pkg_AST);
04009
if (inputState->guessing==0) {
04010 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04011 }
04012 basic_decl_item_AST = (currentAST.
root);
04013
break;
04014 }
04015
case TASK:
04016 {
04017 tsk = LT(1);
04018
if ( inputState->guessing == 0 ) {
04019 tsk_AST = astFactory->create(tsk);
04020 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tsk_AST.get()));
04021 }
04022 match(TASK);
04023
task_type_or_single_decl(tsk_AST);
04024
if (inputState->guessing==0) {
04025 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04026 }
04027 basic_decl_item_AST = (currentAST.
root);
04028
break;
04029 }
04030
case PROTECTED:
04031 {
04032 pro = LT(1);
04033
if ( inputState->guessing == 0 ) {
04034 pro_AST = astFactory->create(pro);
04035 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pro_AST.get()));
04036 }
04037 match(PROTECTED);
04038
prot_type_or_single_decl(pro_AST);
04039
if (inputState->guessing==0) {
04040 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04041 }
04042 match(SEMI);
04043 basic_decl_item_AST = (currentAST.
root);
04044
break;
04045 }
04046
case PROCEDURE:
04047
case FUNCTION:
04048 {
04049
subprog_decl(
false);
04050
if (inputState->guessing==0) {
04051 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04052 }
04053 basic_decl_item_AST = (currentAST.
root);
04054
break;
04055 }
04056
case IDENTIFIER:
04057
case USE:
04058
case TYPE:
04059
case FOR:
04060
case SUBTYPE:
04061
case GENERIC:
04062 {
04063
decl_common();
04064
if (inputState->guessing==0) {
04065 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04066 }
04067 basic_decl_item_AST = (currentAST.
root);
04068
break;
04069 }
04070
default:
04071 {
04072
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04073 }
04074 }
04075 }
04076
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04077
if( inputState->guessing == 0 ) {
04078
reportError(ex);
04079 consume();
04080 consumeUntil(
_tokenSet_23);
04081 }
else {
04082
throw;
04083 }
04084 }
04085
returnAST = basic_decl_item_AST;
04086 }
04087
04088 void AdaParser::basic_declarative_items() {
04089
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04090
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04091
RefAdaAST basic_declarative_items_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04092
04093
try {
04094 {
04095
int _cnt118=0;
04096
for (;;) {
04097
switch ( LA(1)) {
04098
case IDENTIFIER:
04099
case USE:
04100
case TYPE:
04101
case PACKAGE:
04102
case PROCEDURE:
04103
case FUNCTION:
04104
case TASK:
04105
case PROTECTED:
04106
case FOR:
04107
case SUBTYPE:
04108
case GENERIC:
04109 {
04110
basic_decl_item();
04111
if (inputState->guessing==0) {
04112 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04113 }
04114
break;
04115 }
04116
case PRAGMA:
04117 {
04118
pragma();
04119
if (inputState->guessing==0) {
04120 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04121 }
04122
break;
04123 }
04124
default:
04125 {
04126
if ( _cnt118>=1 ) {
goto _loop118; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
04127 }
04128 }
04129 _cnt118++;
04130 }
04131 _loop118:;
04132 }
04133
if ( inputState->guessing==0 ) {
04134 basic_declarative_items_AST =
RefAdaAST(currentAST.
root);
04135
#line 384 "ada.g"
04136
basic_declarative_items_AST =
04137
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,
"BASIC_DECLARATIVE_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(basic_declarative_items_AST.get()))));
04138
#line 4139 "AdaParser.cpp"
04139
currentAST.
root = basic_declarative_items_AST;
04140
if ( basic_declarative_items_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
04141 basic_declarative_items_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
04142 currentAST.
child = basic_declarative_items_AST->getFirstChild();
04143
else
04144 currentAST.
child = basic_declarative_items_AST;
04145 currentAST.
advanceChildToEnd();
04146 }
04147 basic_declarative_items_AST = (currentAST.
root);
04148 }
04149
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04150
if( inputState->guessing == 0 ) {
04151
reportError(ex);
04152 consume();
04153 consumeUntil(
_tokenSet_0);
04154 }
else {
04155
throw;
04156 }
04157 }
04158
returnAST = basic_declarative_items_AST;
04159 }
04160
04161 void AdaParser::task_type_or_single_decl(
04162 RefAdaAST tsk
04163 ) {
04164
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04165
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04166
RefAdaAST task_type_or_single_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04167
04168
try {
04169
switch ( LA(1)) {
04170
case TYPE:
04171 {
04172 match(TYPE);
04173
def_id(
false);
04174
if (inputState->guessing==0) {
04175 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04176 }
04177
discrim_part_opt();
04178
if (inputState->guessing==0) {
04179 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04180 }
04181
task_definition_opt();
04182
if (inputState->guessing==0) {
04183 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04184 }
04185
if ( inputState->guessing==0 ) {
04186
#line 400 "ada.g"
04187
Set(tsk, TASK_TYPE_DECLARATION);
04188
#line 4189 "AdaParser.cpp"
04189
}
04190 task_type_or_single_decl_AST = (currentAST.
root);
04191
break;
04192 }
04193
case IDENTIFIER:
04194 {
04195
def_id(
false);
04196
if (inputState->guessing==0) {
04197 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04198 }
04199
task_definition_opt();
04200
if (inputState->guessing==0) {
04201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04202 }
04203
if ( inputState->guessing==0 ) {
04204
#line 402 "ada.g"
04205
Set(tsk, SINGLE_TASK_DECLARATION);
04206
#line 4207 "AdaParser.cpp"
04207
}
04208 task_type_or_single_decl_AST = (currentAST.
root);
04209
break;
04210 }
04211
default:
04212 {
04213
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04214 }
04215 }
04216 }
04217
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04218
if( inputState->guessing == 0 ) {
04219
reportError(ex);
04220 consume();
04221 consumeUntil(
_tokenSet_18);
04222 }
else {
04223
throw;
04224 }
04225 }
04226
returnAST = task_type_or_single_decl_AST;
04227 }
04228
04229 void AdaParser::prot_type_or_single_decl(
04230 RefAdaAST pro
04231 ) {
04232
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04233
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04234
RefAdaAST prot_type_or_single_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04235
04236
try {
04237
switch ( LA(1)) {
04238
case TYPE:
04239 {
04240 match(TYPE);
04241
def_id(
false);
04242
if (inputState->guessing==0) {
04243 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04244 }
04245
discrim_part_opt();
04246
if (inputState->guessing==0) {
04247 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04248 }
04249
protected_definition();
04250
if (inputState->guessing==0) {
04251 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04252 }
04253
if ( inputState->guessing==0 ) {
04254
#line 531 "ada.g"
04255
Set(pro, PROTECTED_TYPE_DECLARATION);
04256
#line 4257 "AdaParser.cpp"
04257
}
04258 prot_type_or_single_decl_AST = (currentAST.
root);
04259
break;
04260 }
04261
case IDENTIFIER:
04262 {
04263
def_id(
false);
04264
if (inputState->guessing==0) {
04265 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04266 }
04267
protected_definition();
04268
if (inputState->guessing==0) {
04269 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04270 }
04271
if ( inputState->guessing==0 ) {
04272
#line 533 "ada.g"
04273
Set(pro, SINGLE_PROTECTED_DECLARATION);
04274
#line 4275 "AdaParser.cpp"
04275
}
04276 prot_type_or_single_decl_AST = (currentAST.
root);
04277
break;
04278 }
04279
default:
04280 {
04281
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04282 }
04283 }
04284 }
04285
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04286
if( inputState->guessing == 0 ) {
04287
reportError(ex);
04288 consume();
04289 consumeUntil(
_tokenSet_4);
04290 }
else {
04291
throw;
04292 }
04293 }
04294
returnAST = prot_type_or_single_decl_AST;
04295 }
04296
04297 void AdaParser::decl_common() {
04298
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04299
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04300
RefAdaAST decl_common_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04301
ANTLR_USE_NAMESPACE(antlr)
RefToken t =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04302
RefAdaAST t_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04303
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04304
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04305
ANTLR_USE_NAMESPACE(antlr)
RefToken r =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04306
RefAdaAST r_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04307
ANTLR_USE_NAMESPACE(antlr)
RefToken erd =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04308
RefAdaAST erd_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04309
ANTLR_USE_NAMESPACE(antlr)
RefToken ord =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04310
RefAdaAST ord_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04311
ANTLR_USE_NAMESPACE(antlr)
RefToken od =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
04312
RefAdaAST od_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04313
04314
try {
04315
switch ( LA(1)) {
04316
case TYPE:
04317 {
04318 t = LT(1);
04319
if ( inputState->guessing == 0 ) {
04320 t_AST = astFactory->create(t);
04321 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
04322 }
04323 match(TYPE);
04324
RefAdaAST tmp113_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04325
if ( inputState->guessing == 0 ) {
04326 tmp113_AST = astFactory->create(LT(1));
04327 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp113_AST.get()));
04328 }
04329 match(IDENTIFIER);
04330 {
04331
switch ( LA(1)) {
04332
case IS:
04333 {
04334 match(IS);
04335
type_def(t_AST);
04336
if (inputState->guessing==0) {
04337 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04338 }
04339
break;
04340 }
04341
case SEMI:
04342
case LPAREN:
04343 {
04344 {
04345
switch ( LA(1)) {
04346
case LPAREN:
04347 {
04348
discrim_part();
04349
if (inputState->guessing==0) {
04350 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04351 }
04352 {
04353
switch ( LA(1)) {
04354
case IS:
04355 {
04356 match(IS);
04357
derived_or_private_or_record(t_AST,
true);
04358
if (inputState->guessing==0) {
04359 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04360 }
04361
break;
04362 }
04363
case SEMI:
04364 {
04365
if ( inputState->guessing==0 ) {
04366
#line 573 "ada.g"
04367
Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
04368
#line 4369 "AdaParser.cpp"
04369
}
04370
break;
04371 }
04372
default:
04373 {
04374
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04375 }
04376 }
04377 }
04378
break;
04379 }
04380
case SEMI:
04381 {
04382
empty_discrim_opt();
04383
if (inputState->guessing==0) {
04384 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04385 }
04386
if ( inputState->guessing==0 ) {
04387
#line 576 "ada.g"
04388
Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
04389
#line 4390 "AdaParser.cpp"
04390
}
04391
break;
04392 }
04393
default:
04394 {
04395
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04396 }
04397 }
04398 }
04399
break;
04400 }
04401
default:
04402 {
04403
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04404 }
04405 }
04406 }
04407 match(SEMI);
04408 decl_common_AST = (currentAST.
root);
04409
break;
04410 }
04411
case SUBTYPE:
04412 {
04413 s = LT(1);
04414
if ( inputState->guessing == 0 ) {
04415 s_AST = astFactory->create(s);
04416 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
04417 }
04418 match(SUBTYPE);
04419
RefAdaAST tmp117_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04420
if ( inputState->guessing == 0 ) {
04421 tmp117_AST = astFactory->create(LT(1));
04422 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp117_AST.get()));
04423 }
04424 match(IDENTIFIER);
04425 match(IS);
04426
subtype_ind();
04427
if (inputState->guessing==0) {
04428 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04429 }
04430 match(SEMI);
04431
if ( inputState->guessing==0 ) {
04432
#line 590 "ada.g"
04433
Set(s_AST, SUBTYPE_DECLARATION);
04434
#line 4435 "AdaParser.cpp"
04435
}
04436 decl_common_AST = (currentAST.
root);
04437
break;
04438 }
04439
case GENERIC:
04440 {
04441
generic_decl(
false);
04442
if (inputState->guessing==0) {
04443 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04444 }
04445 decl_common_AST = (currentAST.
root);
04446
break;
04447 }
04448
case USE:
04449 {
04450
use_clause();
04451
if (inputState->guessing==0) {
04452 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04453 }
04454 decl_common_AST = (currentAST.
root);
04455
break;
04456 }
04457
case FOR:
04458 {
04459 r = LT(1);
04460
if ( inputState->guessing == 0 ) {
04461 r_AST = astFactory->create(r);
04462 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
04463 }
04464 match(FOR);
04465 {
04466
bool synPredMatched182 =
false;
04467
if (((LA(1) == IDENTIFIER) && (LA(2) == USE))) {
04468
int _m182 = mark();
04469 synPredMatched182 =
true;
04470 inputState->guessing++;
04471
try {
04472 {
04473
local_enum_name();
04474 match(USE);
04475 match(LPAREN);
04476 }
04477 }
04478
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
04479 synPredMatched182 =
false;
04480 }
04481 rewind(_m182);
04482 inputState->guessing--;
04483 }
04484
if ( synPredMatched182 ) {
04485
local_enum_name();
04486
if (inputState->guessing==0) {
04487 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04488 }
04489 match(USE);
04490
enumeration_aggregate();
04491
if (inputState->guessing==0) {
04492 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04493 }
04494
if ( inputState->guessing==0 ) {
04495
#line 595 "ada.g"
04496
Set(r_AST, ENUMERATION_REPESENTATION_CLAUSE);
04497
#line 4498 "AdaParser.cpp"
04498
}
04499 }
04500
else if ((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == USE || LA(2) == TIC)) {
04501
subtype_mark();
04502
if (inputState->guessing==0) {
04503 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04504 }
04505 match(USE);
04506
rep_spec_part(r_AST);
04507
if (inputState->guessing==0) {
04508 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04509 }
04510 }
04511
else {
04512
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04513 }
04514
04515 }
04516 match(SEMI);
04517 decl_common_AST = (currentAST.
root);
04518
break;
04519 }
04520
default:
04521
bool synPredMatched184 =
false;
04522
if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
04523
int _m184 = mark();
04524 synPredMatched184 =
true;
04525 inputState->guessing++;
04526
try {
04527 {
04528 match(IDENTIFIER);
04529 match(COLON);
04530 match(EXCEPTION);
04531 match(RENAMES);
04532 }
04533 }
04534
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
04535 synPredMatched184 =
false;
04536 }
04537 rewind(_m184);
04538 inputState->guessing--;
04539 }
04540
if ( synPredMatched184 ) {
04541
RefAdaAST tmp123_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04542
if ( inputState->guessing == 0 ) {
04543 tmp123_AST = astFactory->create(LT(1));
04544 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp123_AST.get()));
04545 }
04546 match(IDENTIFIER);
04547 erd = LT(1);
04548
if ( inputState->guessing == 0 ) {
04549 erd_AST = astFactory->create(erd);
04550 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(erd_AST.get()));
04551 }
04552 match(COLON);
04553 match(EXCEPTION);
04554 match(RENAMES);
04555
compound_name();
04556
if (inputState->guessing==0) {
04557 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04558 }
04559 match(SEMI);
04560
if ( inputState->guessing==0 ) {
04561
#line 601 "ada.g"
04562
Set(erd_AST, EXCEPTION_RENAMING_DECLARATION);
04563
#line 4564 "AdaParser.cpp"
04564
}
04565 decl_common_AST = (currentAST.
root);
04566 }
04567
else {
04568
bool synPredMatched186 =
false;
04569
if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
04570
int _m186 = mark();
04571 synPredMatched186 =
true;
04572 inputState->guessing++;
04573
try {
04574 {
04575 match(IDENTIFIER);
04576 match(COLON);
04577
subtype_mark();
04578 match(RENAMES);
04579 }
04580 }
04581
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
04582 synPredMatched186 =
false;
04583 }
04584 rewind(_m186);
04585 inputState->guessing--;
04586 }
04587
if ( synPredMatched186 ) {
04588
RefAdaAST tmp127_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04589
if ( inputState->guessing == 0 ) {
04590 tmp127_AST = astFactory->create(LT(1));
04591 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp127_AST.get()));
04592 }
04593 match(IDENTIFIER);
04594 ord = LT(1);
04595
if ( inputState->guessing == 0 ) {
04596 ord_AST = astFactory->create(ord);
04597 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(ord_AST.get()));
04598 }
04599 match(COLON);
04600
subtype_mark();
04601
if (inputState->guessing==0) {
04602 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04603 }
04604 match(RENAMES);
04605
name();
04606
if (inputState->guessing==0) {
04607 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04608 }
04609 match(SEMI);
04610
if ( inputState->guessing==0 ) {
04611
#line 604 "ada.g"
04612
Set(ord_AST, OBJECT_RENAMING_DECLARATION);
04613
#line 4614 "AdaParser.cpp"
04614
}
04615 decl_common_AST = (currentAST.
root);
04616 }
04617
else if ((LA(1) == IDENTIFIER) && (LA(2) == COMMA || LA(2) == COLON)) {
04618
defining_identifier_list();
04619
if (inputState->guessing==0) {
04620 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04621 }
04622 od = LT(1);
04623
if ( inputState->guessing == 0 ) {
04624 od_AST = astFactory->create(od);
04625 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(od_AST.get()));
04626 }
04627 match(COLON);
04628 {
04629
if ((LA(1) == EXCEPTION)) {
04630 match(EXCEPTION);
04631
if ( inputState->guessing==0 ) {
04632
#line 607 "ada.g"
04633
Set(od_AST, EXCEPTION_DECLARATION);
04634
#line 4635 "AdaParser.cpp"
04635
}
04636 }
04637
else {
04638
bool synPredMatched189 =
false;
04639
if (((LA(1) == CONSTANT) && (LA(2) == ASSIGN))) {
04640
int _m189 = mark();
04641 synPredMatched189 =
true;
04642 inputState->guessing++;
04643
try {
04644 {
04645 match(CONSTANT);
04646 match(ASSIGN);
04647 }
04648 }
04649
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
04650 synPredMatched189 =
false;
04651 }
04652 rewind(_m189);
04653 inputState->guessing--;
04654 }
04655
if ( synPredMatched189 ) {
04656 match(CONSTANT);
04657 match(ASSIGN);
04658
expression();
04659
if (inputState->guessing==0) {
04660 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04661 }
04662
if ( inputState->guessing==0 ) {
04663
#line 609 "ada.g"
04664
Set(od_AST, NUMBER_DECLARATION);
04665
#line 4666 "AdaParser.cpp"
04666
}
04667 }
04668
else if ((
_tokenSet_50.member(LA(1))) && (
_tokenSet_51.member(LA(2)))) {
04669
aliased_constant_opt();
04670
if (inputState->guessing==0) {
04671 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04672 }
04673 {
04674
switch ( LA(1)) {
04675
case ARRAY:
04676 {
04677
array_type_definition(od_AST);
04678
if (inputState->guessing==0) {
04679 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04680 }
04681
init_opt();
04682
if (inputState->guessing==0) {
04683 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04684 }
04685
if ( inputState->guessing==0 ) {
04686
#line 612 "ada.g"
04687
Set(od_AST, ARRAY_OBJECT_DECLARATION);
04688
#line 4689 "AdaParser.cpp"
04689
}
04690
break;
04691 }
04692
case IDENTIFIER:
04693 {
04694
subtype_ind();
04695
if (inputState->guessing==0) {
04696 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04697 }
04698
init_opt();
04699
if (inputState->guessing==0) {
04700 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04701 }
04702
if ( inputState->guessing==0 ) {
04703
#line 616 "ada.g"
04704
Set(od_AST, OBJECT_DECLARATION);
04705
#line 4706 "AdaParser.cpp"
04706
}
04707
break;
04708 }
04709
default:
04710 {
04711
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04712 }
04713 }
04714 }
04715 }
04716
else {
04717
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04718 }
04719 }
04720 }
04721 match(SEMI);
04722 decl_common_AST = (currentAST.
root);
04723 }
04724
else {
04725
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04726 }
04727 }}
04728 }
04729
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04730
if( inputState->guessing == 0 ) {
04731
reportError(ex);
04732 consume();
04733 consumeUntil(
_tokenSet_18);
04734 }
else {
04735
throw;
04736 }
04737 }
04738
returnAST = decl_common_AST;
04739 }
04740
04741 void AdaParser::discrim_part_opt() {
04742
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04743
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04744
RefAdaAST discrim_part_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04745
04746
try {
04747 {
04748
switch ( LA(1)) {
04749
case LPAREN:
04750 {
04751
discrim_part_text();
04752
if (inputState->guessing==0) {
04753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04754 }
04755
break;
04756 }
04757
case SEMI:
04758
case IS:
04759 {
04760
break;
04761 }
04762
default:
04763 {
04764
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04765 }
04766 }
04767 }
04768
if ( inputState->guessing==0 ) {
04769 discrim_part_opt_AST =
RefAdaAST(currentAST.
root);
04770
#line 412 "ada.g"
04771
discrim_part_opt_AST =
04772
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,
"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrim_part_opt_AST.get()))));
04773
#line 4774 "AdaParser.cpp"
04774
currentAST.
root = discrim_part_opt_AST;
04775
if ( discrim_part_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
04776 discrim_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
04777 currentAST.
child = discrim_part_opt_AST->getFirstChild();
04778
else
04779 currentAST.
child = discrim_part_opt_AST;
04780 currentAST.
advanceChildToEnd();
04781 }
04782 discrim_part_opt_AST = (currentAST.
root);
04783 }
04784
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04785
if( inputState->guessing == 0 ) {
04786
reportError(ex);
04787 consume();
04788 consumeUntil(
_tokenSet_52);
04789 }
else {
04790
throw;
04791 }
04792 }
04793
returnAST = discrim_part_opt_AST;
04794 }
04795
04796 void AdaParser::task_definition_opt() {
04797
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04798
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04799
RefAdaAST task_definition_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04800
04801
try {
04802
switch ( LA(1)) {
04803
case IS:
04804 {
04805 match(IS);
04806
task_items_opt();
04807
if (inputState->guessing==0) {
04808 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04809 }
04810
private_task_items_opt();
04811
if (inputState->guessing==0) {
04812 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04813 }
04814
end_id_opt();
04815 match(SEMI);
04816 task_definition_opt_AST = (currentAST.
root);
04817
break;
04818 }
04819
case SEMI:
04820 {
04821 match(SEMI);
04822
if ( inputState->guessing==0 ) {
04823
#line 407 "ada.g"
04824
pop_def_id();
04825
#line 4826 "AdaParser.cpp"
04826
}
04827 task_definition_opt_AST = (currentAST.
root);
04828
break;
04829 }
04830
default:
04831 {
04832
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04833 }
04834 }
04835 }
04836
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04837
if( inputState->guessing == 0 ) {
04838
reportError(ex);
04839 consume();
04840 consumeUntil(
_tokenSet_18);
04841 }
else {
04842
throw;
04843 }
04844 }
04845
returnAST = task_definition_opt_AST;
04846 }
04847
04848 void AdaParser::task_items_opt() {
04849
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04850
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04851
RefAdaAST task_items_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04852
04853
try {
04854 {
04855
for (;;) {
04856
if ((LA(1) == PRAGMA)) {
04857
pragma();
04858
if (inputState->guessing==0) {
04859 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04860 }
04861 }
04862
else {
04863
goto _loop139;
04864 }
04865
04866 }
04867 _loop139:;
04868 }
04869
entrydecls_repspecs_opt();
04870
if (inputState->guessing==0) {
04871 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04872 }
04873
if ( inputState->guessing==0 ) {
04874 task_items_opt_AST =
RefAdaAST(currentAST.
root);
04875
#line 465 "ada.g"
04876
task_items_opt_AST =
04877
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TASK_ITEMS_OPT,
"TASK_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(task_items_opt_AST.get()))));
04878
#line 4879 "AdaParser.cpp"
04879
currentAST.
root = task_items_opt_AST;
04880
if ( task_items_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
04881 task_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
04882 currentAST.
child = task_items_opt_AST->getFirstChild();
04883
else
04884 currentAST.
child = task_items_opt_AST;
04885 currentAST.
advanceChildToEnd();
04886 }
04887 task_items_opt_AST = (currentAST.
root);
04888 }
04889
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04890
if( inputState->guessing == 0 ) {
04891
reportError(ex);
04892 consume();
04893 consumeUntil(
_tokenSet_49);
04894 }
else {
04895
throw;
04896 }
04897 }
04898
returnAST = task_items_opt_AST;
04899 }
04900
04901 void AdaParser::private_task_items_opt() {
04902
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04903
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04904
RefAdaAST private_task_items_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04905
04906
try {
04907 {
04908
switch ( LA(1)) {
04909
case PRIVATE:
04910 {
04911 match(PRIVATE);
04912 {
04913
for (;;) {
04914
if ((LA(1) == PRAGMA)) {
04915
pragma();
04916
if (inputState->guessing==0) {
04917 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04918 }
04919 }
04920
else {
04921
goto _loop164;
04922 }
04923
04924 }
04925 _loop164:;
04926 }
04927
entrydecls_repspecs_opt();
04928
if (inputState->guessing==0) {
04929 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04930 }
04931
break;
04932 }
04933
case END:
04934 {
04935
break;
04936 }
04937
default:
04938 {
04939
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
04940 }
04941 }
04942 }
04943
if ( inputState->guessing==0 ) {
04944 private_task_items_opt_AST =
RefAdaAST(currentAST.
root);
04945
#line 522 "ada.g"
04946
private_task_items_opt_AST =
04947
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PRIVATE_TASK_ITEMS_OPT,
"PRIVATE_TASK_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(private_task_items_opt_AST.get()))));
04948
#line 4949 "AdaParser.cpp"
04949
currentAST.
root = private_task_items_opt_AST;
04950
if ( private_task_items_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
04951 private_task_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
04952 currentAST.
child = private_task_items_opt_AST->getFirstChild();
04953
else
04954 currentAST.
child = private_task_items_opt_AST;
04955 currentAST.
advanceChildToEnd();
04956 }
04957 private_task_items_opt_AST = (currentAST.
root);
04958 }
04959
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04960
if( inputState->guessing == 0 ) {
04961
reportError(ex);
04962 consume();
04963 consumeUntil(
_tokenSet_21);
04964 }
else {
04965
throw;
04966 }
04967 }
04968
returnAST = private_task_items_opt_AST;
04969 }
04970
04971 void AdaParser::discrim_part_text() {
04972
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04973
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
04974
RefAdaAST discrim_part_text_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04975
04976
try {
04977 match(LPAREN);
04978 {
04979
switch ( LA(1)) {
04980
case BOX:
04981 {
04982
RefAdaAST tmp139_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
04983
if ( inputState->guessing == 0 ) {
04984 tmp139_AST = astFactory->create(LT(1));
04985 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp139_AST.get()));
04986 }
04987 match(BOX);
04988
break;
04989 }
04990
case IDENTIFIER:
04991 {
04992
discriminant_specifications();
04993
if (inputState->guessing==0) {
04994 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
04995 }
04996
break;
04997 }
04998
default:
04999 {
05000
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05001 }
05002 }
05003 }
05004 match(RPAREN);
05005 discrim_part_text_AST = (currentAST.
root);
05006 }
05007
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05008
if( inputState->guessing == 0 ) {
05009
reportError(ex);
05010 consume();
05011 consumeUntil(
_tokenSet_52);
05012 }
else {
05013
throw;
05014 }
05015 }
05016
returnAST = discrim_part_text_AST;
05017 }
05018
05019 void AdaParser::discriminant_specifications() {
05020
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05021
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05022
RefAdaAST discriminant_specifications_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05023
05024
try {
05025
discriminant_specification();
05026
if (inputState->guessing==0) {
05027 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05028 }
05029 {
05030
for (;;) {
05031
if ((LA(1) == SEMI)) {
05032 match(SEMI);
05033
discriminant_specification();
05034
if (inputState->guessing==0) {
05035 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05036 }
05037 }
05038
else {
05039
goto _loop131;
05040 }
05041
05042 }
05043 _loop131:;
05044 }
05045
if ( inputState->guessing==0 ) {
05046 discriminant_specifications_AST =
RefAdaAST(currentAST.
root);
05047
#line 442 "ada.g"
05048
discriminant_specifications_AST =
05049
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_SPECIFICATIONS,
"DISCRIMINANT_SPECIFICATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_specifications_AST.get()))));
05050
#line 5051 "AdaParser.cpp"
05051
currentAST.
root = discriminant_specifications_AST;
05052
if ( discriminant_specifications_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05053 discriminant_specifications_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05054 currentAST.
child = discriminant_specifications_AST->getFirstChild();
05055
else
05056 currentAST.
child = discriminant_specifications_AST;
05057 currentAST.
advanceChildToEnd();
05058 }
05059 discriminant_specifications_AST = (currentAST.
root);
05060 }
05061
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05062
if( inputState->guessing == 0 ) {
05063
reportError(ex);
05064 consume();
05065 consumeUntil(
_tokenSet_47);
05066 }
else {
05067
throw;
05068 }
05069 }
05070
returnAST = discriminant_specifications_AST;
05071 }
05072
05073 void AdaParser::known_discrim_part() {
05074
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05075
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05076
RefAdaAST known_discrim_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05077
05078
try {
05079 match(LPAREN);
05080
discriminant_specifications();
05081
if (inputState->guessing==0) {
05082 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05083 }
05084 match(RPAREN);
05085
if ( inputState->guessing==0 ) {
05086 known_discrim_part_AST =
RefAdaAST(currentAST.
root);
05087
#line 422 "ada.g"
05088
known_discrim_part_AST =
05089
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,
"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(known_discrim_part_AST.get()))));
05090
#line 5091 "AdaParser.cpp"
05091
currentAST.
root = known_discrim_part_AST;
05092
if ( known_discrim_part_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05093 known_discrim_part_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05094 currentAST.
child = known_discrim_part_AST->getFirstChild();
05095
else
05096 currentAST.
child = known_discrim_part_AST;
05097 currentAST.
advanceChildToEnd();
05098 }
05099 known_discrim_part_AST = (currentAST.
root);
05100 }
05101
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05102
if( inputState->guessing == 0 ) {
05103
reportError(ex);
05104 consume();
05105 consumeUntil(
_tokenSet_0);
05106 }
else {
05107
throw;
05108 }
05109 }
05110
returnAST = known_discrim_part_AST;
05111 }
05112
05113 void AdaParser::empty_discrim_opt() {
05114
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05115
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05116
RefAdaAST empty_discrim_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05117
05118
try {
05119
if ( inputState->guessing==0 ) {
05120 empty_discrim_opt_AST =
RefAdaAST(currentAST.
root);
05121
#line 428 "ada.g"
05122
empty_discrim_opt_AST =
05123
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,
"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(empty_discrim_opt_AST.get()))));
05124
#line 5125 "AdaParser.cpp"
05125
currentAST.
root = empty_discrim_opt_AST;
05126
if ( empty_discrim_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05127 empty_discrim_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05128 currentAST.
child = empty_discrim_opt_AST->getFirstChild();
05129
else
05130 currentAST.
child = empty_discrim_opt_AST;
05131 currentAST.
advanceChildToEnd();
05132 }
05133 empty_discrim_opt_AST = (currentAST.
root);
05134 }
05135
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05136
if( inputState->guessing == 0 ) {
05137
reportError(ex);
05138 consume();
05139 consumeUntil(
_tokenSet_53);
05140 }
else {
05141
throw;
05142 }
05143 }
05144
returnAST = empty_discrim_opt_AST;
05145 }
05146
05147 void AdaParser::discrim_part() {
05148
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05149
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05150
RefAdaAST discrim_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05151
05152
try {
05153
discrim_part_text();
05154
if (inputState->guessing==0) {
05155 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05156 }
05157
if ( inputState->guessing==0 ) {
05158 discrim_part_AST =
RefAdaAST(currentAST.
root);
05159
#line 435 "ada.g"
05160
discrim_part_AST =
05161
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,
"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrim_part_AST.get()))));
05162
#line 5163 "AdaParser.cpp"
05163
currentAST.
root = discrim_part_AST;
05164
if ( discrim_part_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05165 discrim_part_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05166 currentAST.
child = discrim_part_AST->getFirstChild();
05167
else
05168 currentAST.
child = discrim_part_AST;
05169 currentAST.
advanceChildToEnd();
05170 }
05171 discrim_part_AST = (currentAST.
root);
05172 }
05173
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05174
if( inputState->guessing == 0 ) {
05175
reportError(ex);
05176 consume();
05177 consumeUntil(
_tokenSet_52);
05178 }
else {
05179
throw;
05180 }
05181 }
05182
returnAST = discrim_part_AST;
05183 }
05184
05185 void AdaParser::discriminant_specification() {
05186
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05187
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05188
RefAdaAST discriminant_specification_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05189
05190
try {
05191
def_ids_colon();
05192
if (inputState->guessing==0) {
05193 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05194 }
05195
access_opt();
05196
if (inputState->guessing==0) {
05197 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05198 }
05199
subtype_mark();
05200
if (inputState->guessing==0) {
05201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05202 }
05203
init_opt();
05204
if (inputState->guessing==0) {
05205 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05206 }
05207
if ( inputState->guessing==0 ) {
05208 discriminant_specification_AST =
RefAdaAST(currentAST.
root);
05209
#line 449 "ada.g"
05210
discriminant_specification_AST =
05211
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_SPECIFICATION,
"DISCRIMINANT_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_specification_AST.get()))));
05212
#line 5213 "AdaParser.cpp"
05213
currentAST.
root = discriminant_specification_AST;
05214
if ( discriminant_specification_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05215 discriminant_specification_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05216 currentAST.
child = discriminant_specification_AST->getFirstChild();
05217
else
05218 currentAST.
child = discriminant_specification_AST;
05219 currentAST.
advanceChildToEnd();
05220 }
05221 discriminant_specification_AST = (currentAST.
root);
05222 }
05223
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05224
if( inputState->guessing == 0 ) {
05225
reportError(ex);
05226 consume();
05227 consumeUntil(
_tokenSet_37);
05228 }
else {
05229
throw;
05230 }
05231 }
05232
returnAST = discriminant_specification_AST;
05233 }
05234
05235 void AdaParser::access_opt() {
05236
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05237
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05238
RefAdaAST access_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05239
05240
try {
05241 {
05242
switch ( LA(1)) {
05243
case ACCESS:
05244 {
05245
RefAdaAST tmp144_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05246
if ( inputState->guessing == 0 ) {
05247 tmp144_AST = astFactory->create(LT(1));
05248 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp144_AST.get()));
05249 }
05250 match(ACCESS);
05251
break;
05252 }
05253
case IDENTIFIER:
05254 {
05255
break;
05256 }
05257
default:
05258 {
05259
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05260 }
05261 }
05262 }
05263
if ( inputState->guessing==0 ) {
05264 access_opt_AST =
RefAdaAST(currentAST.
root);
05265
#line 456 "ada.g"
05266
access_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(access_opt_AST.get()))));
05267
#line 5268 "AdaParser.cpp"
05268
currentAST.
root = access_opt_AST;
05269
if ( access_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05270 access_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05271 currentAST.
child = access_opt_AST->getFirstChild();
05272
else
05273 currentAST.
child = access_opt_AST;
05274 currentAST.
advanceChildToEnd();
05275 }
05276 access_opt_AST = (currentAST.
root);
05277 }
05278
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05279
if( inputState->guessing == 0 ) {
05280
reportError(ex);
05281 consume();
05282 consumeUntil(
_tokenSet_39);
05283 }
else {
05284
throw;
05285 }
05286 }
05287
returnAST = access_opt_AST;
05288 }
05289
05290 void AdaParser::entrydecls_repspecs_opt() {
05291
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05292
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05293
RefAdaAST entrydecls_repspecs_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05294
05295
try {
05296 {
05297
for (;;) {
05298
if ((LA(1) == ENTRY)) {
05299
entry_declaration();
05300
if (inputState->guessing==0) {
05301 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05302 }
05303 {
05304
for (;;) {
05305
switch ( LA(1)) {
05306
case PRAGMA:
05307 {
05308
pragma();
05309
if (inputState->guessing==0) {
05310 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05311 }
05312
break;
05313 }
05314
case FOR:
05315 {
05316
rep_spec();
05317
if (inputState->guessing==0) {
05318 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05319 }
05320
break;
05321 }
05322
default:
05323 {
05324
goto _loop143;
05325 }
05326 }
05327 }
05328 _loop143:;
05329 }
05330 }
05331
else {
05332
goto _loop144;
05333 }
05334
05335 }
05336 _loop144:;
05337 }
05338 entrydecls_repspecs_opt_AST = (currentAST.
root);
05339 }
05340
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05341
if( inputState->guessing == 0 ) {
05342
reportError(ex);
05343 consume();
05344 consumeUntil(
_tokenSet_49);
05345 }
else {
05346
throw;
05347 }
05348 }
05349
returnAST = entrydecls_repspecs_opt_AST;
05350 }
05351
05352 void AdaParser::entry_declaration() {
05353
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05354
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05355
RefAdaAST entry_declaration_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05356
ANTLR_USE_NAMESPACE(antlr)
RefToken e =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05357
RefAdaAST e_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05358
05359
try {
05360 e = LT(1);
05361
if ( inputState->guessing == 0 ) {
05362 e_AST = astFactory->create(e);
05363 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(e_AST.get()));
05364 }
05365 match(ENTRY);
05366
RefAdaAST tmp145_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05367
if ( inputState->guessing == 0 ) {
05368 tmp145_AST = astFactory->create(LT(1));
05369 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp145_AST.get()));
05370 }
05371 match(IDENTIFIER);
05372
discrete_subtype_def_opt();
05373
if (inputState->guessing==0) {
05374 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05375 }
05376
formal_part_opt();
05377
if (inputState->guessing==0) {
05378 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05379 }
05380 match(SEMI);
05381
if ( inputState->guessing==0 ) {
05382
#line 474 "ada.g"
05383
Set (e_AST, ENTRY_DECLARATION);
05384
#line 5385 "AdaParser.cpp"
05385
}
05386 entry_declaration_AST = (currentAST.
root);
05387 }
05388
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05389
if( inputState->guessing == 0 ) {
05390
reportError(ex);
05391 consume();
05392 consumeUntil(
_tokenSet_54);
05393 }
else {
05394
throw;
05395 }
05396 }
05397
returnAST = entry_declaration_AST;
05398 }
05399
05400 void AdaParser::rep_spec() {
05401
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05402
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05403
RefAdaAST rep_spec_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05404
ANTLR_USE_NAMESPACE(antlr)
RefToken r =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05405
RefAdaAST r_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05406
05407
try {
05408 r = LT(1);
05409
if ( inputState->guessing == 0 ) {
05410 r_AST = astFactory->create(r);
05411 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
05412 }
05413 match(FOR);
05414
subtype_mark();
05415
if (inputState->guessing==0) {
05416 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05417 }
05418 match(USE);
05419
rep_spec_part(r_AST);
05420
if (inputState->guessing==0) {
05421 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05422 }
05423 match(SEMI);
05424 rep_spec_AST = (currentAST.
root);
05425 }
05426
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05427
if( inputState->guessing == 0 ) {
05428
reportError(ex);
05429 consume();
05430 consumeUntil(
_tokenSet_54);
05431 }
else {
05432
throw;
05433 }
05434 }
05435
returnAST = rep_spec_AST;
05436 }
05437
05438 void AdaParser::discrete_subtype_def_opt() {
05439
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05440
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05441
RefAdaAST discrete_subtype_def_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05442
05443
try {
05444 {
05445
bool synPredMatched149 =
false;
05446
if (((LA(1) == LPAREN) && (
_tokenSet_5.member(LA(2))))) {
05447
int _m149 = mark();
05448 synPredMatched149 =
true;
05449 inputState->guessing++;
05450
try {
05451 {
05452 match(LPAREN);
05453
discrete_subtype_definition();
05454 match(RPAREN);
05455 }
05456 }
05457
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
05458 synPredMatched149 =
false;
05459 }
05460 rewind(_m149);
05461 inputState->guessing--;
05462 }
05463
if ( synPredMatched149 ) {
05464 match(LPAREN);
05465
discrete_subtype_definition();
05466
if (inputState->guessing==0) {
05467 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05468 }
05469 match(RPAREN);
05470 }
05471
else if ((LA(1) == SEMI || LA(1) == LPAREN) && (
_tokenSet_54.member(LA(2)))) {
05472 }
05473
else {
05474
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05475 }
05476
05477 }
05478
if ( inputState->guessing==0 ) {
05479 discrete_subtype_def_opt_AST =
RefAdaAST(currentAST.
root);
05480
#line 481 "ada.g"
05481
discrete_subtype_def_opt_AST =
05482
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRETE_SUBTYPE_DEF_OPT,
"DISCRETE_SUBTYPE_DEF_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrete_subtype_def_opt_AST.get()))));
05483
#line 5484 "AdaParser.cpp"
05484
currentAST.
root = discrete_subtype_def_opt_AST;
05485
if ( discrete_subtype_def_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05486 discrete_subtype_def_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05487 currentAST.
child = discrete_subtype_def_opt_AST->getFirstChild();
05488
else
05489 currentAST.
child = discrete_subtype_def_opt_AST;
05490 currentAST.
advanceChildToEnd();
05491 }
05492 discrete_subtype_def_opt_AST = (currentAST.
root);
05493 }
05494
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05495
if( inputState->guessing == 0 ) {
05496
reportError(ex);
05497 consume();
05498 consumeUntil(
_tokenSet_55);
05499 }
else {
05500
throw;
05501 }
05502 }
05503
returnAST = discrete_subtype_def_opt_AST;
05504 }
05505
05506 void AdaParser::discrete_subtype_definition() {
05507
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05508
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05509
RefAdaAST discrete_subtype_definition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05510
05511
try {
05512 {
05513
bool synPredMatched153 =
false;
05514
if (((
_tokenSet_5.member(LA(1))) && (
_tokenSet_33.member(LA(2))))) {
05515
int _m153 = mark();
05516 synPredMatched153 =
true;
05517 inputState->guessing++;
05518
try {
05519 {
05520
range();
05521 }
05522 }
05523
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
05524 synPredMatched153 =
false;
05525 }
05526 rewind(_m153);
05527 inputState->guessing--;
05528 }
05529
if ( synPredMatched153 ) {
05530
range();
05531
if (inputState->guessing==0) {
05532 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05533 }
05534 }
05535
else if ((LA(1) == IDENTIFIER) && (
_tokenSet_56.member(LA(2)))) {
05536
subtype_ind();
05537
if (inputState->guessing==0) {
05538 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05539 }
05540 }
05541
else {
05542
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05543 }
05544
05545 }
05546 discrete_subtype_definition_AST = (currentAST.
root);
05547 }
05548
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05549
if( inputState->guessing == 0 ) {
05550
reportError(ex);
05551 consume();
05552 consumeUntil(
_tokenSet_57);
05553 }
else {
05554
throw;
05555 }
05556 }
05557
returnAST = discrete_subtype_definition_AST;
05558 }
05559
05560 void AdaParser::subtype_ind() {
05561
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05562
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05563
RefAdaAST subtype_ind_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05564
05565
try {
05566
subtype_mark();
05567
if (inputState->guessing==0) {
05568 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05569 }
05570
constraint_opt();
05571
if (inputState->guessing==0) {
05572 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05573 }
05574
if ( inputState->guessing==0 ) {
05575 subtype_ind_AST =
RefAdaAST(currentAST.
root);
05576
#line 679 "ada.g"
05577
subtype_ind_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SUBTYPE_INDICATION,
"SUBTYPE_INDICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(subtype_ind_AST.get()))));
05578
#line 5579 "AdaParser.cpp"
05579
currentAST.
root = subtype_ind_AST;
05580
if ( subtype_ind_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05581 subtype_ind_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05582 currentAST.
child = subtype_ind_AST->getFirstChild();
05583
else
05584 currentAST.
child = subtype_ind_AST;
05585 currentAST.
advanceChildToEnd();
05586 }
05587 subtype_ind_AST = (currentAST.
root);
05588 }
05589
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05590
if( inputState->guessing == 0 ) {
05591
reportError(ex);
05592 consume();
05593 consumeUntil(
_tokenSet_58);
05594 }
else {
05595
throw;
05596 }
05597 }
05598
returnAST = subtype_ind_AST;
05599 }
05600
05601 void AdaParser::rep_spec_part(
05602 RefAdaAST t
05603 ) {
05604
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05605
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05606
RefAdaAST rep_spec_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05607
05608
try {
05609
switch ( LA(1)) {
05610
case RECORD:
05611 {
05612 match(RECORD);
05613
align_opt();
05614
if (inputState->guessing==0) {
05615 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05616 }
05617
comp_loc_s();
05618
if (inputState->guessing==0) {
05619 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05620 }
05621 match(END);
05622 match(RECORD);
05623
if ( inputState->guessing==0 ) {
05624
#line 504 "ada.g"
05625
Set(t, RECORD_REPRESENTATION_CLAUSE);
05626
#line 5627 "AdaParser.cpp"
05627
}
05628 rep_spec_part_AST = (currentAST.
root);
05629
break;
05630 }
05631
case AT:
05632 {
05633 match(AT);
05634
expression();
05635
if (inputState->guessing==0) {
05636 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05637 }
05638
if ( inputState->guessing==0 ) {
05639
#line 506 "ada.g"
05640
Set(t, AT_CLAUSE);
05641
#line 5642 "AdaParser.cpp"
05642
}
05643 rep_spec_part_AST = (currentAST.
root);
05644
break;
05645 }
05646
case IDENTIFIER:
05647
case LPAREN:
05648
case NEW:
05649
case CHARACTER_LITERAL:
05650
case CHAR_STRING:
05651
case NuLL:
05652
case NOT:
05653
case PLUS:
05654
case MINUS:
05655
case ABS:
05656
case NUMERIC_LIT:
05657 {
05658
expression();
05659
if (inputState->guessing==0) {
05660 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05661 }
05662
if ( inputState->guessing==0 ) {
05663
#line 509 "ada.g"
05664
Set(t, ATTRIBUTE_DEFINITION_CLAUSE);
05665
#line 5666 "AdaParser.cpp"
05666
}
05667 rep_spec_part_AST = (currentAST.
root);
05668
break;
05669 }
05670
default:
05671 {
05672
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05673 }
05674 }
05675 }
05676
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05677
if( inputState->guessing == 0 ) {
05678
reportError(ex);
05679 consume();
05680 consumeUntil(
_tokenSet_4);
05681 }
else {
05682
throw;
05683 }
05684 }
05685
returnAST = rep_spec_part_AST;
05686 }
05687
05688 void AdaParser::align_opt() {
05689
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05690
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05691
RefAdaAST align_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05692
05693
try {
05694 {
05695
switch ( LA(1)) {
05696
case AT:
05697 {
05698 match(AT);
05699 match(MOD);
05700
expression();
05701
if (inputState->guessing==0) {
05702 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05703 }
05704 match(SEMI);
05705
break;
05706 }
05707
case PRAGMA:
05708
case IDENTIFIER:
05709
case END:
05710 {
05711
break;
05712 }
05713
default:
05714 {
05715
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05716 }
05717 }
05718 }
05719
if ( inputState->guessing==0 ) {
05720 align_opt_AST =
RefAdaAST(currentAST.
root);
05721
#line 513 "ada.g"
05722
align_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MOD_CLAUSE_OPT,
"MOD_CLAUSE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(align_opt_AST.get()))));
05723
#line 5724 "AdaParser.cpp"
05724
currentAST.
root = align_opt_AST;
05725
if ( align_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05726 align_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05727 currentAST.
child = align_opt_AST->getFirstChild();
05728
else
05729 currentAST.
child = align_opt_AST;
05730 currentAST.
advanceChildToEnd();
05731 }
05732 align_opt_AST = (currentAST.
root);
05733 }
05734
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05735
if( inputState->guessing == 0 ) {
05736
reportError(ex);
05737 consume();
05738 consumeUntil(
_tokenSet_59);
05739 }
else {
05740
throw;
05741 }
05742 }
05743
returnAST = align_opt_AST;
05744 }
05745
05746 void AdaParser::comp_loc_s() {
05747
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05748
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05749
RefAdaAST comp_loc_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05750
05751
try {
05752 {
05753
for (;;) {
05754
switch ( LA(1)) {
05755
case PRAGMA:
05756 {
05757
pragma();
05758
if (inputState->guessing==0) {
05759 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05760 }
05761
break;
05762 }
05763
case IDENTIFIER:
05764 {
05765
subtype_mark();
05766
if (inputState->guessing==0) {
05767 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05768 }
05769 match(AT);
05770
expression();
05771
if (inputState->guessing==0) {
05772 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05773 }
05774 match(RANGE);
05775
range();
05776
if (inputState->guessing==0) {
05777 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05778 }
05779 match(SEMI);
05780
break;
05781 }
05782
default:
05783 {
05784
goto _loop160;
05785 }
05786 }
05787 }
05788 _loop160:;
05789 }
05790
if ( inputState->guessing==0 ) {
05791 comp_loc_s_AST =
RefAdaAST(currentAST.
root);
05792
#line 517 "ada.g"
05793
comp_loc_s_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_CLAUSES_OPT,
"COMPONENT_CLAUSES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(comp_loc_s_AST.get()))));
05794
#line 5795 "AdaParser.cpp"
05795
currentAST.
root = comp_loc_s_AST;
05796
if ( comp_loc_s_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05797 comp_loc_s_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05798 currentAST.
child = comp_loc_s_AST->getFirstChild();
05799
else
05800 currentAST.
child = comp_loc_s_AST;
05801 currentAST.
advanceChildToEnd();
05802 }
05803 comp_loc_s_AST = (currentAST.
root);
05804 }
05805
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05806
if( inputState->guessing == 0 ) {
05807
reportError(ex);
05808 consume();
05809 consumeUntil(
_tokenSet_21);
05810 }
else {
05811
throw;
05812 }
05813 }
05814
returnAST = comp_loc_s_AST;
05815 }
05816
05817 void AdaParser::protected_definition() {
05818
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05819
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05820
RefAdaAST protected_definition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05821
05822
try {
05823 match(IS);
05824
prot_op_decl_s();
05825
if (inputState->guessing==0) {
05826 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05827 }
05828 {
05829
switch ( LA(1)) {
05830
case PRIVATE:
05831 {
05832 match(PRIVATE);
05833
prot_member_decl_s();
05834
if (inputState->guessing==0) {
05835 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05836 }
05837
break;
05838 }
05839
case END:
05840 {
05841
break;
05842 }
05843
default:
05844 {
05845
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
05846 }
05847 }
05848 }
05849
end_id_opt();
05850 protected_definition_AST = (currentAST.
root);
05851 }
05852
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05853
if( inputState->guessing == 0 ) {
05854
reportError(ex);
05855 consume();
05856 consumeUntil(
_tokenSet_4);
05857 }
else {
05858
throw;
05859 }
05860 }
05861
returnAST = protected_definition_AST;
05862 }
05863
05864 void AdaParser::prot_op_decl_s() {
05865
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05866
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05867
RefAdaAST prot_op_decl_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05868
05869
try {
05870 {
05871
for (;;) {
05872
if ((
_tokenSet_60.member(LA(1)))) {
05873
prot_op_decl();
05874
if (inputState->guessing==0) {
05875 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05876 }
05877 }
05878
else {
05879
goto _loop170;
05880 }
05881
05882 }
05883 _loop170:;
05884 }
05885
if ( inputState->guessing==0 ) {
05886 prot_op_decl_s_AST =
RefAdaAST(currentAST.
root);
05887
#line 541 "ada.g"
05888
prot_op_decl_s_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_OP_DECLARATIONS,
"PROT_OP_DECLARATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_op_decl_s_AST.get()))));
05889
#line 5890 "AdaParser.cpp"
05890
currentAST.
root = prot_op_decl_s_AST;
05891
if ( prot_op_decl_s_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05892 prot_op_decl_s_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05893 currentAST.
child = prot_op_decl_s_AST->getFirstChild();
05894
else
05895 currentAST.
child = prot_op_decl_s_AST;
05896 currentAST.
advanceChildToEnd();
05897 }
05898 prot_op_decl_s_AST = (currentAST.
root);
05899 }
05900
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05901
if( inputState->guessing == 0 ) {
05902
reportError(ex);
05903 consume();
05904 consumeUntil(
_tokenSet_49);
05905 }
else {
05906
throw;
05907 }
05908 }
05909
returnAST = prot_op_decl_s_AST;
05910 }
05911
05912 void AdaParser::prot_member_decl_s() {
05913
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05914
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05915
RefAdaAST prot_member_decl_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05916
05917
try {
05918 {
05919
for (;;) {
05920
switch ( LA(1)) {
05921
case PRAGMA:
05922
case PROCEDURE:
05923
case FUNCTION:
05924
case ENTRY:
05925
case FOR:
05926 {
05927
prot_op_decl();
05928
if (inputState->guessing==0) {
05929 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05930 }
05931
break;
05932 }
05933
case IDENTIFIER:
05934 {
05935
comp_decl();
05936
if (inputState->guessing==0) {
05937 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05938 }
05939
break;
05940 }
05941
default:
05942 {
05943
goto _loop174;
05944 }
05945 }
05946 }
05947 _loop174:;
05948 }
05949
if ( inputState->guessing==0 ) {
05950 prot_member_decl_s_AST =
RefAdaAST(currentAST.
root);
05951
#line 555 "ada.g"
05952
prot_member_decl_s_AST =
05953
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_MEMBER_DECLARATIONS,
"PROT_MEMBER_DECLARATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_member_decl_s_AST.get()))));
05954
#line 5955 "AdaParser.cpp"
05955
currentAST.
root = prot_member_decl_s_AST;
05956
if ( prot_member_decl_s_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
05957 prot_member_decl_s_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
05958 currentAST.
child = prot_member_decl_s_AST->getFirstChild();
05959
else
05960 currentAST.
child = prot_member_decl_s_AST;
05961 currentAST.
advanceChildToEnd();
05962 }
05963 prot_member_decl_s_AST = (currentAST.
root);
05964 }
05965
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05966
if( inputState->guessing == 0 ) {
05967
reportError(ex);
05968 consume();
05969 consumeUntil(
_tokenSet_21);
05970 }
else {
05971
throw;
05972 }
05973 }
05974
returnAST = prot_member_decl_s_AST;
05975 }
05976
05977 void AdaParser::prot_op_decl() {
05978
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05979
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
05980
RefAdaAST prot_op_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05981
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05982
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05983
ANTLR_USE_NAMESPACE(antlr)
RefToken f =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
05984
RefAdaAST f_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
05985
05986
try {
05987
switch ( LA(1)) {
05988
case ENTRY:
05989 {
05990
entry_declaration();
05991
if (inputState->guessing==0) {
05992 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
05993 }
05994 prot_op_decl_AST = (currentAST.
root);
05995
break;
05996 }
05997
case PROCEDURE:
05998 {
05999 p = LT(1);
06000
if ( inputState->guessing == 0 ) {
06001 p_AST = astFactory->create(p);
06002 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
06003 }
06004 match(PROCEDURE);
06005
def_id(
false);
06006
if (inputState->guessing==0) {
06007 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06008 }
06009
formal_part_opt();
06010
if (inputState->guessing==0) {
06011 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06012 }
06013 match(SEMI);
06014
if ( inputState->guessing==0 ) {
06015
#line 547 "ada.g"
06016
pop_def_id();
Set(p_AST, PROCEDURE_DECLARATION);
06017
#line 6018 "AdaParser.cpp"
06018
}
06019 prot_op_decl_AST = (currentAST.
root);
06020
break;
06021 }
06022
case FUNCTION:
06023 {
06024 f = LT(1);
06025
if ( inputState->guessing == 0 ) {
06026 f_AST = astFactory->create(f);
06027 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
06028 }
06029 match(FUNCTION);
06030
def_designator(
false);
06031
if (inputState->guessing==0) {
06032 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06033 }
06034
function_tail();
06035
if (inputState->guessing==0) {
06036 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06037 }
06038 match(SEMI);
06039
if ( inputState->guessing==0 ) {
06040
#line 549 "ada.g"
06041
pop_def_id();
Set(f_AST, FUNCTION_DECLARATION);
06042
#line 6043 "AdaParser.cpp"
06043
}
06044 prot_op_decl_AST = (currentAST.
root);
06045
break;
06046 }
06047
case FOR:
06048 {
06049
rep_spec();
06050
if (inputState->guessing==0) {
06051 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06052 }
06053 prot_op_decl_AST = (currentAST.
root);
06054
break;
06055 }
06056
case PRAGMA:
06057 {
06058
pragma();
06059
if (inputState->guessing==0) {
06060 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06061 }
06062 prot_op_decl_AST = (currentAST.
root);
06063
break;
06064 }
06065
default:
06066 {
06067
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06068 }
06069 }
06070 }
06071
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06072
if( inputState->guessing == 0 ) {
06073
reportError(ex);
06074 consume();
06075 consumeUntil(
_tokenSet_54);
06076 }
else {
06077
throw;
06078 }
06079 }
06080
returnAST = prot_op_decl_AST;
06081 }
06082
06083 void AdaParser::comp_decl() {
06084
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06085
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06086
RefAdaAST comp_decl_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06087
06088
try {
06089
def_ids_colon();
06090
if (inputState->guessing==0) {
06091 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06092 }
06093
component_subtype_def();
06094
if (inputState->guessing==0) {
06095 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06096 }
06097
init_opt();
06098
if (inputState->guessing==0) {
06099 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06100 }
06101 match(SEMI);
06102
if ( inputState->guessing==0 ) {
06103 comp_decl_AST =
RefAdaAST(currentAST.
root);
06104
#line 561 "ada.g"
06105
comp_decl_AST =
06106
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_DECLARATION,
"COMPONENT_DECLARATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(comp_decl_AST.get()))));
06107
#line 6108 "AdaParser.cpp"
06108
currentAST.
root = comp_decl_AST;
06109
if ( comp_decl_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
06110 comp_decl_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
06111 currentAST.
child = comp_decl_AST->getFirstChild();
06112
else
06113 currentAST.
child = comp_decl_AST;
06114 currentAST.
advanceChildToEnd();
06115 }
06116 comp_decl_AST = (currentAST.
root);
06117 }
06118
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06119
if( inputState->guessing == 0 ) {
06120
reportError(ex);
06121 consume();
06122 consumeUntil(
_tokenSet_61);
06123 }
else {
06124
throw;
06125 }
06126 }
06127
returnAST = comp_decl_AST;
06128 }
06129
06130 void AdaParser::component_subtype_def() {
06131
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06132
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06133
RefAdaAST component_subtype_def_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06134
06135
try {
06136
aliased_opt();
06137
if (inputState->guessing==0) {
06138 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06139 }
06140
subtype_ind();
06141
if (inputState->guessing==0) {
06142 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06143 }
06144 component_subtype_def_AST = (currentAST.
root);
06145 }
06146
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06147
if( inputState->guessing == 0 ) {
06148
reportError(ex);
06149 consume();
06150 consumeUntil(
_tokenSet_62);
06151 }
else {
06152
throw;
06153 }
06154 }
06155
returnAST = component_subtype_def_AST;
06156 }
06157
06158 void AdaParser::type_def(
06159 RefAdaAST t
06160 ) {
06161
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06162
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06163
RefAdaAST type_def_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06164
06165
try {
06166
switch ( LA(1)) {
06167
case LPAREN:
06168 {
06169 match(LPAREN);
06170
enum_id_s();
06171
if (inputState->guessing==0) {
06172 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06173 }
06174 match(RPAREN);
06175
if ( inputState->guessing==0 ) {
06176
#line 624 "ada.g"
06177
Set(t, ENUMERATION_TYPE_DECLARATION);
06178
#line 6179 "AdaParser.cpp"
06179
}
06180 type_def_AST = (currentAST.
root);
06181
break;
06182 }
06183
case RANGE:
06184 {
06185 match(RANGE);
06186
range();
06187
if (inputState->guessing==0) {
06188 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06189 }
06190
if ( inputState->guessing==0 ) {
06191
#line 626 "ada.g"
06192
Set(t, SIGNED_INTEGER_TYPE_DECLARATION);
06193
#line 6194 "AdaParser.cpp"
06194
}
06195 type_def_AST = (currentAST.
root);
06196
break;
06197 }
06198
case MOD:
06199 {
06200 match(MOD);
06201
expression();
06202
if (inputState->guessing==0) {
06203 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06204 }
06205
if ( inputState->guessing==0 ) {
06206
#line 628 "ada.g"
06207
Set(t, MODULAR_TYPE_DECLARATION);
06208
#line 6209 "AdaParser.cpp"
06209
}
06210 type_def_AST = (currentAST.
root);
06211
break;
06212 }
06213
case DIGITS:
06214 {
06215 match(DIGITS);
06216
expression();
06217
if (inputState->guessing==0) {
06218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06219 }
06220
range_constraint_opt();
06221
if (inputState->guessing==0) {
06222 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06223 }
06224
if ( inputState->guessing==0 ) {
06225
#line 630 "ada.g"
06226
Set(t, FLOATING_POINT_DECLARATION);
06227
#line 6228 "AdaParser.cpp"
06228
}
06229 type_def_AST = (currentAST.
root);
06230
break;
06231 }
06232
case DELTA:
06233 {
06234 match(DELTA);
06235
expression();
06236
if (inputState->guessing==0) {
06237 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06238 }
06239 {
06240
switch ( LA(1)) {
06241
case RANGE:
06242 {
06243 match(RANGE);
06244
range();
06245
if (inputState->guessing==0) {
06246 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06247 }
06248
if ( inputState->guessing==0 ) {
06249
#line 633 "ada.g"
06250
Set(t, ORDINARY_FIXED_POINT_DECLARATION);
06251
#line 6252 "AdaParser.cpp"
06252
}
06253
break;
06254 }
06255
case DIGITS:
06256 {
06257 match(DIGITS);
06258
expression();
06259
if (inputState->guessing==0) {
06260 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06261 }
06262
range_constraint_opt();
06263
if (inputState->guessing==0) {
06264 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06265 }
06266
if ( inputState->guessing==0 ) {
06267
#line 635 "ada.g"
06268
Set(t, DECIMAL_FIXED_POINT_DECLARATION);
06269
#line 6270 "AdaParser.cpp"
06270
}
06271
break;
06272 }
06273
default:
06274 {
06275
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06276 }
06277 }
06278 }
06279 type_def_AST = (currentAST.
root);
06280
break;
06281 }
06282
case ARRAY:
06283 {
06284
array_type_definition(t);
06285
if (inputState->guessing==0) {
06286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06287 }
06288 type_def_AST = (currentAST.
root);
06289
break;
06290 }
06291
case ACCESS:
06292 {
06293
access_type_definition(t);
06294
if (inputState->guessing==0) {
06295 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06296 }
06297 type_def_AST = (currentAST.
root);
06298
break;
06299 }
06300
case PRIVATE:
06301
case NEW:
06302
case NuLL:
06303
case RECORD:
06304
case ABSTRACT:
06305
case TAGGED:
06306
case LIMITED:
06307 {
06308
empty_discrim_opt();
06309
if (inputState->guessing==0) {
06310 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06311 }
06312
derived_or_private_or_record(t,
false);
06313
if (inputState->guessing==0) {
06314 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06315 }
06316 type_def_AST = (currentAST.
root);
06317
break;
06318 }
06319
default:
06320 {
06321
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06322 }
06323 }
06324 }
06325
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06326
if( inputState->guessing == 0 ) {
06327
reportError(ex);
06328 consume();
06329 consumeUntil(
_tokenSet_4);
06330 }
else {
06331
throw;
06332 }
06333 }
06334
returnAST = type_def_AST;
06335 }
06336
06337 void AdaParser::derived_or_private_or_record(
06338 RefAdaAST t,
bool has_discrim
06339 ) {
06340
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06341
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06342
RefAdaAST derived_or_private_or_record_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06343
06344
try {
06345
bool synPredMatched244 =
false;
06346
if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
06347
int _m244 = mark();
06348 synPredMatched244 =
true;
06349 inputState->guessing++;
06350
try {
06351 {
06352 {
06353
switch ( LA(1)) {
06354
case ABSTRACT:
06355 {
06356 match(ABSTRACT);
06357
break;
06358 }
06359
case NEW:
06360 {
06361
break;
06362 }
06363
default:
06364 {
06365
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06366 }
06367 }
06368 }
06369 match(NEW);
06370
subtype_ind();
06371 match(WITH);
06372 }
06373 }
06374
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
06375 synPredMatched244 =
false;
06376 }
06377 rewind(_m244);
06378 inputState->guessing--;
06379 }
06380
if ( synPredMatched244 ) {
06381
abstract_opt();
06382
if (inputState->guessing==0) {
06383 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06384 }
06385 match(NEW);
06386
subtype_ind();
06387
if (inputState->guessing==0) {
06388 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06389 }
06390 match(WITH);
06391 {
06392
switch ( LA(1)) {
06393
case PRIVATE:
06394 {
06395 match(PRIVATE);
06396
if ( inputState->guessing==0 ) {
06397
#line 758 "ada.g"
06398
Set(t, PRIVATE_EXTENSION_DECLARATION);
06399
#line 6400 "AdaParser.cpp"
06400
}
06401
break;
06402 }
06403
case NuLL:
06404
case RECORD:
06405 {
06406
record_definition(has_discrim);
06407
if (inputState->guessing==0) {
06408 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06409 }
06410
if ( inputState->guessing==0 ) {
06411
#line 760 "ada.g"
06412
Set(t, DERIVED_RECORD_EXTENSION);
06413
#line 6414 "AdaParser.cpp"
06414
}
06415
break;
06416 }
06417
default:
06418 {
06419
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06420 }
06421 }
06422 }
06423 derived_or_private_or_record_AST = (currentAST.
root);
06424 }
06425
else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
06426 match(NEW);
06427
subtype_ind();
06428
if (inputState->guessing==0) {
06429 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06430 }
06431
if ( inputState->guessing==0 ) {
06432
#line 762 "ada.g"
06433
Set(t, ORDINARY_DERIVED_TYPE_DECLARATION);
06434
#line 6435 "AdaParser.cpp"
06435
}
06436 derived_or_private_or_record_AST = (currentAST.
root);
06437 }
06438
else if ((
_tokenSet_63.member(LA(1))) && (
_tokenSet_64.member(LA(2)))) {
06439
abstract_tagged_limited_opt();
06440
if (inputState->guessing==0) {
06441 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06442 }
06443 {
06444
switch ( LA(1)) {
06445
case PRIVATE:
06446 {
06447 match(PRIVATE);
06448
if ( inputState->guessing==0 ) {
06449
#line 764 "ada.g"
06450
Set(t, PRIVATE_TYPE_DECLARATION);
06451
#line 6452 "AdaParser.cpp"
06452
}
06453
break;
06454 }
06455
case NuLL:
06456
case RECORD:
06457 {
06458
record_definition(has_discrim);
06459
if (inputState->guessing==0) {
06460 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06461 }
06462
if ( inputState->guessing==0 ) {
06463
#line 766 "ada.g"
06464
Set(t, RECORD_TYPE_DECLARATION);
06465
#line 6466 "AdaParser.cpp"
06466
}
06467
break;
06468 }
06469
default:
06470 {
06471
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06472 }
06473 }
06474 }
06475 derived_or_private_or_record_AST = (currentAST.
root);
06476 }
06477
else {
06478
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06479 }
06480
06481 }
06482
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06483
if( inputState->guessing == 0 ) {
06484
reportError(ex);
06485 consume();
06486 consumeUntil(
_tokenSet_4);
06487 }
else {
06488
throw;
06489 }
06490 }
06491
returnAST = derived_or_private_or_record_AST;
06492 }
06493
06494 void AdaParser::local_enum_name() {
06495
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06496
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06497
RefAdaAST local_enum_name_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06498
06499
try {
06500
RefAdaAST tmp179_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06501
if ( inputState->guessing == 0 ) {
06502 tmp179_AST = astFactory->create(LT(1));
06503 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp179_AST.get()));
06504 }
06505 match(IDENTIFIER);
06506 local_enum_name_AST = (currentAST.
root);
06507 }
06508
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06509
if( inputState->guessing == 0 ) {
06510
reportError(ex);
06511 consume();
06512 consumeUntil(
_tokenSet_65);
06513 }
else {
06514
throw;
06515 }
06516 }
06517
returnAST = local_enum_name_AST;
06518 }
06519
06520 void AdaParser::enumeration_aggregate() {
06521
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06522
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06523
RefAdaAST enumeration_aggregate_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06524
06525
try {
06526
parenth_values();
06527
if (inputState->guessing==0) {
06528 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06529 }
06530 enumeration_aggregate_AST = (currentAST.
root);
06531 }
06532
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06533
if( inputState->guessing == 0 ) {
06534
reportError(ex);
06535 consume();
06536 consumeUntil(
_tokenSet_4);
06537 }
else {
06538
throw;
06539 }
06540 }
06541
returnAST = enumeration_aggregate_AST;
06542 }
06543
06544 void AdaParser::aliased_constant_opt() {
06545
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06546
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06547
RefAdaAST aliased_constant_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06548
06549
try {
06550 {
06551
switch ( LA(1)) {
06552
case ALIASED:
06553 {
06554
RefAdaAST tmp180_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06555
if ( inputState->guessing == 0 ) {
06556 tmp180_AST = astFactory->create(LT(1));
06557 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp180_AST.get()));
06558 }
06559 match(ALIASED);
06560
break;
06561 }
06562
case IDENTIFIER:
06563
case CONSTANT:
06564
case ARRAY:
06565 {
06566
break;
06567 }
06568
default:
06569 {
06570
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06571 }
06572 }
06573 }
06574 {
06575
switch ( LA(1)) {
06576
case CONSTANT:
06577 {
06578
RefAdaAST tmp181_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06579
if ( inputState->guessing == 0 ) {
06580 tmp181_AST = astFactory->create(LT(1));
06581 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp181_AST.get()));
06582 }
06583 match(CONSTANT);
06584
break;
06585 }
06586
case IDENTIFIER:
06587
case ARRAY:
06588 {
06589
break;
06590 }
06591
default:
06592 {
06593
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06594 }
06595 }
06596 }
06597
if ( inputState->guessing==0 ) {
06598 aliased_constant_opt_AST =
RefAdaAST(currentAST.
root);
06599
#line 844 "ada.g"
06600
aliased_constant_opt_AST =
06601
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(aliased_constant_opt_AST.get()))));
06602
#line 6603 "AdaParser.cpp"
06603
currentAST.
root = aliased_constant_opt_AST;
06604
if ( aliased_constant_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
06605 aliased_constant_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
06606 currentAST.
child = aliased_constant_opt_AST->getFirstChild();
06607
else
06608 currentAST.
child = aliased_constant_opt_AST;
06609 currentAST.
advanceChildToEnd();
06610 }
06611 aliased_constant_opt_AST = (currentAST.
root);
06612 }
06613
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06614
if( inputState->guessing == 0 ) {
06615
reportError(ex);
06616 consume();
06617 consumeUntil(
_tokenSet_66);
06618 }
else {
06619
throw;
06620 }
06621 }
06622
returnAST = aliased_constant_opt_AST;
06623 }
06624
06625 void AdaParser::array_type_definition(
06626 RefAdaAST t
06627 ) {
06628
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06629
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06630
RefAdaAST array_type_definition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06631
06632
try {
06633 match(ARRAY);
06634 match(LPAREN);
06635
index_or_discrete_range_s();
06636
if (inputState->guessing==0) {
06637 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06638 }
06639 match(RPAREN);
06640 match(OF);
06641
component_subtype_def();
06642
if (inputState->guessing==0) {
06643 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06644 }
06645
if ( inputState->guessing==0 ) {
06646
#line 655 "ada.g"
06647
Set(t, ARRAY_TYPE_DECLARATION);
06648
#line 6649 "AdaParser.cpp"
06649
}
06650 array_type_definition_AST = (currentAST.
root);
06651 }
06652
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06653
if( inputState->guessing == 0 ) {
06654
reportError(ex);
06655 consume();
06656 consumeUntil(
_tokenSet_62);
06657 }
else {
06658
throw;
06659 }
06660 }
06661
returnAST = array_type_definition_AST;
06662 }
06663
06664 void AdaParser::enum_id_s() {
06665
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06666
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06667
RefAdaAST enum_id_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06668
06669
try {
06670
enumeration_literal_specification();
06671
if (inputState->guessing==0) {
06672 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06673 }
06674 {
06675
for (;;) {
06676
if ((LA(1) == COMMA)) {
06677 match(COMMA);
06678
enumeration_literal_specification();
06679
if (inputState->guessing==0) {
06680 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06681 }
06682 }
06683
else {
06684
goto _loop195;
06685 }
06686
06687 }
06688 _loop195:;
06689 }
06690 enum_id_s_AST = (currentAST.
root);
06691 }
06692
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06693
if( inputState->guessing == 0 ) {
06694
reportError(ex);
06695 consume();
06696 consumeUntil(
_tokenSet_47);
06697 }
else {
06698
throw;
06699 }
06700 }
06701
returnAST = enum_id_s_AST;
06702 }
06703
06704 void AdaParser::range_constraint_opt() {
06705
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06706
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06707
RefAdaAST range_constraint_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06708
06709
try {
06710 {
06711
switch ( LA(1)) {
06712
case RANGE:
06713 {
06714
range_constraint();
06715
if (inputState->guessing==0) {
06716 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06717 }
06718
break;
06719 }
06720
case SEMI:
06721
case COMMA:
06722
case RPAREN:
06723
case WITH:
06724
case ASSIGN:
06725
case LOOP:
06726 {
06727
break;
06728 }
06729
default:
06730 {
06731
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06732 }
06733 }
06734 }
06735 range_constraint_opt_AST = (currentAST.
root);
06736 }
06737
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06738
if( inputState->guessing == 0 ) {
06739
reportError(ex);
06740 consume();
06741 consumeUntil(
_tokenSet_58);
06742 }
else {
06743
throw;
06744 }
06745 }
06746
returnAST = range_constraint_opt_AST;
06747 }
06748
06749 void AdaParser::access_type_definition(
06750 RefAdaAST t
06751 ) {
06752
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06753
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06754
RefAdaAST access_type_definition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06755
06756
try {
06757 match(ACCESS);
06758 {
06759
switch ( LA(1)) {
06760
case PROCEDURE:
06761
case FUNCTION:
06762
case PROTECTED:
06763 {
06764
protected_opt();
06765
if (inputState->guessing==0) {
06766 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06767 }
06768 {
06769
switch ( LA(1)) {
06770
case PROCEDURE:
06771 {
06772 match(PROCEDURE);
06773
formal_part_opt();
06774
if (inputState->guessing==0) {
06775 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06776 }
06777
if ( inputState->guessing==0 ) {
06778
#line 737 "ada.g"
06779
Set(t, ACCESS_TO_PROCEDURE_DECLARATION);
06780
#line 6781 "AdaParser.cpp"
06781
}
06782
break;
06783 }
06784
case FUNCTION:
06785 {
06786 match(FUNCTION);
06787
func_formal_part_opt();
06788
if (inputState->guessing==0) {
06789 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06790 }
06791 match(RETURN);
06792
subtype_mark();
06793
if (inputState->guessing==0) {
06794 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06795 }
06796
if ( inputState->guessing==0 ) {
06797
#line 739 "ada.g"
06798
Set(t, ACCESS_TO_FUNCTION_DECLARATION);
06799
#line 6800 "AdaParser.cpp"
06800
}
06801
break;
06802 }
06803
default:
06804 {
06805
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06806 }
06807 }
06808 }
06809
break;
06810 }
06811
case IDENTIFIER:
06812
case ALL:
06813
case CONSTANT:
06814 {
06815
constant_all_opt();
06816
if (inputState->guessing==0) {
06817 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06818 }
06819
subtype_ind();
06820
if (inputState->guessing==0) {
06821 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06822 }
06823
if ( inputState->guessing==0 ) {
06824
#line 742 "ada.g"
06825
Set(t, ACCESS_TO_OBJECT_DECLARATION);
06826
#line 6827 "AdaParser.cpp"
06827
}
06828
break;
06829 }
06830
default:
06831 {
06832
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06833 }
06834 }
06835 }
06836 access_type_definition_AST = (currentAST.
root);
06837 }
06838
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06839
if( inputState->guessing == 0 ) {
06840
reportError(ex);
06841 consume();
06842 consumeUntil(
_tokenSet_4);
06843 }
else {
06844
throw;
06845 }
06846 }
06847
returnAST = access_type_definition_AST;
06848 }
06849
06850 void AdaParser::enumeration_literal_specification() {
06851
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06852
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06853
RefAdaAST enumeration_literal_specification_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06854
06855
try {
06856
switch ( LA(1)) {
06857
case IDENTIFIER:
06858 {
06859
RefAdaAST tmp191_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06860
if ( inputState->guessing == 0 ) {
06861 tmp191_AST = astFactory->create(LT(1));
06862 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp191_AST.get()));
06863 }
06864 match(IDENTIFIER);
06865 enumeration_literal_specification_AST = (currentAST.
root);
06866
break;
06867 }
06868
case CHARACTER_LITERAL:
06869 {
06870
RefAdaAST tmp192_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06871
if ( inputState->guessing == 0 ) {
06872 tmp192_AST = astFactory->create(LT(1));
06873 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp192_AST.get()));
06874 }
06875 match(CHARACTER_LITERAL);
06876 enumeration_literal_specification_AST = (currentAST.
root);
06877
break;
06878 }
06879
default:
06880 {
06881
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
06882 }
06883 }
06884 }
06885
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06886
if( inputState->guessing == 0 ) {
06887
reportError(ex);
06888 consume();
06889 consumeUntil(
_tokenSet_7);
06890 }
else {
06891
throw;
06892 }
06893 }
06894
returnAST = enumeration_literal_specification_AST;
06895 }
06896
06897 void AdaParser::index_or_discrete_range_s() {
06898
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06899
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06900
RefAdaAST index_or_discrete_range_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06901
06902
try {
06903
index_or_discrete_range();
06904
if (inputState->guessing==0) {
06905 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06906 }
06907 {
06908
for (;;) {
06909
if ((LA(1) == COMMA)) {
06910
RefAdaAST tmp193_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06911
if ( inputState->guessing == 0 ) {
06912 tmp193_AST = astFactory->create(LT(1));
06913 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp193_AST.get()));
06914 }
06915 match(COMMA);
06916
index_or_discrete_range();
06917
if (inputState->guessing==0) {
06918 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06919 }
06920 }
06921
else {
06922
goto _loop202;
06923 }
06924
06925 }
06926 _loop202:;
06927 }
06928 index_or_discrete_range_s_AST = (currentAST.
root);
06929 }
06930
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06931
if( inputState->guessing == 0 ) {
06932
reportError(ex);
06933 consume();
06934 consumeUntil(
_tokenSet_47);
06935 }
else {
06936
throw;
06937 }
06938 }
06939
returnAST = index_or_discrete_range_s_AST;
06940 }
06941
06942 void AdaParser::index_or_discrete_range() {
06943
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06944
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
06945
RefAdaAST index_or_discrete_range_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06946
06947
try {
06948
simple_expression();
06949
if (inputState->guessing==0) {
06950 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06951 }
06952 {
06953
switch ( LA(1)) {
06954
case DOT_DOT:
06955 {
06956
RefAdaAST tmp194_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06957
if ( inputState->guessing == 0 ) {
06958 tmp194_AST = astFactory->create(LT(1));
06959 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp194_AST.get()));
06960 }
06961 match(DOT_DOT);
06962
simple_expression();
06963
if (inputState->guessing==0) {
06964 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
06965 }
06966
break;
06967 }
06968
case RANGE:
06969 {
06970
RefAdaAST tmp195_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06971
if ( inputState->guessing == 0 ) {
06972 tmp195_AST = astFactory->create(LT(1));
06973 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp195_AST.get()));
06974 }
06975 match(RANGE);
06976 {
06977
switch ( LA(1)) {
06978
case BOX:
06979 {
06980
RefAdaAST tmp196_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
06981
if ( inputState->guessing == 0 ) {
06982 tmp196_AST = astFactory->create(LT(1));
06983 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp196_AST.get()));
06984 }
06985 match(BOX);
06986
break;
06987 }
06988
case IDENTIFIER:
06989
case LPAREN:
06990
case NEW:
06991
case CHARACTER_LITERAL:
06992
case CHAR_STRING:
06993
case NuLL:
06994
case NOT:
06995
case PLUS:
06996
case MINUS:
06997
case ABS:
06998
case NUMERIC_LIT:
06999 {
07000
range();
07001
if (inputState->guessing==0) {
07002 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07003 }
07004
break;
07005 }
07006
default:
07007 {
07008
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07009 }
07010 }
07011 }
07012
break;
07013 }
07014
case COMMA:
07015
case RPAREN:
07016 {
07017
break;
07018 }
07019
default:
07020 {
07021
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07022 }
07023 }
07024 }
07025 index_or_discrete_range_AST = (currentAST.
root);
07026 }
07027
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07028
if( inputState->guessing == 0 ) {
07029
reportError(ex);
07030 consume();
07031 consumeUntil(
_tokenSet_7);
07032 }
else {
07033
throw;
07034 }
07035 }
07036
returnAST = index_or_discrete_range_AST;
07037 }
07038
07039 void AdaParser::aliased_opt() {
07040
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07041
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07042
RefAdaAST aliased_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07043
07044
try {
07045 {
07046
switch ( LA(1)) {
07047
case ALIASED:
07048 {
07049
RefAdaAST tmp197_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07050
if ( inputState->guessing == 0 ) {
07051 tmp197_AST = astFactory->create(LT(1));
07052 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp197_AST.get()));
07053 }
07054 match(ALIASED);
07055
break;
07056 }
07057
case IDENTIFIER:
07058 {
07059
break;
07060 }
07061
default:
07062 {
07063
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07064 }
07065 }
07066 }
07067
if ( inputState->guessing==0 ) {
07068 aliased_opt_AST =
RefAdaAST(currentAST.
root);
07069
#line 675 "ada.g"
07070
aliased_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(aliased_opt_AST.get()))));
07071
#line 7072 "AdaParser.cpp"
07072
currentAST.
root = aliased_opt_AST;
07073
if ( aliased_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07074 aliased_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07075 currentAST.
child = aliased_opt_AST->getFirstChild();
07076
else
07077 currentAST.
child = aliased_opt_AST;
07078 currentAST.
advanceChildToEnd();
07079 }
07080 aliased_opt_AST = (currentAST.
root);
07081 }
07082
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07083
if( inputState->guessing == 0 ) {
07084
reportError(ex);
07085 consume();
07086 consumeUntil(
_tokenSet_39);
07087 }
else {
07088
throw;
07089 }
07090 }
07091
returnAST = aliased_opt_AST;
07092 }
07093
07094 void AdaParser::constraint_opt() {
07095
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07096
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07097
RefAdaAST constraint_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07098
07099
try {
07100 {
07101
switch ( LA(1)) {
07102
case RANGE:
07103 {
07104
range_constraint();
07105
if (inputState->guessing==0) {
07106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07107 }
07108
break;
07109 }
07110
case DIGITS:
07111 {
07112
digits_constraint();
07113
if (inputState->guessing==0) {
07114 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07115 }
07116
break;
07117 }
07118
case DELTA:
07119 {
07120
delta_constraint();
07121
if (inputState->guessing==0) {
07122 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07123 }
07124
break;
07125 }
07126
case SEMI:
07127
case COMMA:
07128
case RPAREN:
07129
case WITH:
07130
case ASSIGN:
07131
case LOOP:
07132 {
07133
break;
07134 }
07135
default:
07136
bool synPredMatched213 =
false;
07137
if (((LA(1) == LPAREN) && (
_tokenSet_5.member(LA(2))))) {
07138
int _m213 = mark();
07139 synPredMatched213 =
true;
07140 inputState->guessing++;
07141
try {
07142 {
07143
index_constraint();
07144 }
07145 }
07146
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
07147 synPredMatched213 =
false;
07148 }
07149 rewind(_m213);
07150 inputState->guessing--;
07151 }
07152
if ( synPredMatched213 ) {
07153
index_constraint();
07154
if (inputState->guessing==0) {
07155 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07156 }
07157 }
07158
else if ((LA(1) == LPAREN) && (
_tokenSet_5.member(LA(2)))) {
07159
discriminant_constraint();
07160
if (inputState->guessing==0) {
07161 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07162 }
07163 }
07164
else {
07165
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07166 }
07167 }
07168 }
07169 constraint_opt_AST = (currentAST.
root);
07170 }
07171
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07172
if( inputState->guessing == 0 ) {
07173
reportError(ex);
07174 consume();
07175 consumeUntil(
_tokenSet_58);
07176 }
else {
07177
throw;
07178 }
07179 }
07180
returnAST = constraint_opt_AST;
07181 }
07182
07183 void AdaParser::digits_constraint() {
07184
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07185
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07186
RefAdaAST digits_constraint_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07187
ANTLR_USE_NAMESPACE(antlr)
RefToken d =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
07188
RefAdaAST d_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07189
07190
try {
07191 d = LT(1);
07192
if ( inputState->guessing == 0 ) {
07193 d_AST = astFactory->create(d);
07194 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get()));
07195 }
07196 match(DIGITS);
07197
expression();
07198
if (inputState->guessing==0) {
07199 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07200 }
07201
range_constraint_opt();
07202
if (inputState->guessing==0) {
07203 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07204 }
07205
if ( inputState->guessing==0 ) {
07206
#line 692 "ada.g"
07207
Set(d_AST, DIGITS_CONSTRAINT);
07208
#line 7209 "AdaParser.cpp"
07209
}
07210 digits_constraint_AST = (currentAST.
root);
07211 }
07212
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07213
if( inputState->guessing == 0 ) {
07214
reportError(ex);
07215 consume();
07216 consumeUntil(
_tokenSet_58);
07217 }
else {
07218
throw;
07219 }
07220 }
07221
returnAST = digits_constraint_AST;
07222 }
07223
07224 void AdaParser::delta_constraint() {
07225
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07226
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07227
RefAdaAST delta_constraint_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07228
ANTLR_USE_NAMESPACE(antlr)
RefToken d =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
07229
RefAdaAST d_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07230
07231
try {
07232 d = LT(1);
07233
if ( inputState->guessing == 0 ) {
07234 d_AST = astFactory->create(d);
07235 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get()));
07236 }
07237 match(DELTA);
07238
expression();
07239
if (inputState->guessing==0) {
07240 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07241 }
07242
range_constraint_opt();
07243
if (inputState->guessing==0) {
07244 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07245 }
07246
if ( inputState->guessing==0 ) {
07247
#line 696 "ada.g"
07248
Set(d_AST, DELTA_CONSTRAINT);
07249
#line 7250 "AdaParser.cpp"
07250
}
07251 delta_constraint_AST = (currentAST.
root);
07252 }
07253
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07254
if( inputState->guessing == 0 ) {
07255
reportError(ex);
07256 consume();
07257 consumeUntil(
_tokenSet_58);
07258 }
else {
07259
throw;
07260 }
07261 }
07262
returnAST = delta_constraint_AST;
07263 }
07264
07265 void AdaParser::index_constraint() {
07266
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07267
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07268
RefAdaAST index_constraint_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07269
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
07270
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07271
07272
try {
07273 p = LT(1);
07274
if ( inputState->guessing == 0 ) {
07275 p_AST = astFactory->create(p);
07276 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
07277 }
07278 match(LPAREN);
07279
discrete_range();
07280
if (inputState->guessing==0) {
07281 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07282 }
07283 {
07284
for (;;) {
07285
if ((LA(1) == COMMA)) {
07286 match(COMMA);
07287
discrete_range();
07288
if (inputState->guessing==0) {
07289 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07290 }
07291 }
07292
else {
07293
goto _loop218;
07294 }
07295
07296 }
07297 _loop218:;
07298 }
07299 match(RPAREN);
07300
if ( inputState->guessing==0 ) {
07301
#line 700 "ada.g"
07302
Set(p_AST, INDEX_CONSTRAINT);
07303
#line 7304 "AdaParser.cpp"
07304
}
07305 index_constraint_AST = (currentAST.
root);
07306 }
07307
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07308
if( inputState->guessing == 0 ) {
07309
reportError(ex);
07310 consume();
07311 consumeUntil(
_tokenSet_58);
07312 }
else {
07313
throw;
07314 }
07315 }
07316
returnAST = index_constraint_AST;
07317 }
07318
07319 void AdaParser::discriminant_constraint() {
07320
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07321
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07322
RefAdaAST discriminant_constraint_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07323
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
07324
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07325
07326
try {
07327 p = LT(1);
07328
if ( inputState->guessing == 0 ) {
07329 p_AST = astFactory->create(p);
07330 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
07331 }
07332 match(LPAREN);
07333
discriminant_association();
07334
if (inputState->guessing==0) {
07335 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07336 }
07337 {
07338
for (;;) {
07339
if ((LA(1) == COMMA)) {
07340 match(COMMA);
07341
discriminant_association();
07342
if (inputState->guessing==0) {
07343 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07344 }
07345 }
07346
else {
07347
goto _loop224;
07348 }
07349
07350 }
07351 _loop224:;
07352 }
07353 match(RPAREN);
07354
if ( inputState->guessing==0 ) {
07355
#line 710 "ada.g"
07356
Set(p_AST, DISCRIMINANT_CONSTRAINT);
07357
#line 7358 "AdaParser.cpp"
07358
}
07359 discriminant_constraint_AST = (currentAST.
root);
07360 }
07361
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07362
if( inputState->guessing == 0 ) {
07363
reportError(ex);
07364 consume();
07365 consumeUntil(
_tokenSet_58);
07366 }
else {
07367
throw;
07368 }
07369 }
07370
returnAST = discriminant_constraint_AST;
07371 }
07372
07373 void AdaParser::discrete_range() {
07374
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07375
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07376
RefAdaAST discrete_range_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07377
07378
try {
07379
bool synPredMatched221 =
false;
07380
if (((
_tokenSet_5.member(LA(1))) && (
_tokenSet_33.member(LA(2))))) {
07381
int _m221 = mark();
07382 synPredMatched221 =
true;
07383 inputState->guessing++;
07384
try {
07385 {
07386
range();
07387 }
07388 }
07389
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
07390 synPredMatched221 =
false;
07391 }
07392 rewind(_m221);
07393 inputState->guessing--;
07394 }
07395
if ( synPredMatched221 ) {
07396
range();
07397
if (inputState->guessing==0) {
07398 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07399 }
07400 discrete_range_AST = (currentAST.
root);
07401 }
07402
else if ((LA(1) == IDENTIFIER) && (
_tokenSet_67.member(LA(2)))) {
07403
subtype_ind();
07404
if (inputState->guessing==0) {
07405 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07406 }
07407 discrete_range_AST = (currentAST.
root);
07408 }
07409
else {
07410
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07411 }
07412
07413 }
07414
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07415
if( inputState->guessing == 0 ) {
07416
reportError(ex);
07417 consume();
07418 consumeUntil(
_tokenSet_7);
07419 }
else {
07420
throw;
07421 }
07422 }
07423
returnAST = discrete_range_AST;
07424 }
07425
07426 void AdaParser::discriminant_association() {
07427
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07428
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07429
RefAdaAST discriminant_association_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07430
07431
try {
07432
selector_names_opt();
07433
if (inputState->guessing==0) {
07434 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07435 }
07436
expression();
07437
if (inputState->guessing==0) {
07438 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07439 }
07440
if ( inputState->guessing==0 ) {
07441 discriminant_association_AST =
RefAdaAST(currentAST.
root);
07442
#line 714 "ada.g"
07443
discriminant_association_AST =
07444
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_ASSOCIATION,
"DISCRIMINANT_ASSOCIATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_association_AST.get()))));
07445
#line 7446 "AdaParser.cpp"
07446
currentAST.
root = discriminant_association_AST;
07447
if ( discriminant_association_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07448 discriminant_association_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07449 currentAST.
child = discriminant_association_AST->getFirstChild();
07450
else
07451 currentAST.
child = discriminant_association_AST;
07452 currentAST.
advanceChildToEnd();
07453 }
07454 discriminant_association_AST = (currentAST.
root);
07455 }
07456
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07457
if( inputState->guessing == 0 ) {
07458
reportError(ex);
07459 consume();
07460 consumeUntil(
_tokenSet_7);
07461 }
else {
07462
throw;
07463 }
07464 }
07465
returnAST = discriminant_association_AST;
07466 }
07467
07468 void AdaParser::selector_names_opt() {
07469
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07470
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07471
RefAdaAST selector_names_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07472
07473
try {
07474 {
07475
bool synPredMatched229 =
false;
07476
if (((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT || LA(2) == PIPE))) {
07477
int _m229 = mark();
07478 synPredMatched229 =
true;
07479 inputState->guessing++;
07480
try {
07481 {
07482
association_head();
07483 }
07484 }
07485
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
07486 synPredMatched229 =
false;
07487 }
07488 rewind(_m229);
07489 inputState->guessing--;
07490 }
07491
if ( synPredMatched229 ) {
07492
association_head();
07493
if (inputState->guessing==0) {
07494 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07495 }
07496 }
07497
else if ((
_tokenSet_5.member(LA(1))) && (
_tokenSet_6.member(LA(2)))) {
07498 }
07499
else {
07500
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07501 }
07502
07503 }
07504
if ( inputState->guessing==0 ) {
07505 selector_names_opt_AST =
RefAdaAST(currentAST.
root);
07506
#line 722 "ada.g"
07507
selector_names_opt_AST =
07508
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SELECTOR_NAMES_OPT,
"SELECTOR_NAMES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(selector_names_opt_AST.get()))));
07509
#line 7510 "AdaParser.cpp"
07510
currentAST.
root = selector_names_opt_AST;
07511
if ( selector_names_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07512 selector_names_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07513 currentAST.
child = selector_names_opt_AST->getFirstChild();
07514
else
07515 currentAST.
child = selector_names_opt_AST;
07516 currentAST.
advanceChildToEnd();
07517 }
07518 selector_names_opt_AST = (currentAST.
root);
07519 }
07520
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07521
if( inputState->guessing == 0 ) {
07522
reportError(ex);
07523 consume();
07524 consumeUntil(
_tokenSet_5);
07525 }
else {
07526
throw;
07527 }
07528 }
07529
returnAST = selector_names_opt_AST;
07530 }
07531
07532 void AdaParser::association_head() {
07533
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07534
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07535
RefAdaAST association_head_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07536
07537
try {
07538
selector_name();
07539
if (inputState->guessing==0) {
07540 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07541 }
07542 {
07543
for (;;) {
07544
if ((LA(1) == PIPE)) {
07545 match(PIPE);
07546
selector_name();
07547
if (inputState->guessing==0) {
07548 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07549 }
07550 }
07551
else {
07552
goto _loop232;
07553 }
07554
07555 }
07556 _loop232:;
07557 }
07558 match(RIGHT_SHAFT);
07559 association_head_AST = (currentAST.
root);
07560 }
07561
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07562
if( inputState->guessing == 0 ) {
07563
reportError(ex);
07564 consume();
07565 consumeUntil(
_tokenSet_5);
07566 }
else {
07567
throw;
07568 }
07569 }
07570
returnAST = association_head_AST;
07571 }
07572
07573 void AdaParser::selector_name() {
07574
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07575
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07576
RefAdaAST selector_name_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07577
07578
try {
07579
RefAdaAST tmp204_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07580
if ( inputState->guessing == 0 ) {
07581 tmp204_AST = astFactory->create(LT(1));
07582 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp204_AST.get()));
07583 }
07584 match(IDENTIFIER);
07585 selector_name_AST = (currentAST.
root);
07586 }
07587
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07588
if( inputState->guessing == 0 ) {
07589
reportError(ex);
07590 consume();
07591 consumeUntil(
_tokenSet_68);
07592 }
else {
07593
throw;
07594 }
07595 }
07596
returnAST = selector_name_AST;
07597 }
07598
07599 void AdaParser::protected_opt() {
07600
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07601
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07602
RefAdaAST protected_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07603
07604
try {
07605 {
07606
switch ( LA(1)) {
07607
case PROTECTED:
07608 {
07609
RefAdaAST tmp205_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07610
if ( inputState->guessing == 0 ) {
07611 tmp205_AST = astFactory->create(LT(1));
07612 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp205_AST.get()));
07613 }
07614 match(PROTECTED);
07615
break;
07616 }
07617
case PROCEDURE:
07618
case FUNCTION:
07619 {
07620
break;
07621 }
07622
default:
07623 {
07624
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07625 }
07626 }
07627 }
07628
if ( inputState->guessing==0 ) {
07629 protected_opt_AST =
RefAdaAST(currentAST.
root);
07630
#line 747 "ada.g"
07631
protected_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(protected_opt_AST.get()))));
07632
#line 7633 "AdaParser.cpp"
07633
currentAST.
root = protected_opt_AST;
07634
if ( protected_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07635 protected_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07636 currentAST.
child = protected_opt_AST->getFirstChild();
07637
else
07638 currentAST.
child = protected_opt_AST;
07639 currentAST.
advanceChildToEnd();
07640 }
07641 protected_opt_AST = (currentAST.
root);
07642 }
07643
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07644
if( inputState->guessing == 0 ) {
07645
reportError(ex);
07646 consume();
07647 consumeUntil(
_tokenSet_69);
07648 }
else {
07649
throw;
07650 }
07651 }
07652
returnAST = protected_opt_AST;
07653 }
07654
07655 void AdaParser::constant_all_opt() {
07656
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07657
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07658
RefAdaAST constant_all_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07659
07660
try {
07661 {
07662
switch ( LA(1)) {
07663
case CONSTANT:
07664 {
07665
RefAdaAST tmp206_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07666
if ( inputState->guessing == 0 ) {
07667 tmp206_AST = astFactory->create(LT(1));
07668 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp206_AST.get()));
07669 }
07670 match(CONSTANT);
07671
break;
07672 }
07673
case ALL:
07674 {
07675
RefAdaAST tmp207_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07676
if ( inputState->guessing == 0 ) {
07677 tmp207_AST = astFactory->create(LT(1));
07678 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp207_AST.get()));
07679 }
07680 match(ALL);
07681
break;
07682 }
07683
case IDENTIFIER:
07684 {
07685
break;
07686 }
07687
default:
07688 {
07689
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07690 }
07691 }
07692 }
07693
if ( inputState->guessing==0 ) {
07694 constant_all_opt_AST =
RefAdaAST(currentAST.
root);
07695
#line 751 "ada.g"
07696
constant_all_opt_AST =
07697
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(constant_all_opt_AST.get()))));
07698
#line 7699 "AdaParser.cpp"
07699
currentAST.
root = constant_all_opt_AST;
07700
if ( constant_all_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07701 constant_all_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07702 currentAST.
child = constant_all_opt_AST->getFirstChild();
07703
else
07704 currentAST.
child = constant_all_opt_AST;
07705 currentAST.
advanceChildToEnd();
07706 }
07707 constant_all_opt_AST = (currentAST.
root);
07708 }
07709
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07710
if( inputState->guessing == 0 ) {
07711
reportError(ex);
07712 consume();
07713 consumeUntil(
_tokenSet_39);
07714 }
else {
07715
throw;
07716 }
07717 }
07718
returnAST = constant_all_opt_AST;
07719 }
07720
07721 void AdaParser::abstract_opt() {
07722
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07723
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07724
RefAdaAST abstract_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07725
07726
try {
07727 {
07728
switch ( LA(1)) {
07729
case ABSTRACT:
07730 {
07731
RefAdaAST tmp208_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07732
if ( inputState->guessing == 0 ) {
07733 tmp208_AST = astFactory->create(LT(1));
07734 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp208_AST.get()));
07735 }
07736 match(ABSTRACT);
07737
break;
07738 }
07739
case NEW:
07740 {
07741
break;
07742 }
07743
default:
07744 {
07745
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07746 }
07747 }
07748 }
07749
if ( inputState->guessing==0 ) {
07750 abstract_opt_AST =
RefAdaAST(currentAST.
root);
07751
#line 771 "ada.g"
07752
abstract_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abstract_opt_AST.get()))));
07753
#line 7754 "AdaParser.cpp"
07754
currentAST.
root = abstract_opt_AST;
07755
if ( abstract_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07756 abstract_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07757 currentAST.
child = abstract_opt_AST->getFirstChild();
07758
else
07759 currentAST.
child = abstract_opt_AST;
07760 currentAST.
advanceChildToEnd();
07761 }
07762 abstract_opt_AST = (currentAST.
root);
07763 }
07764
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07765
if( inputState->guessing == 0 ) {
07766
reportError(ex);
07767 consume();
07768 consumeUntil(
_tokenSet_70);
07769 }
else {
07770
throw;
07771 }
07772 }
07773
returnAST = abstract_opt_AST;
07774 }
07775
07776 void AdaParser::record_definition(
07777
bool has_discrim
07778 ) {
07779
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07780
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07781
RefAdaAST record_definition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07782
07783
try {
07784
switch ( LA(1)) {
07785
case RECORD:
07786 {
07787 match(RECORD);
07788
component_list(has_discrim);
07789
if (inputState->guessing==0) {
07790 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07791 }
07792 match(END);
07793 match(RECORD);
07794 record_definition_AST = (currentAST.
root);
07795
break;
07796 }
07797
case NuLL:
07798 {
07799 match(NuLL);
07800 match(RECORD);
07801 record_definition_AST = (currentAST.
root);
07802
break;
07803 }
07804
default:
07805 {
07806
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07807 }
07808 }
07809 }
07810
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07811
if( inputState->guessing == 0 ) {
07812
reportError(ex);
07813 consume();
07814 consumeUntil(
_tokenSet_4);
07815 }
else {
07816
throw;
07817 }
07818 }
07819
returnAST = record_definition_AST;
07820 }
07821
07822 void AdaParser::abstract_tagged_limited_opt() {
07823
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07824
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07825
RefAdaAST abstract_tagged_limited_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07826
07827
try {
07828 {
07829
switch ( LA(1)) {
07830
case ABSTRACT:
07831 {
07832
RefAdaAST tmp214_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07833
if ( inputState->guessing == 0 ) {
07834 tmp214_AST = astFactory->create(LT(1));
07835 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp214_AST.get()));
07836 }
07837 match(ABSTRACT);
07838 match(TAGGED);
07839
break;
07840 }
07841
case TAGGED:
07842 {
07843
RefAdaAST tmp216_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07844
if ( inputState->guessing == 0 ) {
07845 tmp216_AST = astFactory->create(LT(1));
07846 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp216_AST.get()));
07847 }
07848 match(TAGGED);
07849
break;
07850 }
07851
case PRIVATE:
07852
case NuLL:
07853
case RECORD:
07854
case LIMITED:
07855 {
07856
break;
07857 }
07858
default:
07859 {
07860
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07861 }
07862 }
07863 }
07864 {
07865
switch ( LA(1)) {
07866
case LIMITED:
07867 {
07868
RefAdaAST tmp217_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07869
if ( inputState->guessing == 0 ) {
07870 tmp217_AST = astFactory->create(LT(1));
07871 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp217_AST.get()));
07872 }
07873 match(LIMITED);
07874
break;
07875 }
07876
case PRIVATE:
07877
case NuLL:
07878
case RECORD:
07879 {
07880
break;
07881 }
07882
default:
07883 {
07884
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07885 }
07886 }
07887 }
07888
if ( inputState->guessing==0 ) {
07889 abstract_tagged_limited_opt_AST =
RefAdaAST(currentAST.
root);
07890
#line 833 "ada.g"
07891
abstract_tagged_limited_opt_AST =
07892
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abstract_tagged_limited_opt_AST.get()))));
07893
#line 7894 "AdaParser.cpp"
07894
currentAST.
root = abstract_tagged_limited_opt_AST;
07895
if ( abstract_tagged_limited_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
07896 abstract_tagged_limited_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
07897 currentAST.
child = abstract_tagged_limited_opt_AST->getFirstChild();
07898
else
07899 currentAST.
child = abstract_tagged_limited_opt_AST;
07900 currentAST.
advanceChildToEnd();
07901 }
07902 abstract_tagged_limited_opt_AST = (currentAST.
root);
07903 }
07904
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07905
if( inputState->guessing == 0 ) {
07906
reportError(ex);
07907 consume();
07908 consumeUntil(
_tokenSet_71);
07909 }
else {
07910
throw;
07911 }
07912 }
07913
returnAST = abstract_tagged_limited_opt_AST;
07914 }
07915
07916 void AdaParser::component_list(
07917
bool has_discrim
07918 ) {
07919
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07920
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
07921
RefAdaAST component_list_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
07922
07923
try {
07924
switch ( LA(1)) {
07925
case NuLL:
07926 {
07927 match(NuLL);
07928 match(SEMI);
07929 component_list_AST = (currentAST.
root);
07930
break;
07931 }
07932
case PRAGMA:
07933
case IDENTIFIER:
07934 {
07935
component_items();
07936
if (inputState->guessing==0) {
07937 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07938 }
07939 {
07940
switch ( LA(1)) {
07941
case CASE:
07942 {
07943
variant_part();
07944
if (inputState->guessing==0) {
07945 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07946 }
07947
if (!( has_discrim ))
07948
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" has_discrim ");
07949
break;
07950 }
07951
case END:
07952
case WHEN:
07953 {
07954
break;
07955 }
07956
default:
07957 {
07958
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07959 }
07960 }
07961 }
07962 component_list_AST = (currentAST.
root);
07963
break;
07964 }
07965
case CASE:
07966 {
07967
empty_component_items();
07968
if (inputState->guessing==0) {
07969 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07970 }
07971
variant_part();
07972
if (inputState->guessing==0) {
07973 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
07974 }
07975
if (!( has_discrim ))
07976
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" has_discrim ");
07977 component_list_AST = (currentAST.
root);
07978
break;
07979 }
07980
default:
07981 {
07982
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
07983 }
07984 }
07985 }
07986
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07987
if( inputState->guessing == 0 ) {
07988
reportError(ex);
07989 consume();
07990 consumeUntil(
_tokenSet_72);
07991 }
else {
07992
throw;
07993 }
07994 }
07995
returnAST = component_list_AST;
07996 }
07997
07998 void AdaParser::component_items() {
07999
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08000
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08001
RefAdaAST component_items_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08002
08003
try {
08004 {
08005
int _cnt254=0;
08006
for (;;) {
08007
switch ( LA(1)) {
08008
case PRAGMA:
08009 {
08010
pragma();
08011
if (inputState->guessing==0) {
08012 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08013 }
08014
break;
08015 }
08016
case IDENTIFIER:
08017 {
08018
comp_decl();
08019
if (inputState->guessing==0) {
08020 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08021 }
08022
break;
08023 }
08024
default:
08025 {
08026
if ( _cnt254>=1 ) {
goto _loop254; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
08027 }
08028 }
08029 _cnt254++;
08030 }
08031 _loop254:;
08032 }
08033
if ( inputState->guessing==0 ) {
08034 component_items_AST =
RefAdaAST(currentAST.
root);
08035
#line 786 "ada.g"
08036
component_items_AST =
08037
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_ITEMS,
"COMPONENT_ITEMS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(component_items_AST.get()))));
08038
#line 8039 "AdaParser.cpp"
08039
currentAST.
root = component_items_AST;
08040
if ( component_items_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
08041 component_items_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
08042 currentAST.
child = component_items_AST->getFirstChild();
08043
else
08044 currentAST.
child = component_items_AST;
08045 currentAST.
advanceChildToEnd();
08046 }
08047 component_items_AST = (currentAST.
root);
08048 }
08049
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08050
if( inputState->guessing == 0 ) {
08051
reportError(ex);
08052 consume();
08053 consumeUntil(
_tokenSet_73);
08054 }
else {
08055
throw;
08056 }
08057 }
08058
returnAST = component_items_AST;
08059 }
08060
08061 void AdaParser::variant_part() {
08062
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08063
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08064
RefAdaAST variant_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08065
ANTLR_USE_NAMESPACE(antlr)
RefToken c =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
08066
RefAdaAST c_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08067
08068
try {
08069 c = LT(1);
08070
if ( inputState->guessing == 0 ) {
08071 c_AST = astFactory->create(c);
08072 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get()));
08073 }
08074 match(CASE);
08075
discriminant_direct_name();
08076
if (inputState->guessing==0) {
08077 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08078 }
08079 match(IS);
08080
variant_s();
08081
if (inputState->guessing==0) {
08082 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08083 }
08084 match(END);
08085 match(CASE);
08086 match(SEMI);
08087
if ( inputState->guessing==0 ) {
08088
#line 798 "ada.g"
08089
Set (c_AST, VARIANT_PART);
08090
#line 8091 "AdaParser.cpp"
08091
}
08092 variant_part_AST = (currentAST.
root);
08093 }
08094
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08095
if( inputState->guessing == 0 ) {
08096
reportError(ex);
08097 consume();
08098 consumeUntil(
_tokenSet_72);
08099 }
else {
08100
throw;
08101 }
08102 }
08103
returnAST = variant_part_AST;
08104 }
08105
08106 void AdaParser::empty_component_items() {
08107
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08108
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08109
RefAdaAST empty_component_items_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08110
08111
try {
08112
if ( inputState->guessing==0 ) {
08113 empty_component_items_AST =
RefAdaAST(currentAST.
root);
08114
#line 792 "ada.g"
08115
empty_component_items_AST =
08116
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_ITEMS,
"COMPONENT_ITEMS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(empty_component_items_AST.get()))));
08117
#line 8118 "AdaParser.cpp"
08118
currentAST.
root = empty_component_items_AST;
08119
if ( empty_component_items_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
08120 empty_component_items_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
08121 currentAST.
child = empty_component_items_AST->getFirstChild();
08122
else
08123 currentAST.
child = empty_component_items_AST;
08124 currentAST.
advanceChildToEnd();
08125 }
08126 empty_component_items_AST = (currentAST.
root);
08127 }
08128
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08129
if( inputState->guessing == 0 ) {
08130
reportError(ex);
08131 consume();
08132 consumeUntil(
_tokenSet_74);
08133 }
else {
08134
throw;
08135 }
08136 }
08137
returnAST = empty_component_items_AST;
08138 }
08139
08140 void AdaParser::discriminant_direct_name() {
08141
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08142
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08143
RefAdaAST discriminant_direct_name_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08144
08145
try {
08146
RefAdaAST tmp224_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08147
if ( inputState->guessing == 0 ) {
08148 tmp224_AST = astFactory->create(LT(1));
08149 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp224_AST.get()));
08150 }
08151 match(IDENTIFIER);
08152 discriminant_direct_name_AST = (currentAST.
root);
08153 }
08154
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08155
if( inputState->guessing == 0 ) {
08156
reportError(ex);
08157 consume();
08158 consumeUntil(
_tokenSet_75);
08159 }
else {
08160
throw;
08161 }
08162 }
08163
returnAST = discriminant_direct_name_AST;
08164 }
08165
08166 void AdaParser::variant_s() {
08167
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08168
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08169
RefAdaAST variant_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08170
08171
try {
08172 {
08173
int _cnt260=0;
08174
for (;;) {
08175
if ((LA(1) == WHEN)) {
08176
variant();
08177
if (inputState->guessing==0) {
08178 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08179 }
08180 }
08181
else {
08182
if ( _cnt260>=1 ) {
goto _loop260; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
08183 }
08184
08185 _cnt260++;
08186 }
08187 _loop260:;
08188 }
08189
if ( inputState->guessing==0 ) {
08190 variant_s_AST =
RefAdaAST(currentAST.
root);
08191
#line 805 "ada.g"
08192
variant_s_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VARIANTS,
"VARIANTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(variant_s_AST.get()))));
08193
#line 8194 "AdaParser.cpp"
08194
currentAST.
root = variant_s_AST;
08195
if ( variant_s_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
08196 variant_s_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
08197 currentAST.
child = variant_s_AST->getFirstChild();
08198
else
08199 currentAST.
child = variant_s_AST;
08200 currentAST.
advanceChildToEnd();
08201 }
08202 variant_s_AST = (currentAST.
root);
08203 }
08204
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08205
if( inputState->guessing == 0 ) {
08206
reportError(ex);
08207 consume();
08208 consumeUntil(
_tokenSet_21);
08209 }
else {
08210
throw;
08211 }
08212 }
08213
returnAST = variant_s_AST;
08214 }
08215
08216 void AdaParser::variant() {
08217
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08218
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08219
RefAdaAST variant_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08220
ANTLR_USE_NAMESPACE(antlr)
RefToken w =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
08221
RefAdaAST w_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08222
08223
try {
08224 w = LT(1);
08225
if ( inputState->guessing == 0 ) {
08226 w_AST = astFactory->create(w);
08227 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
08228 }
08229 match(WHEN);
08230
choice_s();
08231
if (inputState->guessing==0) {
08232 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08233 }
08234 match(RIGHT_SHAFT);
08235
component_list(
true);
08236
if (inputState->guessing==0) {
08237 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08238 }
08239
if ( inputState->guessing==0 ) {
08240
#line 809 "ada.g"
08241
Set (w_AST, VARIANT);
08242
#line 8243 "AdaParser.cpp"
08243
}
08244 variant_AST = (currentAST.
root);
08245 }
08246
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08247
if( inputState->guessing == 0 ) {
08248
reportError(ex);
08249 consume();
08250 consumeUntil(
_tokenSet_72);
08251 }
else {
08252
throw;
08253 }
08254 }
08255
returnAST = variant_AST;
08256 }
08257
08258 void AdaParser::choice_s() {
08259
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08260
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08261
RefAdaAST choice_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08262
08263
try {
08264
choice();
08265
if (inputState->guessing==0) {
08266 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08267 }
08268 {
08269
for (;;) {
08270
if ((LA(1) == PIPE)) {
08271
RefAdaAST tmp226_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08272
if ( inputState->guessing == 0 ) {
08273 tmp226_AST = astFactory->create(LT(1));
08274 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp226_AST.get()));
08275 }
08276 match(PIPE);
08277
choice();
08278
if (inputState->guessing==0) {
08279 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08280 }
08281 }
08282
else {
08283
goto _loop264;
08284 }
08285
08286 }
08287 _loop264:;
08288 }
08289 choice_s_AST = (currentAST.
root);
08290 }
08291
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08292
if( inputState->guessing == 0 ) {
08293
reportError(ex);
08294 consume();
08295 consumeUntil(
_tokenSet_76);
08296 }
else {
08297
throw;
08298 }
08299 }
08300
returnAST = choice_s_AST;
08301 }
08302
08303 void AdaParser::choice() {
08304
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08305
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08306
RefAdaAST choice_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08307
08308
try {
08309
if ((LA(1) == OTHERS)) {
08310
RefAdaAST tmp227_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08311
if ( inputState->guessing == 0 ) {
08312 tmp227_AST = astFactory->create(LT(1));
08313 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp227_AST.get()));
08314 }
08315 match(OTHERS);
08316 choice_AST = (currentAST.
root);
08317 }
08318
else {
08319
bool synPredMatched267 =
false;
08320
if (((
_tokenSet_5.member(LA(1))) && (
_tokenSet_77.member(LA(2))))) {
08321
int _m267 = mark();
08322 synPredMatched267 =
true;
08323 inputState->guessing++;
08324
try {
08325 {
08326
discrete_with_range();
08327 }
08328 }
08329
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
08330 synPredMatched267 =
false;
08331 }
08332 rewind(_m267);
08333 inputState->guessing--;
08334 }
08335
if ( synPredMatched267 ) {
08336
discrete_with_range();
08337
if (inputState->guessing==0) {
08338 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08339 }
08340 choice_AST = (currentAST.
root);
08341 }
08342
else if ((
_tokenSet_5.member(LA(1))) && (
_tokenSet_78.member(LA(2)))) {
08343
expression();
08344
if (inputState->guessing==0) {
08345 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08346 }
08347 choice_AST = (currentAST.
root);
08348 }
08349
else {
08350
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08351 }
08352 }
08353 }
08354
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08355
if( inputState->guessing == 0 ) {
08356
reportError(ex);
08357 consume();
08358 consumeUntil(
_tokenSet_68);
08359 }
else {
08360
throw;
08361 }
08362 }
08363
returnAST = choice_AST;
08364 }
08365
08366 void AdaParser::discrete_with_range() {
08367
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08368
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08369
RefAdaAST discrete_with_range_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08370
08371
try {
08372
bool synPredMatched270 =
false;
08373
if (((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == TIC || LA(2) == RANGE))) {
08374
int _m270 = mark();
08375 synPredMatched270 =
true;
08376 inputState->guessing++;
08377
try {
08378 {
08379
mark_with_constraint();
08380 }
08381 }
08382
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
08383 synPredMatched270 =
false;
08384 }
08385 rewind(_m270);
08386 inputState->guessing--;
08387 }
08388
if ( synPredMatched270 ) {
08389
mark_with_constraint();
08390
if (inputState->guessing==0) {
08391 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08392 }
08393 discrete_with_range_AST = (currentAST.
root);
08394 }
08395
else if ((
_tokenSet_5.member(LA(1))) && (
_tokenSet_33.member(LA(2)))) {
08396
range();
08397
if (inputState->guessing==0) {
08398 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08399 }
08400 discrete_with_range_AST = (currentAST.
root);
08401 }
08402
else {
08403
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08404 }
08405
08406 }
08407
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08408
if( inputState->guessing == 0 ) {
08409
reportError(ex);
08410 consume();
08411 consumeUntil(
_tokenSet_68);
08412 }
else {
08413
throw;
08414 }
08415 }
08416
returnAST = discrete_with_range_AST;
08417 }
08418
08419 void AdaParser::mark_with_constraint() {
08420
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08421
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08422
RefAdaAST mark_with_constraint_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08423
08424
try {
08425
subtype_mark();
08426
if (inputState->guessing==0) {
08427 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08428 }
08429
range_constraint();
08430
if (inputState->guessing==0) {
08431 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08432 }
08433
if ( inputState->guessing==0 ) {
08434 mark_with_constraint_AST =
RefAdaAST(currentAST.
root);
08435
#line 825 "ada.g"
08436
mark_with_constraint_AST =
08437
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MARK_WITH_CONSTRAINT,
"MARK_WITH_CONSTRAINT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mark_with_constraint_AST.get()))));
08438
#line 8439 "AdaParser.cpp"
08439
currentAST.
root = mark_with_constraint_AST;
08440
if ( mark_with_constraint_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
08441 mark_with_constraint_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
08442 currentAST.
child = mark_with_constraint_AST->getFirstChild();
08443
else
08444 currentAST.
child = mark_with_constraint_AST;
08445 currentAST.
advanceChildToEnd();
08446 }
08447 mark_with_constraint_AST = (currentAST.
root);
08448 }
08449
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08450
if( inputState->guessing == 0 ) {
08451
reportError(ex);
08452 consume();
08453 consumeUntil(
_tokenSet_68);
08454 }
else {
08455
throw;
08456 }
08457 }
08458
returnAST = mark_with_constraint_AST;
08459 }
08460
08461 void AdaParser::generic_formal_part_opt() {
08462
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08463
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08464
RefAdaAST generic_formal_part_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08465
08466
try {
08467 {
08468
for (;;) {
08469
switch ( LA(1)) {
08470
case USE:
08471 {
08472
use_clause();
08473
if (inputState->guessing==0) {
08474 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08475 }
08476
break;
08477 }
08478
case PRAGMA:
08479 {
08480
pragma();
08481
if (inputState->guessing==0) {
08482 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08483 }
08484
break;
08485 }
08486
case IDENTIFIER:
08487
case WITH:
08488
case TYPE:
08489 {
08490
generic_formal_parameter();
08491
if (inputState->guessing==0) {
08492 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08493 }
08494
break;
08495 }
08496
default:
08497 {
08498
goto _loop287;
08499 }
08500 }
08501 }
08502 _loop287:;
08503 }
08504
if ( inputState->guessing==0 ) {
08505 generic_formal_part_opt_AST =
RefAdaAST(currentAST.
root);
08506
#line 871 "ada.g"
08507
generic_formal_part_opt_AST =
08508
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(GENERIC_FORMAL_PART,
"GENERIC_FORMAL_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(generic_formal_part_opt_AST.get()))));
08509
#line 8510 "AdaParser.cpp"
08510
currentAST.
root = generic_formal_part_opt_AST;
08511
if ( generic_formal_part_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
08512 generic_formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
08513 currentAST.
child = generic_formal_part_opt_AST->getFirstChild();
08514
else
08515 currentAST.
child = generic_formal_part_opt_AST;
08516 currentAST.
advanceChildToEnd();
08517 }
08518 generic_formal_part_opt_AST = (currentAST.
root);
08519 }
08520
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08521
if( inputState->guessing == 0 ) {
08522
reportError(ex);
08523 consume();
08524 consumeUntil(
_tokenSet_79);
08525 }
else {
08526
throw;
08527 }
08528 }
08529
returnAST = generic_formal_part_opt_AST;
08530 }
08531
08532 void AdaParser::generic_formal_parameter() {
08533
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08534
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08535
RefAdaAST generic_formal_parameter_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08536
ANTLR_USE_NAMESPACE(antlr)
RefToken t =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
08537
RefAdaAST t_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08538
ANTLR_USE_NAMESPACE(antlr)
RefToken w =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
08539
RefAdaAST w_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08540
08541
try {
08542 {
08543
switch ( LA(1)) {
08544
case TYPE:
08545 {
08546 t = LT(1);
08547
if ( inputState->guessing == 0 ) {
08548 t_AST = astFactory->create(t);
08549 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
08550 }
08551 match(TYPE);
08552
def_id(
false);
08553
if (inputState->guessing==0) {
08554 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08555 }
08556 {
08557
switch ( LA(1)) {
08558
case IS:
08559 {
08560 match(IS);
08561 {
08562
switch ( LA(1)) {
08563
case LPAREN:
08564 {
08565 match(LPAREN);
08566 match(BOX);
08567 match(RPAREN);
08568
if ( inputState->guessing==0 ) {
08569
#line 881 "ada.g"
08570
Set (t_AST, FORMAL_DISCRETE_TYPE_DECLARATION);
08571
#line 8572 "AdaParser.cpp"
08572
}
08573
break;
08574 }
08575
case RANGE:
08576 {
08577 match(RANGE);
08578 match(BOX);
08579
if ( inputState->guessing==0 ) {
08580
#line 883 "ada.g"
08581
Set (t_AST, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
08582
#line 8583 "AdaParser.cpp"
08583
}
08584
break;
08585 }
08586
case MOD:
08587 {
08588 match(MOD);
08589 match(BOX);
08590
if ( inputState->guessing==0 ) {
08591
#line 885 "ada.g"
08592
Set (t_AST, FORMAL_MODULAR_TYPE_DECLARATION);
08593
#line 8594 "AdaParser.cpp"
08594
}
08595
break;
08596 }
08597
case DELTA:
08598 {
08599 match(DELTA);
08600 match(BOX);
08601 {
08602
switch ( LA(1)) {
08603
case DIGITS:
08604 {
08605 match(DIGITS);
08606 match(BOX);
08607
if ( inputState->guessing==0 ) {
08608
#line 888 "ada.g"
08609
Set (t_AST, FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
08610
#line 8611 "AdaParser.cpp"
08611
}
08612
break;
08613 }
08614
case SEMI:
08615 {
08616
if ( inputState->guessing==0 ) {
08617
#line 889 "ada.g"
08618
Set (t_AST, FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
08619
#line 8620 "AdaParser.cpp"
08620
}
08621
break;
08622 }
08623
default:
08624 {
08625
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08626 }
08627 }
08628 }
08629
break;
08630 }
08631
case DIGITS:
08632 {
08633 match(DIGITS);
08634 match(BOX);
08635
if ( inputState->guessing==0 ) {
08636
#line 892 "ada.g"
08637
Set (t_AST, FORMAL_FLOATING_POINT_DECLARATION);
08638
#line 8639 "AdaParser.cpp"
08639
}
08640
break;
08641 }
08642
case ARRAY:
08643 {
08644
array_type_definition(t_AST);
08645
if (inputState->guessing==0) {
08646 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08647 }
08648
break;
08649 }
08650
case ACCESS:
08651 {
08652
access_type_definition(t_AST);
08653
if (inputState->guessing==0) {
08654 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08655 }
08656
break;
08657 }
08658
case PRIVATE:
08659
case NEW:
08660
case ABSTRACT:
08661
case TAGGED:
08662
case LIMITED:
08663 {
08664
empty_discrim_opt();
08665
if (inputState->guessing==0) {
08666 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08667 }
08668
discriminable_type_definition(t_AST);
08669
if (inputState->guessing==0) {
08670 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08671 }
08672
break;
08673 }
08674
default:
08675 {
08676
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08677 }
08678 }
08679 }
08680
break;
08681 }
08682
case LPAREN:
08683 {
08684
discrim_part();
08685
if (inputState->guessing==0) {
08686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08687 }
08688 match(IS);
08689
discriminable_type_definition(t_AST);
08690
if (inputState->guessing==0) {
08691 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08692 }
08693
break;
08694 }
08695
default:
08696 {
08697
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08698 }
08699 }
08700 }
08701
if ( inputState->guessing==0 ) {
08702
#line 899 "ada.g"
08703
pop_def_id();
08704
#line 8705 "AdaParser.cpp"
08705
}
08706
break;
08707 }
08708
case WITH:
08709 {
08710 w = LT(1);
08711
if ( inputState->guessing == 0 ) {
08712 w_AST = astFactory->create(w);
08713 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
08714 }
08715 match(WITH);
08716 {
08717
switch ( LA(1)) {
08718
case PROCEDURE:
08719 {
08720 match(PROCEDURE);
08721
def_id(
false);
08722
if (inputState->guessing==0) {
08723 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08724 }
08725
formal_part_opt();
08726
if (inputState->guessing==0) {
08727 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08728 }
08729
subprogram_default_opt();
08730
if (inputState->guessing==0) {
08731 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08732 }
08733
if ( inputState->guessing==0 ) {
08734
#line 901 "ada.g"
08735
Set(w_AST, FORMAL_PROCEDURE_DECLARATION);
08736
#line 8737 "AdaParser.cpp"
08737
}
08738
break;
08739 }
08740
case FUNCTION:
08741 {
08742 match(FUNCTION);
08743
def_designator(
false);
08744
if (inputState->guessing==0) {
08745 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08746 }
08747
function_tail();
08748
if (inputState->guessing==0) {
08749 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08750 }
08751
subprogram_default_opt();
08752
if (inputState->guessing==0) {
08753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08754 }
08755
if ( inputState->guessing==0 ) {
08756
#line 903 "ada.g"
08757
Set(w_AST, FORMAL_FUNCTION_DECLARATION);
08758
#line 8759 "AdaParser.cpp"
08759
}
08760
break;
08761 }
08762
case PACKAGE:
08763 {
08764 match(PACKAGE);
08765
def_id(
false);
08766
if (inputState->guessing==0) {
08767 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08768 }
08769 match(IS);
08770 match(NEW);
08771
compound_name();
08772
if (inputState->guessing==0) {
08773 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08774 }
08775
formal_package_actual_part_opt();
08776
if (inputState->guessing==0) {
08777 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08778 }
08779
if ( inputState->guessing==0 ) {
08780
#line 905 "ada.g"
08781
Set(w_AST, FORMAL_PACKAGE_DECLARATION);
08782
#line 8783 "AdaParser.cpp"
08783
}
08784
break;
08785 }
08786
default:
08787 {
08788
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08789 }
08790 }
08791 }
08792
if ( inputState->guessing==0 ) {
08793
#line 907 "ada.g"
08794
pop_def_id();
08795
#line 8796 "AdaParser.cpp"
08796
}
08797
break;
08798 }
08799
case IDENTIFIER:
08800 {
08801
parameter_specification();
08802
if (inputState->guessing==0) {
08803 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08804 }
08805
break;
08806 }
08807
default:
08808 {
08809
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08810 }
08811 }
08812 }
08813 match(SEMI);
08814 generic_formal_parameter_AST = (currentAST.
root);
08815 }
08816
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08817
if( inputState->guessing == 0 ) {
08818
reportError(ex);
08819 consume();
08820 consumeUntil(
_tokenSet_80);
08821 }
else {
08822
throw;
08823 }
08824 }
08825
returnAST = generic_formal_parameter_AST;
08826 }
08827
08828 void AdaParser::discriminable_type_definition(
08829 RefAdaAST t
08830 ) {
08831
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08832
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08833
RefAdaAST discriminable_type_definition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08834
08835
try {
08836
bool synPredMatched297 =
false;
08837
if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
08838
int _m297 = mark();
08839 synPredMatched297 =
true;
08840 inputState->guessing++;
08841
try {
08842 {
08843 {
08844
switch ( LA(1)) {
08845
case ABSTRACT:
08846 {
08847 match(ABSTRACT);
08848
break;
08849 }
08850
case NEW:
08851 {
08852
break;
08853 }
08854
default:
08855 {
08856
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08857 }
08858 }
08859 }
08860 match(NEW);
08861
subtype_ind();
08862 match(WITH);
08863 }
08864 }
08865
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
08866 synPredMatched297 =
false;
08867 }
08868 rewind(_m297);
08869 inputState->guessing--;
08870 }
08871
if ( synPredMatched297 ) {
08872
abstract_opt();
08873
if (inputState->guessing==0) {
08874 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08875 }
08876 match(NEW);
08877
subtype_ind();
08878
if (inputState->guessing==0) {
08879 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08880 }
08881 match(WITH);
08882 match(PRIVATE);
08883
if ( inputState->guessing==0 ) {
08884
#line 916 "ada.g"
08885
Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION);
08886
#line 8887 "AdaParser.cpp"
08887
}
08888 discriminable_type_definition_AST = (currentAST.
root);
08889 }
08890
else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
08891 match(NEW);
08892
subtype_ind();
08893
if (inputState->guessing==0) {
08894 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08895 }
08896
if ( inputState->guessing==0 ) {
08897
#line 918 "ada.g"
08898
Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
08899
#line 8900 "AdaParser.cpp"
08900
}
08901 discriminable_type_definition_AST = (currentAST.
root);
08902 }
08903
else if ((
_tokenSet_81.member(LA(1))) && (
_tokenSet_82.member(LA(2)))) {
08904
abstract_tagged_limited_opt();
08905
if (inputState->guessing==0) {
08906 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08907 }
08908 match(PRIVATE);
08909
if ( inputState->guessing==0 ) {
08910
#line 920 "ada.g"
08911
Set (t, FORMAL_PRIVATE_TYPE_DECLARATION);
08912
#line 8913 "AdaParser.cpp"
08913
}
08914 discriminable_type_definition_AST = (currentAST.
root);
08915 }
08916
else {
08917
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08918 }
08919
08920 }
08921
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08922
if( inputState->guessing == 0 ) {
08923
reportError(ex);
08924 consume();
08925 consumeUntil(
_tokenSet_4);
08926 }
else {
08927
throw;
08928 }
08929 }
08930
returnAST = discriminable_type_definition_AST;
08931 }
08932
08933 void AdaParser::subprogram_default_opt() {
08934
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08935
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08936
RefAdaAST subprogram_default_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08937
08938
try {
08939 {
08940
switch ( LA(1)) {
08941
case IS:
08942 {
08943 match(IS);
08944 {
08945
switch ( LA(1)) {
08946
case BOX:
08947 {
08948
RefAdaAST tmp255_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08949
if ( inputState->guessing == 0 ) {
08950 tmp255_AST = astFactory->create(LT(1));
08951 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp255_AST.get()));
08952 }
08953 match(BOX);
08954
break;
08955 }
08956
case IDENTIFIER:
08957 {
08958
name();
08959
if (inputState->guessing==0) {
08960 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
08961 }
08962
break;
08963 }
08964
default:
08965 {
08966
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08967 }
08968 }
08969 }
08970
break;
08971 }
08972
case SEMI:
08973 {
08974
break;
08975 }
08976
default:
08977 {
08978
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
08979 }
08980 }
08981 }
08982 subprogram_default_opt_AST = (currentAST.
root);
08983 }
08984
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08985
if( inputState->guessing == 0 ) {
08986
reportError(ex);
08987 consume();
08988 consumeUntil(
_tokenSet_4);
08989 }
else {
08990
throw;
08991 }
08992 }
08993
returnAST = subprogram_default_opt_AST;
08994 }
08995
08996 void AdaParser::formal_package_actual_part_opt() {
08997
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
08998
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
08999
RefAdaAST formal_package_actual_part_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09000
09001
try {
09002 {
09003
switch ( LA(1)) {
09004
case LPAREN:
09005 {
09006 match(LPAREN);
09007 {
09008
switch ( LA(1)) {
09009
case BOX:
09010 {
09011
RefAdaAST tmp257_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09012
if ( inputState->guessing == 0 ) {
09013 tmp257_AST = astFactory->create(LT(1));
09014 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp257_AST.get()));
09015 }
09016 match(BOX);
09017
break;
09018 }
09019
case IDENTIFIER:
09020 {
09021
defining_identifier_list();
09022
if (inputState->guessing==0) {
09023 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09024 }
09025
break;
09026 }
09027
default:
09028 {
09029
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09030 }
09031 }
09032 }
09033 match(RPAREN);
09034
break;
09035 }
09036
case SEMI:
09037 {
09038
break;
09039 }
09040
default:
09041 {
09042
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09043 }
09044 }
09045 }
09046 formal_package_actual_part_opt_AST = (currentAST.
root);
09047 }
09048
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09049
if( inputState->guessing == 0 ) {
09050
reportError(ex);
09051 consume();
09052 consumeUntil(
_tokenSet_4);
09053 }
else {
09054
throw;
09055 }
09056 }
09057
returnAST = formal_package_actual_part_opt_AST;
09058 }
09059
09060 void AdaParser::body_part() {
09061
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09062
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09063
RefAdaAST body_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09064
09065
try {
09066
declarative_part();
09067
if (inputState->guessing==0) {
09068 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09069 }
09070
block_body();
09071
if (inputState->guessing==0) {
09072 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09073 }
09074
end_id_opt();
09075 body_part_AST = (currentAST.
root);
09076 }
09077
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09078
if( inputState->guessing == 0 ) {
09079
reportError(ex);
09080 consume();
09081 consumeUntil(
_tokenSet_4);
09082 }
else {
09083
throw;
09084 }
09085 }
09086
returnAST = body_part_AST;
09087 }
09088
09089 void AdaParser::declarative_part() {
09090
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09091
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09092
RefAdaAST declarative_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09093
09094
try {
09095 {
09096
for (;;) {
09097
switch ( LA(1)) {
09098
case PRAGMA:
09099 {
09100
pragma();
09101
if (inputState->guessing==0) {
09102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09103 }
09104
break;
09105 }
09106
case IDENTIFIER:
09107
case USE:
09108
case TYPE:
09109
case PACKAGE:
09110
case PROCEDURE:
09111
case FUNCTION:
09112
case TASK:
09113
case PROTECTED:
09114
case FOR:
09115
case SUBTYPE:
09116
case GENERIC:
09117 {
09118
declarative_item();
09119
if (inputState->guessing==0) {
09120 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09121 }
09122
break;
09123 }
09124
default:
09125 {
09126
goto _loop314;
09127 }
09128 }
09129 }
09130 _loop314:;
09131 }
09132
if ( inputState->guessing==0 ) {
09133 declarative_part_AST =
RefAdaAST(currentAST.
root);
09134
#line 964 "ada.g"
09135
declarative_part_AST =
09136
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DECLARATIVE_PART,
"DECLARATIVE_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(declarative_part_AST.get()))));
09137
#line 9138 "AdaParser.cpp"
09138
currentAST.
root = declarative_part_AST;
09139
if ( declarative_part_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
09140 declarative_part_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
09141 currentAST.
child = declarative_part_AST->getFirstChild();
09142
else
09143 currentAST.
child = declarative_part_AST;
09144 currentAST.
advanceChildToEnd();
09145 }
09146 declarative_part_AST = (currentAST.
root);
09147 }
09148
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09149
if( inputState->guessing == 0 ) {
09150
reportError(ex);
09151 consume();
09152 consumeUntil(
_tokenSet_83);
09153 }
else {
09154
throw;
09155 }
09156 }
09157
returnAST = declarative_part_AST;
09158 }
09159
09160 void AdaParser::block_body() {
09161
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09162
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09163
RefAdaAST block_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09164
ANTLR_USE_NAMESPACE(antlr)
RefToken b =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09165
RefAdaAST b_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09166
09167
try {
09168 b = LT(1);
09169
if ( inputState->guessing == 0 ) {
09170 b_AST = astFactory->create(b);
09171 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(b_AST.get()));
09172 }
09173 match(BEGIN);
09174
handled_stmt_s();
09175
if (inputState->guessing==0) {
09176 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09177 }
09178
if ( inputState->guessing==0 ) {
09179
#line 1044 "ada.g"
09180
Set(b_AST, BLOCK_BODY);
09181
#line 9182 "AdaParser.cpp"
09182
}
09183 block_body_AST = (currentAST.
root);
09184 }
09185
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09186
if( inputState->guessing == 0 ) {
09187
reportError(ex);
09188 consume();
09189 consumeUntil(
_tokenSet_21);
09190 }
else {
09191
throw;
09192 }
09193 }
09194
returnAST = block_body_AST;
09195 }
09196
09197 void AdaParser::declarative_item() {
09198
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09199
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09200
RefAdaAST declarative_item_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09201
ANTLR_USE_NAMESPACE(antlr)
RefToken pkg =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09202
RefAdaAST pkg_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09203
ANTLR_USE_NAMESPACE(antlr)
RefToken tsk =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09204
RefAdaAST tsk_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09205
ANTLR_USE_NAMESPACE(antlr)
RefToken pro =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09206
RefAdaAST pro_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09207
09208
try {
09209 {
09210
switch ( LA(1)) {
09211
case PACKAGE:
09212 {
09213 pkg = LT(1);
09214
if ( inputState->guessing == 0 ) {
09215 pkg_AST = astFactory->create(pkg);
09216 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get()));
09217 }
09218 match(PACKAGE);
09219 {
09220
switch ( LA(1)) {
09221
case BODY:
09222 {
09223
body_is();
09224
if (inputState->guessing==0) {
09225 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09226 }
09227 {
09228
switch ( LA(1)) {
09229
case SEPARATE:
09230 {
09231
separate();
09232
if (inputState->guessing==0) {
09233 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09234 }
09235
if ( inputState->guessing==0 ) {
09236
#line 972 "ada.g"
09237
Set(pkg_AST, PACKAGE_BODY_STUB);
09238
#line 9239 "AdaParser.cpp"
09239
}
09240
break;
09241 }
09242
case PRAGMA:
09243
case IDENTIFIER:
09244
case USE:
09245
case TYPE:
09246
case PACKAGE:
09247
case PROCEDURE:
09248
case FUNCTION:
09249
case TASK:
09250
case PROTECTED:
09251
case FOR:
09252
case END:
09253
case SUBTYPE:
09254
case GENERIC:
09255
case BEGIN:
09256 {
09257
pkg_body_part();
09258
if (inputState->guessing==0) {
09259 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09260 }
09261
end_id_opt();
09262
if ( inputState->guessing==0 ) {
09263
#line 974 "ada.g"
09264
Set(pkg_AST, PACKAGE_BODY);
09265
#line 9266 "AdaParser.cpp"
09266
}
09267
break;
09268 }
09269
default:
09270 {
09271
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09272 }
09273 }
09274 }
09275 match(SEMI);
09276
break;
09277 }
09278
case IDENTIFIER:
09279 {
09280
def_id(
false);
09281
if (inputState->guessing==0) {
09282 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09283 }
09284
spec_decl_part(pkg_AST);
09285
if (inputState->guessing==0) {
09286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09287 }
09288
break;
09289 }
09290
default:
09291 {
09292
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09293 }
09294 }
09295 }
09296
break;
09297 }
09298
case TASK:
09299 {
09300 tsk = LT(1);
09301
if ( inputState->guessing == 0 ) {
09302 tsk_AST = astFactory->create(tsk);
09303 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tsk_AST.get()));
09304 }
09305 match(TASK);
09306 {
09307
switch ( LA(1)) {
09308
case BODY:
09309 {
09310
body_is();
09311
if (inputState->guessing==0) {
09312 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09313 }
09314 {
09315
switch ( LA(1)) {
09316
case SEPARATE:
09317 {
09318
separate();
09319
if (inputState->guessing==0) {
09320 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09321 }
09322
if ( inputState->guessing==0 ) {
09323
#line 980 "ada.g"
09324
Set(tsk_AST, TASK_BODY_STUB);
09325
#line 9326 "AdaParser.cpp"
09326
}
09327
break;
09328 }
09329
case PRAGMA:
09330
case IDENTIFIER:
09331
case USE:
09332
case TYPE:
09333
case PACKAGE:
09334
case PROCEDURE:
09335
case FUNCTION:
09336
case TASK:
09337
case PROTECTED:
09338
case FOR:
09339
case SUBTYPE:
09340
case GENERIC:
09341
case BEGIN:
09342 {
09343
body_part();
09344
if (inputState->guessing==0) {
09345 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09346 }
09347
if ( inputState->guessing==0 ) {
09348
#line 981 "ada.g"
09349
Set(tsk_AST, TASK_BODY);
09350
#line 9351 "AdaParser.cpp"
09351
}
09352
break;
09353 }
09354
default:
09355 {
09356
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09357 }
09358 }
09359 }
09360 match(SEMI);
09361
break;
09362 }
09363
case IDENTIFIER:
09364
case TYPE:
09365 {
09366
task_type_or_single_decl(tsk_AST);
09367
if (inputState->guessing==0) {
09368 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09369 }
09370
break;
09371 }
09372
default:
09373 {
09374
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09375 }
09376 }
09377 }
09378
break;
09379 }
09380
case PROTECTED:
09381 {
09382 pro = LT(1);
09383
if ( inputState->guessing == 0 ) {
09384 pro_AST = astFactory->create(pro);
09385 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pro_AST.get()));
09386 }
09387 match(PROTECTED);
09388 {
09389
switch ( LA(1)) {
09390
case BODY:
09391 {
09392
body_is();
09393
if (inputState->guessing==0) {
09394 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09395 }
09396 {
09397
switch ( LA(1)) {
09398
case SEPARATE:
09399 {
09400
separate();
09401
if (inputState->guessing==0) {
09402 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09403 }
09404
if ( inputState->guessing==0 ) {
09405
#line 988 "ada.g"
09406
Set(pro_AST, PROTECTED_BODY_STUB);
09407
#line 9408 "AdaParser.cpp"
09408
}
09409
break;
09410 }
09411
case PRAGMA:
09412
case PROCEDURE:
09413
case FUNCTION:
09414
case ENTRY:
09415
case END:
09416 {
09417
prot_op_bodies_opt();
09418
if (inputState->guessing==0) {
09419 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09420 }
09421
end_id_opt();
09422
if ( inputState->guessing==0 ) {
09423
#line 990 "ada.g"
09424
Set(pro_AST, PROTECTED_BODY);
09425
#line 9426 "AdaParser.cpp"
09426
}
09427
break;
09428 }
09429
default:
09430 {
09431
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09432 }
09433 }
09434 }
09435
break;
09436 }
09437
case IDENTIFIER:
09438
case TYPE:
09439 {
09440
prot_type_or_single_decl(pro_AST);
09441
if (inputState->guessing==0) {
09442 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09443 }
09444
break;
09445 }
09446
default:
09447 {
09448
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09449 }
09450 }
09451 }
09452 match(SEMI);
09453
break;
09454 }
09455
case PROCEDURE:
09456
case FUNCTION:
09457 {
09458
subprog_decl_or_rename_or_inst_or_body(
false);
09459
if (inputState->guessing==0) {
09460 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09461 }
09462
break;
09463 }
09464
case IDENTIFIER:
09465
case USE:
09466
case TYPE:
09467
case FOR:
09468
case SUBTYPE:
09469
case GENERIC:
09470 {
09471
decl_common();
09472
if (inputState->guessing==0) {
09473 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09474 }
09475
break;
09476 }
09477
default:
09478 {
09479
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09480 }
09481 }
09482 }
09483 declarative_item_AST = (currentAST.
root);
09484 }
09485
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09486
if( inputState->guessing == 0 ) {
09487
reportError(ex);
09488 consume();
09489 consumeUntil(
_tokenSet_84);
09490 }
else {
09491
throw;
09492 }
09493 }
09494
returnAST = declarative_item_AST;
09495 }
09496
09497 void AdaParser::body_is() {
09498
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09499
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09500
RefAdaAST body_is_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09501
09502
try {
09503 match(BODY);
09504
def_id(
false);
09505
if (inputState->guessing==0) {
09506 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09507 }
09508 match(IS);
09509 body_is_AST = (currentAST.
root);
09510 }
09511
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09512
if( inputState->guessing == 0 ) {
09513
reportError(ex);
09514 consume();
09515 consumeUntil(
_tokenSet_85);
09516 }
else {
09517
throw;
09518 }
09519 }
09520
returnAST = body_is_AST;
09521 }
09522
09523 void AdaParser::separate() {
09524
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09525
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09526
RefAdaAST separate_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09527
09528
try {
09529 match(SEPARATE);
09530
if ( inputState->guessing==0 ) {
09531
#line 1009 "ada.g"
09532
pop_def_id();
09533
#line 9534 "AdaParser.cpp"
09534
}
09535 separate_AST = (currentAST.
root);
09536 }
09537
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09538
if( inputState->guessing == 0 ) {
09539
reportError(ex);
09540 consume();
09541 consumeUntil(
_tokenSet_4);
09542 }
else {
09543
throw;
09544 }
09545 }
09546
returnAST = separate_AST;
09547 }
09548
09549 void AdaParser::prot_op_bodies_opt() {
09550
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09551
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09552
RefAdaAST prot_op_bodies_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09553
09554
try {
09555 {
09556
for (;;) {
09557
switch ( LA(1)) {
09558
case ENTRY:
09559 {
09560
entry_body();
09561
if (inputState->guessing==0) {
09562 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09563 }
09564
break;
09565 }
09566
case PROCEDURE:
09567
case FUNCTION:
09568 {
09569
subprog_decl_or_body();
09570
if (inputState->guessing==0) {
09571 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09572 }
09573
break;
09574 }
09575
case PRAGMA:
09576 {
09577
pragma();
09578
if (inputState->guessing==0) {
09579 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09580 }
09581
break;
09582 }
09583
default:
09584 {
09585
goto _loop330;
09586 }
09587 }
09588 }
09589 _loop330:;
09590 }
09591
if ( inputState->guessing==0 ) {
09592 prot_op_bodies_opt_AST =
RefAdaAST(currentAST.
root);
09593
#line 1025 "ada.g"
09594
prot_op_bodies_opt_AST =
09595
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_OP_BODIES_OPT,
"PROT_OP_BODIES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_op_bodies_opt_AST.get()))));
09596
#line 9597 "AdaParser.cpp"
09597
currentAST.
root = prot_op_bodies_opt_AST;
09598
if ( prot_op_bodies_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
09599 prot_op_bodies_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
09600 currentAST.
child = prot_op_bodies_opt_AST->getFirstChild();
09601
else
09602 currentAST.
child = prot_op_bodies_opt_AST;
09603 currentAST.
advanceChildToEnd();
09604 }
09605 prot_op_bodies_opt_AST = (currentAST.
root);
09606 }
09607
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09608
if( inputState->guessing == 0 ) {
09609
reportError(ex);
09610 consume();
09611 consumeUntil(
_tokenSet_21);
09612 }
else {
09613
throw;
09614 }
09615 }
09616
returnAST = prot_op_bodies_opt_AST;
09617 }
09618
09619 void AdaParser::block_body_opt() {
09620
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09621
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09622
RefAdaAST block_body_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09623
09624
try {
09625 {
09626
switch ( LA(1)) {
09627
case BEGIN:
09628 {
09629 match(BEGIN);
09630
handled_stmt_s();
09631
if (inputState->guessing==0) {
09632 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09633 }
09634
break;
09635 }
09636
case END:
09637 {
09638
break;
09639 }
09640
default:
09641 {
09642
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09643 }
09644 }
09645 }
09646
if ( inputState->guessing==0 ) {
09647 block_body_opt_AST =
RefAdaAST(currentAST.
root);
09648
#line 1016 "ada.g"
09649
block_body_opt_AST =
09650
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BLOCK_BODY_OPT,
"BLOCK_BODY_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(block_body_opt_AST.get()))));
09651
#line 9652 "AdaParser.cpp"
09652
currentAST.
root = block_body_opt_AST;
09653
if ( block_body_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
09654 block_body_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
09655 currentAST.
child = block_body_opt_AST->getFirstChild();
09656
else
09657 currentAST.
child = block_body_opt_AST;
09658 currentAST.
advanceChildToEnd();
09659 }
09660 block_body_opt_AST = (currentAST.
root);
09661 }
09662
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09663
if( inputState->guessing == 0 ) {
09664
reportError(ex);
09665 consume();
09666 consumeUntil(
_tokenSet_21);
09667 }
else {
09668
throw;
09669 }
09670 }
09671
returnAST = block_body_opt_AST;
09672 }
09673
09674 void AdaParser::handled_stmt_s() {
09675
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09676
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09677
RefAdaAST handled_stmt_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09678
09679
try {
09680
statements();
09681
if (inputState->guessing==0) {
09682 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09683 }
09684
except_handler_part_opt();
09685
if (inputState->guessing==0) {
09686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09687 }
09688
if ( inputState->guessing==0 ) {
09689 handled_stmt_s_AST =
RefAdaAST(currentAST.
root);
09690
#line 1048 "ada.g"
09691
handled_stmt_s_AST =
09692
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(HANDLED_SEQUENCE_OF_STATEMENTS,
"HANDLED_SEQUENCE_OF_STATEMENTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(handled_stmt_s_AST.get()))));
09693
#line 9694 "AdaParser.cpp"
09694
currentAST.
root = handled_stmt_s_AST;
09695
if ( handled_stmt_s_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
09696 handled_stmt_s_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
09697 currentAST.
child = handled_stmt_s_AST->getFirstChild();
09698
else
09699 currentAST.
child = handled_stmt_s_AST;
09700 currentAST.
advanceChildToEnd();
09701 }
09702 handled_stmt_s_AST = (currentAST.
root);
09703 }
09704
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09705
if( inputState->guessing == 0 ) {
09706
reportError(ex);
09707 consume();
09708 consumeUntil(
_tokenSet_21);
09709 }
else {
09710
throw;
09711 }
09712 }
09713
returnAST = handled_stmt_s_AST;
09714 }
09715
09716 void AdaParser::entry_body() {
09717
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09718
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09719
RefAdaAST entry_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09720
ANTLR_USE_NAMESPACE(antlr)
RefToken e =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09721
RefAdaAST e_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09722
09723
try {
09724 e = LT(1);
09725
if ( inputState->guessing == 0 ) {
09726 e_AST = astFactory->create(e);
09727 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(e_AST.get()));
09728 }
09729 match(ENTRY);
09730
def_id(
false);
09731
if (inputState->guessing==0) {
09732 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09733 }
09734
entry_body_formal_part();
09735
if (inputState->guessing==0) {
09736 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09737 }
09738
entry_barrier();
09739
if (inputState->guessing==0) {
09740 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09741 }
09742 match(IS);
09743
body_part();
09744
if (inputState->guessing==0) {
09745 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09746 }
09747 match(SEMI);
09748
if ( inputState->guessing==0 ) {
09749
#line 1211 "ada.g"
09750
Set (e_AST, ENTRY_BODY);
09751
#line 9752 "AdaParser.cpp"
09752
}
09753 entry_body_AST = (currentAST.
root);
09754 }
09755
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09756
if( inputState->guessing == 0 ) {
09757
reportError(ex);
09758 consume();
09759 consumeUntil(
_tokenSet_86);
09760 }
else {
09761
throw;
09762 }
09763 }
09764
returnAST = entry_body_AST;
09765 }
09766
09767 void AdaParser::subprog_decl_or_body() {
09768
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09769
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09770
RefAdaAST subprog_decl_or_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09771
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09772
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09773
ANTLR_USE_NAMESPACE(antlr)
RefToken f =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
09774
RefAdaAST f_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09775
09776
try {
09777
switch ( LA(1)) {
09778
case PROCEDURE:
09779 {
09780 p = LT(1);
09781
if ( inputState->guessing == 0 ) {
09782 p_AST = astFactory->create(p);
09783 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
09784 }
09785 match(PROCEDURE);
09786
def_id(
false);
09787
if (inputState->guessing==0) {
09788 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09789 }
09790
formal_part_opt();
09791
if (inputState->guessing==0) {
09792 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09793 }
09794 {
09795
switch ( LA(1)) {
09796
case IS:
09797 {
09798 match(IS);
09799
body_part();
09800
if (inputState->guessing==0) {
09801 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09802 }
09803
if ( inputState->guessing==0 ) {
09804
#line 1032 "ada.g"
09805
Set(p_AST, PROCEDURE_BODY);
09806
#line 9807 "AdaParser.cpp"
09807
}
09808
break;
09809 }
09810
case SEMI:
09811 {
09812
if ( inputState->guessing==0 ) {
09813
#line 1033 "ada.g"
09814
pop_def_id();
Set(p_AST, PROCEDURE_DECLARATION);
09815
#line 9816 "AdaParser.cpp"
09816
}
09817
break;
09818 }
09819
default:
09820 {
09821
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09822 }
09823 }
09824 }
09825 match(SEMI);
09826 subprog_decl_or_body_AST = (currentAST.
root);
09827
break;
09828 }
09829
case FUNCTION:
09830 {
09831 f = LT(1);
09832
if ( inputState->guessing == 0 ) {
09833 f_AST = astFactory->create(f);
09834 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
09835 }
09836 match(FUNCTION);
09837
def_designator(
false);
09838
if (inputState->guessing==0) {
09839 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09840 }
09841
function_tail();
09842
if (inputState->guessing==0) {
09843 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09844 }
09845 {
09846
switch ( LA(1)) {
09847
case IS:
09848 {
09849 match(IS);
09850
body_part();
09851
if (inputState->guessing==0) {
09852 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09853 }
09854
if ( inputState->guessing==0 ) {
09855
#line 1037 "ada.g"
09856
Set(f_AST, FUNCTION_BODY);
09857
#line 9858 "AdaParser.cpp"
09858
}
09859
break;
09860 }
09861
case SEMI:
09862 {
09863
if ( inputState->guessing==0 ) {
09864
#line 1038 "ada.g"
09865
pop_def_id();
Set(f_AST, FUNCTION_DECLARATION);
09866
#line 9867 "AdaParser.cpp"
09867
}
09868
break;
09869 }
09870
default:
09871 {
09872
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09873 }
09874 }
09875 }
09876 match(SEMI);
09877 subprog_decl_or_body_AST = (currentAST.
root);
09878
break;
09879 }
09880
default:
09881 {
09882
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
09883 }
09884 }
09885 }
09886
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09887
if( inputState->guessing == 0 ) {
09888
reportError(ex);
09889 consume();
09890 consumeUntil(
_tokenSet_86);
09891 }
else {
09892
throw;
09893 }
09894 }
09895
returnAST = subprog_decl_or_body_AST;
09896 }
09897
09898 void AdaParser::statements() {
09899
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09900
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09901
RefAdaAST statements_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09902
09903
try {
09904 {
09905
int _cnt338=0;
09906
for (;;) {
09907
switch ( LA(1)) {
09908
case PRAGMA:
09909 {
09910
pragma();
09911
if (inputState->guessing==0) {
09912 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09913 }
09914
break;
09915 }
09916
case IDENTIFIER:
09917
case NuLL:
09918
case RETURN:
09919
case FOR:
09920
case CASE:
09921
case BEGIN:
09922
case LT_LT:
09923
case IF:
09924
case LOOP:
09925
case WHILE:
09926
case DECLARE:
09927
case EXIT:
09928
case GOTO:
09929
case ACCEPT:
09930
case DELAY:
09931
case SELECT:
09932
case ABORT:
09933
case RAISE:
09934
case REQUEUE:
09935 {
09936
statement();
09937
if (inputState->guessing==0) {
09938 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09939 }
09940
break;
09941 }
09942
default:
09943 {
09944
if ( _cnt338>=1 ) {
goto _loop338; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
09945 }
09946 }
09947 _cnt338++;
09948 }
09949 _loop338:;
09950 }
09951
if ( inputState->guessing==0 ) {
09952 statements_AST =
RefAdaAST(currentAST.
root);
09953
#line 1054 "ada.g"
09954
statements_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SEQUENCE_OF_STATEMENTS,
"SEQUENCE_OF_STATEMENTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(statements_AST.get()))));
09955
#line 9956 "AdaParser.cpp"
09956
currentAST.
root = statements_AST;
09957
if ( statements_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
09958 statements_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
09959 currentAST.
child = statements_AST->getFirstChild();
09960
else
09961 currentAST.
child = statements_AST;
09962 currentAST.
advanceChildToEnd();
09963 }
09964 statements_AST = (currentAST.
root);
09965 }
09966
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
09967
if( inputState->guessing == 0 ) {
09968
reportError(ex);
09969 consume();
09970 consumeUntil(
_tokenSet_87);
09971 }
else {
09972
throw;
09973 }
09974 }
09975
returnAST = statements_AST;
09976 }
09977
09978 void AdaParser::except_handler_part_opt() {
09979
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09980
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
09981
RefAdaAST except_handler_part_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
09982
09983
try {
09984 {
09985
switch ( LA(1)) {
09986
case EXCEPTION:
09987 {
09988 match(EXCEPTION);
09989 {
09990
int _cnt424=0;
09991
for (;;) {
09992
if ((LA(1) == WHEN)) {
09993
exception_handler();
09994
if (inputState->guessing==0) {
09995 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
09996 }
09997 }
09998
else {
09999
if ( _cnt424>=1 ) {
goto _loop424; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
10000 }
10001
10002 _cnt424++;
10003 }
10004 _loop424:;
10005 }
10006
break;
10007 }
10008
case END:
10009 {
10010
break;
10011 }
10012
default:
10013 {
10014
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10015 }
10016 }
10017 }
10018
if ( inputState->guessing==0 ) {
10019 except_handler_part_opt_AST =
RefAdaAST(currentAST.
root);
10020
#line 1340 "ada.g"
10021
except_handler_part_opt_AST =
10022
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXCEPT_HANDLER_PART_OPT,
"EXCEPT_HANDLER_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(except_handler_part_opt_AST.get()))));
10023
#line 10024 "AdaParser.cpp"
10024
currentAST.
root = except_handler_part_opt_AST;
10025
if ( except_handler_part_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
10026 except_handler_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
10027 currentAST.
child = except_handler_part_opt_AST->getFirstChild();
10028
else
10029 currentAST.
child = except_handler_part_opt_AST;
10030 currentAST.
advanceChildToEnd();
10031 }
10032 except_handler_part_opt_AST = (currentAST.
root);
10033 }
10034
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10035
if( inputState->guessing == 0 ) {
10036
reportError(ex);
10037 consume();
10038 consumeUntil(
_tokenSet_21);
10039 }
else {
10040
throw;
10041 }
10042 }
10043
returnAST = except_handler_part_opt_AST;
10044 }
10045
10046 void AdaParser::statement() {
10047
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10048
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10049
RefAdaAST statement_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10050
10051
try {
10052
def_label_opt();
10053
if (inputState->guessing==0) {
10054 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10055 }
10056 {
10057
switch ( LA(1)) {
10058
case NuLL:
10059 {
10060
null_stmt();
10061
if (inputState->guessing==0) {
10062 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10063 }
10064
break;
10065 }
10066
case EXIT:
10067 {
10068
exit_stmt();
10069
if (inputState->guessing==0) {
10070 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10071 }
10072
break;
10073 }
10074
case RETURN:
10075 {
10076
return_stmt();
10077
if (inputState->guessing==0) {
10078 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10079 }
10080
break;
10081 }
10082
case GOTO:
10083 {
10084
goto_stmt();
10085
if (inputState->guessing==0) {
10086 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10087 }
10088
break;
10089 }
10090
case DELAY:
10091 {
10092
delay_stmt();
10093
if (inputState->guessing==0) {
10094 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10095 }
10096
break;
10097 }
10098
case ABORT:
10099 {
10100
abort_stmt();
10101
if (inputState->guessing==0) {
10102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10103 }
10104
break;
10105 }
10106
case RAISE:
10107 {
10108
raise_stmt();
10109
if (inputState->guessing==0) {
10110 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10111 }
10112
break;
10113 }
10114
case REQUEUE:
10115 {
10116
requeue_stmt();
10117
if (inputState->guessing==0) {
10118 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10119 }
10120
break;
10121 }
10122
case ACCEPT:
10123 {
10124
accept_stmt();
10125
if (inputState->guessing==0) {
10126 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10127 }
10128
break;
10129 }
10130
case SELECT:
10131 {
10132
select_stmt();
10133
if (inputState->guessing==0) {
10134 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10135 }
10136
break;
10137 }
10138
case IF:
10139 {
10140
if_stmt();
10141
if (inputState->guessing==0) {
10142 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10143 }
10144
break;
10145 }
10146
case CASE:
10147 {
10148
case_stmt();
10149
if (inputState->guessing==0) {
10150 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10151 }
10152
break;
10153 }
10154
case FOR:
10155
case LOOP:
10156
case WHILE:
10157 {
10158
loop_stmt();
10159
if (inputState->guessing==0) {
10160 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10161 }
10162 match(SEMI);
10163
break;
10164 }
10165
case BEGIN:
10166
case DECLARE:
10167 {
10168
block();
10169
if (inputState->guessing==0) {
10170 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10171 }
10172 match(END);
10173 match(SEMI);
10174
break;
10175 }
10176
default:
10177
if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
10178
statement_identifier();
10179
if (inputState->guessing==0) {
10180 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10181 }
10182 {
10183
switch ( LA(1)) {
10184
case FOR:
10185
case LOOP:
10186
case WHILE:
10187 {
10188
loop_stmt();
10189
if (inputState->guessing==0) {
10190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10191 }
10192
id_opt();
10193 match(SEMI);
10194
break;
10195 }
10196
case BEGIN:
10197
case DECLARE:
10198 {
10199
block();
10200
if (inputState->guessing==0) {
10201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10202 }
10203
end_id_opt();
10204 match(SEMI);
10205
break;
10206 }
10207
default:
10208 {
10209
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10210 }
10211 }
10212 }
10213 }
10214
else if ((LA(1) == IDENTIFIER) && (
_tokenSet_88.member(LA(2)))) {
10215
call_or_assignment();
10216
if (inputState->guessing==0) {
10217 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10218 }
10219 }
10220
else {
10221
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10222 }
10223 }
10224 }
10225
if ( inputState->guessing==0 ) {
10226 statement_AST =
RefAdaAST(currentAST.
root);
10227
#line 1080 "ada.g"
10228
statement_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(STATEMENT,
"STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(statement_AST.get()))));
10229
#line 10230 "AdaParser.cpp"
10230
currentAST.
root = statement_AST;
10231
if ( statement_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
10232 statement_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
10233 currentAST.
child = statement_AST->getFirstChild();
10234
else
10235 currentAST.
child = statement_AST;
10236 currentAST.
advanceChildToEnd();
10237 }
10238 statement_AST = (currentAST.
root);
10239 }
10240
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10241
if( inputState->guessing == 0 ) {
10242
reportError(ex);
10243 consume();
10244 consumeUntil(
_tokenSet_89);
10245 }
else {
10246
throw;
10247 }
10248 }
10249
returnAST = statement_AST;
10250 }
10251
10252 void AdaParser::def_label_opt() {
10253
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10254
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10255
RefAdaAST def_label_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10256
10257
try {
10258 {
10259
switch ( LA(1)) {
10260
case LT_LT:
10261 {
10262 match(LT_LT);
10263
RefAdaAST tmp279_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10264
if ( inputState->guessing == 0 ) {
10265 tmp279_AST = astFactory->create(LT(1));
10266 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp279_AST.get()));
10267 }
10268 match(IDENTIFIER);
10269 match(GT_GT);
10270
break;
10271 }
10272
case IDENTIFIER:
10273
case NuLL:
10274
case RETURN:
10275
case FOR:
10276
case CASE:
10277
case BEGIN:
10278
case IF:
10279
case LOOP:
10280
case WHILE:
10281
case DECLARE:
10282
case EXIT:
10283
case GOTO:
10284
case ACCEPT:
10285
case DELAY:
10286
case SELECT:
10287
case ABORT:
10288
case RAISE:
10289
case REQUEUE:
10290 {
10291
break;
10292 }
10293
default:
10294 {
10295
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10296 }
10297 }
10298 }
10299
if ( inputState->guessing==0 ) {
10300 def_label_opt_AST =
RefAdaAST(currentAST.
root);
10301
#line 1084 "ada.g"
10302
def_label_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LABEL_OPT,
"LABEL_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(def_label_opt_AST.get()))));
10303
#line 10304 "AdaParser.cpp"
10304
currentAST.
root = def_label_opt_AST;
10305
if ( def_label_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
10306 def_label_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
10307 currentAST.
child = def_label_opt_AST->getFirstChild();
10308
else
10309 currentAST.
child = def_label_opt_AST;
10310 currentAST.
advanceChildToEnd();
10311 }
10312 def_label_opt_AST = (currentAST.
root);
10313 }
10314
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10315
if( inputState->guessing == 0 ) {
10316
reportError(ex);
10317 consume();
10318 consumeUntil(
_tokenSet_90);
10319 }
else {
10320
throw;
10321 }
10322 }
10323
returnAST = def_label_opt_AST;
10324 }
10325
10326 void AdaParser::null_stmt() {
10327
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10328
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10329
RefAdaAST null_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10330
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10331
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10332
10333
try {
10334 s = LT(1);
10335
if ( inputState->guessing == 0 ) {
10336 s_AST = astFactory->create(s);
10337 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10338 }
10339 match(NuLL);
10340 match(SEMI);
10341
if ( inputState->guessing==0 ) {
10342
#line 1088 "ada.g"
10343
Set(s_AST, NULL_STATEMENT);
10344
#line 10345 "AdaParser.cpp"
10345
}
10346 null_stmt_AST = (currentAST.
root);
10347 }
10348
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10349
if( inputState->guessing == 0 ) {
10350
reportError(ex);
10351 consume();
10352 consumeUntil(
_tokenSet_89);
10353 }
else {
10354
throw;
10355 }
10356 }
10357
returnAST = null_stmt_AST;
10358 }
10359
10360 void AdaParser::exit_stmt() {
10361
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10362
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10363
RefAdaAST exit_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10364
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10365
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10366
10367
try {
10368 s = LT(1);
10369
if ( inputState->guessing == 0 ) {
10370 s_AST = astFactory->create(s);
10371 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10372 }
10373 match(EXIT);
10374 {
10375
switch ( LA(1)) {
10376
case IDENTIFIER:
10377 {
10378
label_name();
10379
if (inputState->guessing==0) {
10380 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10381 }
10382
break;
10383 }
10384
case SEMI:
10385
case WHEN:
10386 {
10387
break;
10388 }
10389
default:
10390 {
10391
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10392 }
10393 }
10394 }
10395 {
10396
switch ( LA(1)) {
10397
case WHEN:
10398 {
10399
RefAdaAST tmp282_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10400
if ( inputState->guessing == 0 ) {
10401 tmp282_AST = astFactory->create(LT(1));
10402 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp282_AST.get()));
10403 }
10404 match(WHEN);
10405
condition();
10406
if (inputState->guessing==0) {
10407 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10408 }
10409
break;
10410 }
10411
case SEMI:
10412 {
10413
break;
10414 }
10415
default:
10416 {
10417
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10418 }
10419 }
10420 }
10421 match(SEMI);
10422
if ( inputState->guessing==0 ) {
10423
#line 1181 "ada.g"
10424
Set(s_AST, EXIT_STATEMENT);
10425
#line 10426 "AdaParser.cpp"
10426
}
10427 exit_stmt_AST = (currentAST.
root);
10428 }
10429
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10430
if( inputState->guessing == 0 ) {
10431
reportError(ex);
10432 consume();
10433 consumeUntil(
_tokenSet_89);
10434 }
else {
10435
throw;
10436 }
10437 }
10438
returnAST = exit_stmt_AST;
10439 }
10440
10441 void AdaParser::return_stmt() {
10442
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10443
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10444
RefAdaAST return_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10445
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10446
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10447
10448
try {
10449 s = LT(1);
10450
if ( inputState->guessing == 0 ) {
10451 s_AST = astFactory->create(s);
10452 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10453 }
10454 match(RETURN);
10455 {
10456
switch ( LA(1)) {
10457
case IDENTIFIER:
10458
case LPAREN:
10459
case NEW:
10460
case CHARACTER_LITERAL:
10461
case CHAR_STRING:
10462
case NuLL:
10463
case NOT:
10464
case PLUS:
10465
case MINUS:
10466
case ABS:
10467
case NUMERIC_LIT:
10468 {
10469
expression();
10470
if (inputState->guessing==0) {
10471 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10472 }
10473
break;
10474 }
10475
case SEMI:
10476 {
10477
break;
10478 }
10479
default:
10480 {
10481
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10482 }
10483 }
10484 }
10485 match(SEMI);
10486
if ( inputState->guessing==0 ) {
10487
#line 1188 "ada.g"
10488
Set(s_AST, RETURN_STATEMENT);
10489
#line 10490 "AdaParser.cpp"
10490
}
10491 return_stmt_AST = (currentAST.
root);
10492 }
10493
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10494
if( inputState->guessing == 0 ) {
10495
reportError(ex);
10496 consume();
10497 consumeUntil(
_tokenSet_89);
10498 }
else {
10499
throw;
10500 }
10501 }
10502
returnAST = return_stmt_AST;
10503 }
10504
10505 void AdaParser::goto_stmt() {
10506
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10507
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10508
RefAdaAST goto_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10509
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10510
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10511
10512
try {
10513 s = LT(1);
10514
if ( inputState->guessing == 0 ) {
10515 s_AST = astFactory->create(s);
10516 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10517 }
10518 match(GOTO);
10519
label_name();
10520
if (inputState->guessing==0) {
10521 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10522 }
10523 match(SEMI);
10524
if ( inputState->guessing==0 ) {
10525
#line 1192 "ada.g"
10526
Set(s_AST, GOTO_STATEMENT);
10527
#line 10528 "AdaParser.cpp"
10528
}
10529 goto_stmt_AST = (currentAST.
root);
10530 }
10531
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10532
if( inputState->guessing == 0 ) {
10533
reportError(ex);
10534 consume();
10535 consumeUntil(
_tokenSet_89);
10536 }
else {
10537
throw;
10538 }
10539 }
10540
returnAST = goto_stmt_AST;
10541 }
10542
10543 void AdaParser::delay_stmt() {
10544
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10545
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10546
RefAdaAST delay_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10547
ANTLR_USE_NAMESPACE(antlr)
RefToken d =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10548
RefAdaAST d_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10549
10550
try {
10551 d = LT(1);
10552
if ( inputState->guessing == 0 ) {
10553 d_AST = astFactory->create(d);
10554 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get()));
10555 }
10556 match(DELAY);
10557
until_opt();
10558
if (inputState->guessing==0) {
10559 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10560 }
10561
expression();
10562
if (inputState->guessing==0) {
10563 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10564 }
10565 match(SEMI);
10566
if ( inputState->guessing==0 ) {
10567
#line 1257 "ada.g"
10568
Set (d_AST, DELAY_STATEMENT);
10569
#line 10570 "AdaParser.cpp"
10570
}
10571 delay_stmt_AST = (currentAST.
root);
10572 }
10573
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10574
if( inputState->guessing == 0 ) {
10575
reportError(ex);
10576 consume();
10577 consumeUntil(
_tokenSet_89);
10578 }
else {
10579
throw;
10580 }
10581 }
10582
returnAST = delay_stmt_AST;
10583 }
10584
10585 void AdaParser::abort_stmt() {
10586
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10587
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10588
RefAdaAST abort_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10589
ANTLR_USE_NAMESPACE(antlr)
RefToken a =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10590
RefAdaAST a_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10591
10592
try {
10593 a = LT(1);
10594
if ( inputState->guessing == 0 ) {
10595 a_AST = astFactory->create(a);
10596 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get()));
10597 }
10598 match(ABORT);
10599
name();
10600
if (inputState->guessing==0) {
10601 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10602 }
10603 {
10604
for (;;) {
10605
if ((LA(1) == COMMA)) {
10606 match(COMMA);
10607
name();
10608
if (inputState->guessing==0) {
10609 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10610 }
10611 }
10612
else {
10613
goto _loop420;
10614 }
10615
10616 }
10617 _loop420:;
10618 }
10619 match(SEMI);
10620
if ( inputState->guessing==0 ) {
10621
#line 1336 "ada.g"
10622
Set (a_AST, ABORT_STATEMENT);
10623
#line 10624 "AdaParser.cpp"
10624
}
10625 abort_stmt_AST = (currentAST.
root);
10626 }
10627
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10628
if( inputState->guessing == 0 ) {
10629
reportError(ex);
10630 consume();
10631 consumeUntil(
_tokenSet_89);
10632 }
else {
10633
throw;
10634 }
10635 }
10636
returnAST = abort_stmt_AST;
10637 }
10638
10639 void AdaParser::raise_stmt() {
10640
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10641
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10642
RefAdaAST raise_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10643
ANTLR_USE_NAMESPACE(antlr)
RefToken r =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10644
RefAdaAST r_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10645
10646
try {
10647 r = LT(1);
10648
if ( inputState->guessing == 0 ) {
10649 r_AST = astFactory->create(r);
10650 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
10651 }
10652 match(RAISE);
10653 {
10654
switch ( LA(1)) {
10655
case IDENTIFIER:
10656 {
10657
compound_name();
10658
if (inputState->guessing==0) {
10659 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10660 }
10661
break;
10662 }
10663
case SEMI:
10664 {
10665
break;
10666 }
10667
default:
10668 {
10669
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10670 }
10671 }
10672 }
10673 match(SEMI);
10674
if ( inputState->guessing==0 ) {
10675
#line 1364 "ada.g"
10676
Set (r_AST, RAISE_STATEMENT);
10677
#line 10678 "AdaParser.cpp"
10678
}
10679 raise_stmt_AST = (currentAST.
root);
10680 }
10681
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10682
if( inputState->guessing == 0 ) {
10683
reportError(ex);
10684 consume();
10685 consumeUntil(
_tokenSet_89);
10686 }
else {
10687
throw;
10688 }
10689 }
10690
returnAST = raise_stmt_AST;
10691 }
10692
10693 void AdaParser::requeue_stmt() {
10694
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10695
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10696
RefAdaAST requeue_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10697
ANTLR_USE_NAMESPACE(antlr)
RefToken r =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10698
RefAdaAST r_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10699
10700
try {
10701 r = LT(1);
10702
if ( inputState->guessing == 0 ) {
10703 r_AST = astFactory->create(r);
10704 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
10705 }
10706 match(REQUEUE);
10707
name();
10708
if (inputState->guessing==0) {
10709 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10710 }
10711 {
10712
switch ( LA(1)) {
10713
case WITH:
10714 {
10715 match(WITH);
10716
RefAdaAST tmp291_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10717
if ( inputState->guessing == 0 ) {
10718 tmp291_AST = astFactory->create(LT(1));
10719 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp291_AST.get()));
10720 }
10721 match(ABORT);
10722
break;
10723 }
10724
case SEMI:
10725 {
10726
break;
10727 }
10728
default:
10729 {
10730
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10731 }
10732 }
10733 }
10734 match(SEMI);
10735
if ( inputState->guessing==0 ) {
10736
#line 1368 "ada.g"
10737
Set (r_AST, REQUEUE_STATEMENT);
10738
#line 10739 "AdaParser.cpp"
10739
}
10740 requeue_stmt_AST = (currentAST.
root);
10741 }
10742
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10743
if( inputState->guessing == 0 ) {
10744
reportError(ex);
10745 consume();
10746 consumeUntil(
_tokenSet_89);
10747 }
else {
10748
throw;
10749 }
10750 }
10751
returnAST = requeue_stmt_AST;
10752 }
10753
10754 void AdaParser::accept_stmt() {
10755
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10756
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10757
RefAdaAST accept_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10758
ANTLR_USE_NAMESPACE(antlr)
RefToken a =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10759
RefAdaAST a_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10760
10761
try {
10762 a = LT(1);
10763
if ( inputState->guessing == 0 ) {
10764 a_AST = astFactory->create(a);
10765 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get()));
10766 }
10767 match(ACCEPT);
10768
def_id(
false);
10769
if (inputState->guessing==0) {
10770 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10771 }
10772
entry_index_opt();
10773
if (inputState->guessing==0) {
10774 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10775 }
10776
formal_part_opt();
10777
if (inputState->guessing==0) {
10778 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10779 }
10780 {
10781
switch ( LA(1)) {
10782
case DO:
10783 {
10784 match(DO);
10785
handled_stmt_s();
10786
if (inputState->guessing==0) {
10787 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10788 }
10789
end_id_opt();
10790 match(SEMI);
10791
break;
10792 }
10793
case SEMI:
10794 {
10795 match(SEMI);
10796
if ( inputState->guessing==0 ) {
10797
#line 1239 "ada.g"
10798
pop_def_id();
10799
#line 10800 "AdaParser.cpp"
10800
}
10801
break;
10802 }
10803
default:
10804 {
10805
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10806 }
10807 }
10808 }
10809
if ( inputState->guessing==0 ) {
10810
#line 1241 "ada.g"
10811
Set (a_AST, ACCEPT_STATEMENT);
10812
#line 10813 "AdaParser.cpp"
10813
}
10814 accept_stmt_AST = (currentAST.
root);
10815 }
10816
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10817
if( inputState->guessing == 0 ) {
10818
reportError(ex);
10819 consume();
10820 consumeUntil(
_tokenSet_89);
10821 }
else {
10822
throw;
10823 }
10824 }
10825
returnAST = accept_stmt_AST;
10826 }
10827
10828 void AdaParser::select_stmt() {
10829
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10830
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10831
RefAdaAST select_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10832
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10833
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10834
10835
try {
10836 s = LT(1);
10837
if ( inputState->guessing == 0 ) {
10838 s_AST = astFactory->create(s);
10839 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10840 }
10841 match(SELECT);
10842 {
10843
bool synPredMatched398 =
false;
10844
if (((LA(1) == IDENTIFIER || LA(1) == DELAY) && (
_tokenSet_91.member(LA(2))))) {
10845
int _m398 = mark();
10846 synPredMatched398 =
true;
10847 inputState->guessing++;
10848
try {
10849 {
10850
triggering_alternative();
10851 match(THEN);
10852 match(ABORT);
10853 }
10854 }
10855
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
10856 synPredMatched398 =
false;
10857 }
10858 rewind(_m398);
10859 inputState->guessing--;
10860 }
10861
if ( synPredMatched398 ) {
10862
triggering_alternative();
10863
if (inputState->guessing==0) {
10864 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10865 }
10866 match(THEN);
10867 match(ABORT);
10868
abortable_part();
10869
if (inputState->guessing==0) {
10870 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10871 }
10872
if ( inputState->guessing==0 ) {
10873
#line 1272 "ada.g"
10874
Set (s_AST, ASYNCHRONOUS_SELECT);
10875
#line 10876 "AdaParser.cpp"
10876
}
10877 }
10878
else if ((
_tokenSet_92.member(LA(1))) && (
_tokenSet_93.member(LA(2)))) {
10879
selective_accept();
10880
if (inputState->guessing==0) {
10881 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10882 }
10883
if ( inputState->guessing==0 ) {
10884
#line 1274 "ada.g"
10885
Set (s_AST, SELECTIVE_ACCEPT);
10886
#line 10887 "AdaParser.cpp"
10887
}
10888 }
10889
else if ((LA(1) == IDENTIFIER) && (
_tokenSet_94.member(LA(2)))) {
10890
entry_call_alternative();
10891
if (inputState->guessing==0) {
10892 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10893 }
10894 {
10895
switch ( LA(1)) {
10896
case OR:
10897 {
10898 match(OR);
10899
delay_alternative();
10900
if (inputState->guessing==0) {
10901 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10902 }
10903
if ( inputState->guessing==0 ) {
10904
#line 1276 "ada.g"
10905
Set (s_AST, TIMED_ENTRY_CALL);
10906
#line 10907 "AdaParser.cpp"
10907
}
10908
break;
10909 }
10910
case ELSE:
10911 {
10912 match(ELSE);
10913
statements();
10914
if (inputState->guessing==0) {
10915 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10916 }
10917
if ( inputState->guessing==0 ) {
10918
#line 1277 "ada.g"
10919
Set (s_AST, CONDITIONAL_ENTRY_CALL);
10920
#line 10921 "AdaParser.cpp"
10921
}
10922
break;
10923 }
10924
default:
10925 {
10926
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10927 }
10928 }
10929 }
10930 }
10931
else {
10932
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
10933 }
10934
10935 }
10936 match(END);
10937 match(SELECT);
10938 match(SEMI);
10939 select_stmt_AST = (currentAST.
root);
10940 }
10941
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10942
if( inputState->guessing == 0 ) {
10943
reportError(ex);
10944 consume();
10945 consumeUntil(
_tokenSet_89);
10946 }
else {
10947
throw;
10948 }
10949 }
10950
returnAST = select_stmt_AST;
10951 }
10952
10953 void AdaParser::if_stmt() {
10954
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10955
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
10956
RefAdaAST if_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10957
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
10958
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
10959
10960
try {
10961 s = LT(1);
10962
if ( inputState->guessing == 0 ) {
10963 s_AST = astFactory->create(s);
10964 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10965 }
10966 match(IF);
10967
cond_clause();
10968
if (inputState->guessing==0) {
10969 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10970 }
10971
elsifs_opt();
10972
if (inputState->guessing==0) {
10973 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10974 }
10975
else_opt();
10976
if (inputState->guessing==0) {
10977 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
10978 }
10979 match(END);
10980 match(IF);
10981 match(SEMI);
10982
if ( inputState->guessing==0 ) {
10983
#line 1094 "ada.g"
10984
Set(s_AST, IF_STATEMENT);
10985
#line 10986 "AdaParser.cpp"
10986
}
10987 if_stmt_AST = (currentAST.
root);
10988 }
10989
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
10990
if( inputState->guessing == 0 ) {
10991
reportError(ex);
10992 consume();
10993 consumeUntil(
_tokenSet_89);
10994 }
else {
10995
throw;
10996 }
10997 }
10998
returnAST = if_stmt_AST;
10999 }
11000
11001 void AdaParser::case_stmt() {
11002
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11003
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11004
RefAdaAST case_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11005
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
11006
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11007
11008
try {
11009 s = LT(1);
11010
if ( inputState->guessing == 0 ) {
11011 s_AST = astFactory->create(s);
11012 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
11013 }
11014 match(CASE);
11015
expression();
11016
if (inputState->guessing==0) {
11017 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11018 }
11019 match(IS);
11020
alternative_s();
11021
if (inputState->guessing==0) {
11022 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11023 }
11024 match(END);
11025 match(CASE);
11026 match(SEMI);
11027
if ( inputState->guessing==0 ) {
11028
#line 1114 "ada.g"
11029
Set(s_AST, CASE_STATEMENT);
11030
#line 11031 "AdaParser.cpp"
11031
}
11032 case_stmt_AST = (currentAST.
root);
11033 }
11034
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11035
if( inputState->guessing == 0 ) {
11036
reportError(ex);
11037 consume();
11038 consumeUntil(
_tokenSet_89);
11039 }
else {
11040
throw;
11041 }
11042 }
11043
returnAST = case_stmt_AST;
11044 }
11045
11046 void AdaParser::loop_stmt() {
11047
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11048
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11049
RefAdaAST loop_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11050
11051
try {
11052
iteration_scheme_opt();
11053
if (inputState->guessing==0) {
11054 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11055 }
11056 match(LOOP);
11057
statements();
11058
if (inputState->guessing==0) {
11059 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11060 }
11061 match(END);
11062 match(LOOP);
11063
if ( inputState->guessing==0 ) {
11064 loop_stmt_AST =
RefAdaAST(currentAST.
root);
11065
#line 1126 "ada.g"
11066
loop_stmt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LOOP_STATEMENT,
"LOOP_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(loop_stmt_AST.get()))));
11067
#line 11068 "AdaParser.cpp"
11068
currentAST.
root = loop_stmt_AST;
11069
if ( loop_stmt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11070 loop_stmt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11071 currentAST.
child = loop_stmt_AST->getFirstChild();
11072
else
11073 currentAST.
child = loop_stmt_AST;
11074 currentAST.
advanceChildToEnd();
11075 }
11076 loop_stmt_AST = (currentAST.
root);
11077 }
11078
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11079
if( inputState->guessing == 0 ) {
11080
reportError(ex);
11081 consume();
11082 consumeUntil(
_tokenSet_95);
11083 }
else {
11084
throw;
11085 }
11086 }
11087
returnAST = loop_stmt_AST;
11088 }
11089
11090 void AdaParser::block() {
11091
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11092
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11093
RefAdaAST block_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11094
11095
try {
11096
declare_opt();
11097
if (inputState->guessing==0) {
11098 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11099 }
11100
block_body();
11101
if (inputState->guessing==0) {
11102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11103 }
11104
if ( inputState->guessing==0 ) {
11105 block_AST =
RefAdaAST(currentAST.
root);
11106
#line 1173 "ada.g"
11107
block_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BLOCK_STATEMENT,
"BLOCK_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(block_AST.get()))));
11108
#line 11109 "AdaParser.cpp"
11109
currentAST.
root = block_AST;
11110
if ( block_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11111 block_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11112 currentAST.
child = block_AST->getFirstChild();
11113
else
11114 currentAST.
child = block_AST;
11115 currentAST.
advanceChildToEnd();
11116 }
11117 block_AST = (currentAST.
root);
11118 }
11119
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11120
if( inputState->guessing == 0 ) {
11121
reportError(ex);
11122 consume();
11123 consumeUntil(
_tokenSet_21);
11124 }
else {
11125
throw;
11126 }
11127 }
11128
returnAST = block_AST;
11129 }
11130
11131 void AdaParser::statement_identifier() {
11132
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11133
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11134
RefAdaAST statement_identifier_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11135
ANTLR_USE_NAMESPACE(antlr)
RefToken n =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
11136
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11137
11138
try {
11139 n = LT(1);
11140
if ( inputState->guessing == 0 ) {
11141 n_AST = astFactory->create(n);
11142 }
11143 match(IDENTIFIER);
11144 match(COLON);
11145
if ( inputState->guessing==0 ) {
11146
#line 1161 "ada.g"
11147
push_def_id(n_AST);
11148
#line 11149 "AdaParser.cpp"
11149
}
11150 }
11151
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11152
if( inputState->guessing == 0 ) {
11153
reportError(ex);
11154 consume();
11155 consumeUntil(
_tokenSet_96);
11156 }
else {
11157
throw;
11158 }
11159 }
11160
returnAST = statement_identifier_AST;
11161 }
11162
11163 void AdaParser::id_opt() {
11164
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11165
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11166
RefAdaAST id_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11167
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11168
#line 1141 "ada.g"
11169
RefAdaAST endid;
11170
#line 11171 "AdaParser.cpp"
11171
11172
try {
11173
switch ( LA(1)) {
11174
case CHAR_STRING:
11175 {
11176 endid=
definable_operator_symbol();
11177
if (inputState->guessing==0) {
11178 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11179 }
11180
if (!(
end_id_matches_def_id (endid) ))
11181
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" end_id_matches_def_id (endid) ");
11182 id_opt_AST = (currentAST.
root);
11183
break;
11184 }
11185
case IDENTIFIER:
11186 {
11187
compound_name();
11188
if (inputState->guessing==0) {
11189 n_AST =
returnAST;
11190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11191 }
11192
if (!(
end_id_matches_def_id (n_AST) ))
11193
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" end_id_matches_def_id (n_AST) ");
11194 id_opt_AST = (currentAST.
root);
11195
break;
11196 }
11197
case SEMI:
11198 {
11199
if ( inputState->guessing==0 ) {
11200
#line 1148 "ada.g"
11201
pop_def_id();
11202
#line 11203 "AdaParser.cpp"
11203
}
11204 id_opt_AST = (currentAST.
root);
11205
break;
11206 }
11207
default:
11208 {
11209
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11210 }
11211 }
11212 }
11213
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11214
if( inputState->guessing == 0 ) {
11215
reportError(ex);
11216 consume();
11217 consumeUntil(
_tokenSet_4);
11218 }
else {
11219
throw;
11220 }
11221 }
11222
returnAST = id_opt_AST;
11223 }
11224
11225 void AdaParser::call_or_assignment() {
11226
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11227
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11228
RefAdaAST call_or_assignment_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11229
11230
try {
11231
name();
11232
if (inputState->guessing==0) {
11233 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11234 }
11235 {
11236
switch ( LA(1)) {
11237
case ASSIGN:
11238 {
11239 match(ASSIGN);
11240
expression();
11241
if (inputState->guessing==0) {
11242 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11243 }
11244
if ( inputState->guessing==0 ) {
11245 call_or_assignment_AST =
RefAdaAST(currentAST.
root);
11246
#line 1197 "ada.g"
11247
call_or_assignment_AST =
11248
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ASSIGNMENT_STATEMENT,
"ASSIGNMENT_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(call_or_assignment_AST.get()))));
11249
#line 11250 "AdaParser.cpp"
11250
currentAST.
root = call_or_assignment_AST;
11251
if ( call_or_assignment_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11252 call_or_assignment_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11253 currentAST.
child = call_or_assignment_AST->getFirstChild();
11254
else
11255 currentAST.
child = call_or_assignment_AST;
11256 currentAST.
advanceChildToEnd();
11257 }
11258
break;
11259 }
11260
case SEMI:
11261 {
11262
if ( inputState->guessing==0 ) {
11263 call_or_assignment_AST =
RefAdaAST(currentAST.
root);
11264
#line 1200 "ada.g"
11265
call_or_assignment_AST =
11266
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CALL_STATEMENT,
"CALL_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(call_or_assignment_AST.get()))));
11267
#line 11268 "AdaParser.cpp"
11268
currentAST.
root = call_or_assignment_AST;
11269
if ( call_or_assignment_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11270 call_or_assignment_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11271 currentAST.
child = call_or_assignment_AST->getFirstChild();
11272
else
11273 currentAST.
child = call_or_assignment_AST;
11274 currentAST.
advanceChildToEnd();
11275 }
11276
break;
11277 }
11278
default:
11279 {
11280
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11281 }
11282 }
11283 }
11284 match(SEMI);
11285 call_or_assignment_AST = (currentAST.
root);
11286 }
11287
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11288
if( inputState->guessing == 0 ) {
11289
reportError(ex);
11290 consume();
11291 consumeUntil(
_tokenSet_89);
11292 }
else {
11293
throw;
11294 }
11295 }
11296
returnAST = call_or_assignment_AST;
11297 }
11298
11299 void AdaParser::cond_clause() {
11300
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11301
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11302
RefAdaAST cond_clause_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11303
ANTLR_USE_NAMESPACE(antlr)
RefToken c =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
11304
RefAdaAST c_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11305
11306
try {
11307
condition();
11308
if (inputState->guessing==0) {
11309 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11310 }
11311 c = LT(1);
11312
if ( inputState->guessing == 0 ) {
11313 c_AST = astFactory->create(c);
11314 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get()));
11315 }
11316 match(THEN);
11317
statements();
11318
if (inputState->guessing==0) {
11319 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11320 }
11321
if ( inputState->guessing==0 ) {
11322
#line 1098 "ada.g"
11323
Set(c_AST, COND_CLAUSE);
11324
#line 11325 "AdaParser.cpp"
11325
}
11326 cond_clause_AST = (currentAST.
root);
11327 }
11328
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11329
if( inputState->guessing == 0 ) {
11330
reportError(ex);
11331 consume();
11332 consumeUntil(
_tokenSet_97);
11333 }
else {
11334
throw;
11335 }
11336 }
11337
returnAST = cond_clause_AST;
11338 }
11339
11340 void AdaParser::elsifs_opt() {
11341
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11342
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11343
RefAdaAST elsifs_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11344
11345
try {
11346 {
11347
for (;;) {
11348
if ((LA(1) == ELSIF)) {
11349 match(ELSIF);
11350
cond_clause();
11351
if (inputState->guessing==0) {
11352 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11353 }
11354 }
11355
else {
11356
goto _loop350;
11357 }
11358
11359 }
11360 _loop350:;
11361 }
11362
if ( inputState->guessing==0 ) {
11363 elsifs_opt_AST =
RefAdaAST(currentAST.
root);
11364
#line 1106 "ada.g"
11365
elsifs_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELSIFS_OPT,
"ELSIFS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(elsifs_opt_AST.get()))));
11366
#line 11367 "AdaParser.cpp"
11367
currentAST.
root = elsifs_opt_AST;
11368
if ( elsifs_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11369 elsifs_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11370 currentAST.
child = elsifs_opt_AST->getFirstChild();
11371
else
11372 currentAST.
child = elsifs_opt_AST;
11373 currentAST.
advanceChildToEnd();
11374 }
11375 elsifs_opt_AST = (currentAST.
root);
11376 }
11377
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11378
if( inputState->guessing == 0 ) {
11379
reportError(ex);
11380 consume();
11381 consumeUntil(
_tokenSet_98);
11382 }
else {
11383
throw;
11384 }
11385 }
11386
returnAST = elsifs_opt_AST;
11387 }
11388
11389 void AdaParser::else_opt() {
11390
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11391
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11392
RefAdaAST else_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11393
11394
try {
11395 {
11396
switch ( LA(1)) {
11397
case ELSE:
11398 {
11399 match(ELSE);
11400
statements();
11401
if (inputState->guessing==0) {
11402 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11403 }
11404
break;
11405 }
11406
case END:
11407 {
11408
break;
11409 }
11410
default:
11411 {
11412
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11413 }
11414 }
11415 }
11416
if ( inputState->guessing==0 ) {
11417 else_opt_AST =
RefAdaAST(currentAST.
root);
11418
#line 1110 "ada.g"
11419
else_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELSE_OPT,
"ELSE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(else_opt_AST.get()))));
11420
#line 11421 "AdaParser.cpp"
11421
currentAST.
root = else_opt_AST;
11422
if ( else_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11423 else_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11424 currentAST.
child = else_opt_AST->getFirstChild();
11425
else
11426 currentAST.
child = else_opt_AST;
11427 currentAST.
advanceChildToEnd();
11428 }
11429 else_opt_AST = (currentAST.
root);
11430 }
11431
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11432
if( inputState->guessing == 0 ) {
11433
reportError(ex);
11434 consume();
11435 consumeUntil(
_tokenSet_21);
11436 }
else {
11437
throw;
11438 }
11439 }
11440
returnAST = else_opt_AST;
11441 }
11442
11443 void AdaParser::condition() {
11444
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11445
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11446
RefAdaAST condition_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11447
11448
try {
11449
expression();
11450
if (inputState->guessing==0) {
11451 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11452 }
11453 condition_AST = (currentAST.
root);
11454 }
11455
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11456
if( inputState->guessing == 0 ) {
11457
reportError(ex);
11458 consume();
11459 consumeUntil(
_tokenSet_99);
11460 }
else {
11461
throw;
11462 }
11463 }
11464
returnAST = condition_AST;
11465 }
11466
11467 void AdaParser::alternative_s() {
11468
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11469
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11470
RefAdaAST alternative_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11471
11472
try {
11473 {
11474
int _cnt356=0;
11475
for (;;) {
11476
if ((LA(1) == WHEN)) {
11477
case_statement_alternative();
11478
if (inputState->guessing==0) {
11479 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11480 }
11481 }
11482
else {
11483
if ( _cnt356>=1 ) {
goto _loop356; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());}
11484 }
11485
11486 _cnt356++;
11487 }
11488 _loop356:;
11489 }
11490 alternative_s_AST = (currentAST.
root);
11491 }
11492
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11493
if( inputState->guessing == 0 ) {
11494
reportError(ex);
11495 consume();
11496 consumeUntil(
_tokenSet_21);
11497 }
else {
11498
throw;
11499 }
11500 }
11501
returnAST = alternative_s_AST;
11502 }
11503
11504 void AdaParser::case_statement_alternative() {
11505
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11506
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11507
RefAdaAST case_statement_alternative_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11508
ANTLR_USE_NAMESPACE(antlr)
RefToken s =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
11509
RefAdaAST s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11510
11511
try {
11512 s = LT(1);
11513
if ( inputState->guessing == 0 ) {
11514 s_AST = astFactory->create(s);
11515 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
11516 }
11517 match(WHEN);
11518
choice_s();
11519
if (inputState->guessing==0) {
11520 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11521 }
11522 match(RIGHT_SHAFT);
11523
statements();
11524
if (inputState->guessing==0) {
11525 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11526 }
11527
if ( inputState->guessing==0 ) {
11528
#line 1121 "ada.g"
11529
Set(s_AST, CASE_STATEMENT_ALTERNATIVE);
11530
#line 11531 "AdaParser.cpp"
11531
}
11532 case_statement_alternative_AST = (currentAST.
root);
11533 }
11534
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11535
if( inputState->guessing == 0 ) {
11536
reportError(ex);
11537 consume();
11538 consumeUntil(
_tokenSet_72);
11539 }
else {
11540
throw;
11541 }
11542 }
11543
returnAST = case_statement_alternative_AST;
11544 }
11545
11546 void AdaParser::iteration_scheme_opt() {
11547
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11548
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11549
RefAdaAST iteration_scheme_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11550
11551
try {
11552 {
11553
switch ( LA(1)) {
11554
case WHILE:
11555 {
11556
RefAdaAST tmp319_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11557
if ( inputState->guessing == 0 ) {
11558 tmp319_AST = astFactory->create(LT(1));
11559 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp319_AST.get()));
11560 }
11561 match(WHILE);
11562
condition();
11563
if (inputState->guessing==0) {
11564 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11565 }
11566
break;
11567 }
11568
case FOR:
11569 {
11570
RefAdaAST tmp320_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11571
if ( inputState->guessing == 0 ) {
11572 tmp320_AST = astFactory->create(LT(1));
11573 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp320_AST.get()));
11574 }
11575 match(FOR);
11576
RefAdaAST tmp321_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11577
if ( inputState->guessing == 0 ) {
11578 tmp321_AST = astFactory->create(LT(1));
11579 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp321_AST.get()));
11580 }
11581 match(IDENTIFIER);
11582 match(IN);
11583
reverse_opt();
11584
if (inputState->guessing==0) {
11585 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11586 }
11587
discrete_subtype_definition();
11588
if (inputState->guessing==0) {
11589 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11590 }
11591
break;
11592 }
11593
case LOOP:
11594 {
11595
break;
11596 }
11597
default:
11598 {
11599
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11600 }
11601 }
11602 }
11603
if ( inputState->guessing==0 ) {
11604 iteration_scheme_opt_AST =
RefAdaAST(currentAST.
root);
11605
#line 1132 "ada.g"
11606
iteration_scheme_opt_AST =
11607
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ITERATION_SCHEME_OPT,
"ITERATION_SCHEME_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(iteration_scheme_opt_AST.get()))));
11608
#line 11609 "AdaParser.cpp"
11609
currentAST.
root = iteration_scheme_opt_AST;
11610
if ( iteration_scheme_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11611 iteration_scheme_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11612 currentAST.
child = iteration_scheme_opt_AST->getFirstChild();
11613
else
11614 currentAST.
child = iteration_scheme_opt_AST;
11615 currentAST.
advanceChildToEnd();
11616 }
11617 iteration_scheme_opt_AST = (currentAST.
root);
11618 }
11619
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11620
if( inputState->guessing == 0 ) {
11621
reportError(ex);
11622 consume();
11623 consumeUntil(
_tokenSet_100);
11624 }
else {
11625
throw;
11626 }
11627 }
11628
returnAST = iteration_scheme_opt_AST;
11629 }
11630
11631 void AdaParser::reverse_opt() {
11632
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11633
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11634
RefAdaAST reverse_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11635
11636
try {
11637 {
11638
switch ( LA(1)) {
11639
case REVERSE:
11640 {
11641
RefAdaAST tmp323_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11642
if ( inputState->guessing == 0 ) {
11643 tmp323_AST = astFactory->create(LT(1));
11644 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp323_AST.get()));
11645 }
11646 match(REVERSE);
11647
break;
11648 }
11649
case IDENTIFIER:
11650
case LPAREN:
11651
case NEW:
11652
case CHARACTER_LITERAL:
11653
case CHAR_STRING:
11654
case NuLL:
11655
case NOT:
11656
case PLUS:
11657
case MINUS:
11658
case ABS:
11659
case NUMERIC_LIT:
11660 {
11661
break;
11662 }
11663
default:
11664 {
11665
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11666 }
11667 }
11668 }
11669
if ( inputState->guessing==0 ) {
11670 reverse_opt_AST =
RefAdaAST(currentAST.
root);
11671
#line 1138 "ada.g"
11672
reverse_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(reverse_opt_AST.get()))));
11673
#line 11674 "AdaParser.cpp"
11674
currentAST.
root = reverse_opt_AST;
11675
if ( reverse_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11676 reverse_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11677 currentAST.
child = reverse_opt_AST->getFirstChild();
11678
else
11679 currentAST.
child = reverse_opt_AST;
11680 currentAST.
advanceChildToEnd();
11681 }
11682 reverse_opt_AST = (currentAST.
root);
11683 }
11684
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11685
if( inputState->guessing == 0 ) {
11686
reportError(ex);
11687 consume();
11688 consumeUntil(
_tokenSet_5);
11689 }
else {
11690
throw;
11691 }
11692 }
11693
returnAST = reverse_opt_AST;
11694 }
11695
11696 void AdaParser::declare_opt() {
11697
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11698
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11699
RefAdaAST declare_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11700
11701
try {
11702 {
11703
switch ( LA(1)) {
11704
case DECLARE:
11705 {
11706 match(DECLARE);
11707
declarative_part();
11708
if (inputState->guessing==0) {
11709 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11710 }
11711
break;
11712 }
11713
case BEGIN:
11714 {
11715
break;
11716 }
11717
default:
11718 {
11719
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11720 }
11721 }
11722 }
11723
if ( inputState->guessing==0 ) {
11724 declare_opt_AST =
RefAdaAST(currentAST.
root);
11725
#line 1177 "ada.g"
11726
declare_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DECLARE_OPT,
"DECLARE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(declare_opt_AST.get()))));
11727
#line 11728 "AdaParser.cpp"
11728
currentAST.
root = declare_opt_AST;
11729
if ( declare_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11730 declare_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11731 currentAST.
child = declare_opt_AST->getFirstChild();
11732
else
11733 currentAST.
child = declare_opt_AST;
11734 currentAST.
advanceChildToEnd();
11735 }
11736 declare_opt_AST = (currentAST.
root);
11737 }
11738
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11739
if( inputState->guessing == 0 ) {
11740
reportError(ex);
11741 consume();
11742 consumeUntil(
_tokenSet_101);
11743 }
else {
11744
throw;
11745 }
11746 }
11747
returnAST = declare_opt_AST;
11748 }
11749
11750 void AdaParser::label_name() {
11751
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11752
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11753
RefAdaAST label_name_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11754
11755
try {
11756
RefAdaAST tmp325_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11757
if ( inputState->guessing == 0 ) {
11758 tmp325_AST = astFactory->create(LT(1));
11759 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp325_AST.get()));
11760 }
11761 match(IDENTIFIER);
11762 label_name_AST = (currentAST.
root);
11763 }
11764
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11765
if( inputState->guessing == 0 ) {
11766
reportError(ex);
11767 consume();
11768 consumeUntil(
_tokenSet_102);
11769 }
else {
11770
throw;
11771 }
11772 }
11773
returnAST = label_name_AST;
11774 }
11775
11776 void AdaParser::entry_body_formal_part() {
11777
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11778
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11779
RefAdaAST entry_body_formal_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11780
11781
try {
11782
entry_index_spec_opt();
11783
if (inputState->guessing==0) {
11784 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11785 }
11786
formal_part_opt();
11787
if (inputState->guessing==0) {
11788 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11789 }
11790 entry_body_formal_part_AST = (currentAST.
root);
11791 }
11792
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11793
if( inputState->guessing == 0 ) {
11794
reportError(ex);
11795 consume();
11796 consumeUntil(
_tokenSet_103);
11797 }
else {
11798
throw;
11799 }
11800 }
11801
returnAST = entry_body_formal_part_AST;
11802 }
11803
11804 void AdaParser::entry_barrier() {
11805
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11806
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11807
RefAdaAST entry_barrier_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11808
11809
try {
11810 match(WHEN);
11811
condition();
11812
if (inputState->guessing==0) {
11813 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11814 }
11815 entry_barrier_AST = (currentAST.
root);
11816 }
11817
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11818
if( inputState->guessing == 0 ) {
11819
reportError(ex);
11820 consume();
11821 consumeUntil(
_tokenSet_75);
11822 }
else {
11823
throw;
11824 }
11825 }
11826
returnAST = entry_barrier_AST;
11827 }
11828
11829 void AdaParser::entry_index_spec_opt() {
11830
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11831
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11832
RefAdaAST entry_index_spec_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11833
11834
try {
11835 {
11836
bool synPredMatched383 =
false;
11837
if (((LA(1) == LPAREN) && (LA(2) == FOR))) {
11838
int _m383 = mark();
11839 synPredMatched383 =
true;
11840 inputState->guessing++;
11841
try {
11842 {
11843 match(LPAREN);
11844 match(FOR);
11845 }
11846 }
11847
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
11848 synPredMatched383 =
false;
11849 }
11850 rewind(_m383);
11851 inputState->guessing--;
11852 }
11853
if ( synPredMatched383 ) {
11854 match(LPAREN);
11855 match(FOR);
11856
def_id(
false);
11857
if (inputState->guessing==0) {
11858 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11859 }
11860 match(IN);
11861
discrete_subtype_definition();
11862
if (inputState->guessing==0) {
11863 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11864 }
11865 match(RPAREN);
11866 }
11867
else if ((LA(1) == LPAREN || LA(1) == WHEN) && (
_tokenSet_5.member(LA(2)))) {
11868 }
11869
else {
11870
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11871 }
11872
11873 }
11874
if ( inputState->guessing==0 ) {
11875 entry_index_spec_opt_AST =
RefAdaAST(currentAST.
root);
11876
#line 1222 "ada.g"
11877
entry_index_spec_opt_AST =
11878
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_INDEX_SPECIFICATION,
"ENTRY_INDEX_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_index_spec_opt_AST.get()))));
11879
#line 11880 "AdaParser.cpp"
11880
currentAST.
root = entry_index_spec_opt_AST;
11881
if ( entry_index_spec_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11882 entry_index_spec_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11883 currentAST.
child = entry_index_spec_opt_AST->getFirstChild();
11884
else
11885 currentAST.
child = entry_index_spec_opt_AST;
11886 currentAST.
advanceChildToEnd();
11887 }
11888 entry_index_spec_opt_AST = (currentAST.
root);
11889 }
11890
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11891
if( inputState->guessing == 0 ) {
11892
reportError(ex);
11893 consume();
11894 consumeUntil(
_tokenSet_104);
11895 }
else {
11896
throw;
11897 }
11898 }
11899
returnAST = entry_index_spec_opt_AST;
11900 }
11901
11902 void AdaParser::entry_call_stmt() {
11903
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11904
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11905
RefAdaAST entry_call_stmt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11906
11907
try {
11908
name();
11909
if (inputState->guessing==0) {
11910 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11911 }
11912 match(SEMI);
11913
if ( inputState->guessing==0 ) {
11914 entry_call_stmt_AST =
RefAdaAST(currentAST.
root);
11915
#line 1232 "ada.g"
11916
entry_call_stmt_AST =
11917
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_CALL_STATEMENT,
"ENTRY_CALL_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_call_stmt_AST.get()))));
11918
#line 11919 "AdaParser.cpp"
11919
currentAST.
root = entry_call_stmt_AST;
11920
if ( entry_call_stmt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11921 entry_call_stmt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11922 currentAST.
child = entry_call_stmt_AST->getFirstChild();
11923
else
11924 currentAST.
child = entry_call_stmt_AST;
11925 currentAST.
advanceChildToEnd();
11926 }
11927 entry_call_stmt_AST = (currentAST.
root);
11928 }
11929
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11930
if( inputState->guessing == 0 ) {
11931
reportError(ex);
11932 consume();
11933 consumeUntil(
_tokenSet_105);
11934 }
else {
11935
throw;
11936 }
11937 }
11938
returnAST = entry_call_stmt_AST;
11939 }
11940
11941 void AdaParser::entry_index_opt() {
11942
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11943
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
11944
RefAdaAST entry_index_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
11945
11946
try {
11947 {
11948
bool synPredMatched391 =
false;
11949
if (((LA(1) == LPAREN) && (
_tokenSet_5.member(LA(2))))) {
11950
int _m391 = mark();
11951 synPredMatched391 =
true;
11952 inputState->guessing++;
11953
try {
11954 {
11955 match(LPAREN);
11956
expression();
11957 match(RPAREN);
11958 }
11959 }
11960
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
11961 synPredMatched391 =
false;
11962 }
11963 rewind(_m391);
11964 inputState->guessing--;
11965 }
11966
if ( synPredMatched391 ) {
11967 match(LPAREN);
11968
expression();
11969
if (inputState->guessing==0) {
11970 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
11971 }
11972 match(RPAREN);
11973 }
11974
else if ((LA(1) == SEMI || LA(1) == LPAREN || LA(1) == DO) && (
_tokenSet_89.member(LA(2)))) {
11975 }
11976
else {
11977
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
11978 }
11979
11980 }
11981
if ( inputState->guessing==0 ) {
11982 entry_index_opt_AST =
RefAdaAST(currentAST.
root);
11983
#line 1251 "ada.g"
11984
entry_index_opt_AST =
11985
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_INDEX_OPT,
"ENTRY_INDEX_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_index_opt_AST.get()))));
11986
#line 11987 "AdaParser.cpp"
11987
currentAST.
root = entry_index_opt_AST;
11988
if ( entry_index_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
11989 entry_index_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
11990 currentAST.
child = entry_index_opt_AST->getFirstChild();
11991
else
11992 currentAST.
child = entry_index_opt_AST;
11993 currentAST.
advanceChildToEnd();
11994 }
11995 entry_index_opt_AST = (currentAST.
root);
11996 }
11997
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
11998
if( inputState->guessing == 0 ) {
11999
reportError(ex);
12000 consume();
12001 consumeUntil(
_tokenSet_106);
12002 }
else {
12003
throw;
12004 }
12005 }
12006
returnAST = entry_index_opt_AST;
12007 }
12008
12009 void AdaParser::until_opt() {
12010
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12011
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12012
RefAdaAST until_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12013
12014
try {
12015 {
12016
switch ( LA(1)) {
12017
case UNTIL:
12018 {
12019
RefAdaAST tmp334_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12020
if ( inputState->guessing == 0 ) {
12021 tmp334_AST = astFactory->create(LT(1));
12022 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp334_AST.get()));
12023 }
12024 match(UNTIL);
12025
break;
12026 }
12027
case IDENTIFIER:
12028
case LPAREN:
12029
case NEW:
12030
case CHARACTER_LITERAL:
12031
case CHAR_STRING:
12032
case NuLL:
12033
case NOT:
12034
case PLUS:
12035
case MINUS:
12036
case ABS:
12037
case NUMERIC_LIT:
12038 {
12039
break;
12040 }
12041
default:
12042 {
12043
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12044 }
12045 }
12046 }
12047
if ( inputState->guessing==0 ) {
12048 until_opt_AST =
RefAdaAST(currentAST.
root);
12049
#line 1261 "ada.g"
12050
until_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,
"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(until_opt_AST.get()))));
12051
#line 12052 "AdaParser.cpp"
12052
currentAST.
root = until_opt_AST;
12053
if ( until_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12054 until_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12055 currentAST.
child = until_opt_AST->getFirstChild();
12056
else
12057 currentAST.
child = until_opt_AST;
12058 currentAST.
advanceChildToEnd();
12059 }
12060 until_opt_AST = (currentAST.
root);
12061 }
12062
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12063
if( inputState->guessing == 0 ) {
12064
reportError(ex);
12065 consume();
12066 consumeUntil(
_tokenSet_5);
12067 }
else {
12068
throw;
12069 }
12070 }
12071
returnAST = until_opt_AST;
12072 }
12073
12074 void AdaParser::triggering_alternative() {
12075
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12076
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12077
RefAdaAST triggering_alternative_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12078
12079
try {
12080 {
12081
switch ( LA(1)) {
12082
case DELAY:
12083 {
12084
delay_stmt();
12085
if (inputState->guessing==0) {
12086 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12087 }
12088
break;
12089 }
12090
case IDENTIFIER:
12091 {
12092
entry_call_stmt();
12093
if (inputState->guessing==0) {
12094 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12095 }
12096
break;
12097 }
12098
default:
12099 {
12100
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12101 }
12102 }
12103 }
12104
stmts_opt();
12105
if (inputState->guessing==0) {
12106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12107 }
12108
if ( inputState->guessing==0 ) {
12109 triggering_alternative_AST =
RefAdaAST(currentAST.
root);
12110
#line 1285 "ada.g"
12111
triggering_alternative_AST =
12112
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TRIGGERING_ALTERNATIVE,
"TRIGGERING_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(triggering_alternative_AST.get()))));
12113
#line 12114 "AdaParser.cpp"
12114
currentAST.
root = triggering_alternative_AST;
12115
if ( triggering_alternative_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12116 triggering_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12117 currentAST.
child = triggering_alternative_AST->getFirstChild();
12118
else
12119 currentAST.
child = triggering_alternative_AST;
12120 currentAST.
advanceChildToEnd();
12121 }
12122 triggering_alternative_AST = (currentAST.
root);
12123 }
12124
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12125
if( inputState->guessing == 0 ) {
12126
reportError(ex);
12127 consume();
12128 consumeUntil(
_tokenSet_107);
12129 }
else {
12130
throw;
12131 }
12132 }
12133
returnAST = triggering_alternative_AST;
12134 }
12135
12136 void AdaParser::abortable_part() {
12137
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12138
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12139
RefAdaAST abortable_part_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12140
12141
try {
12142
stmts_opt();
12143
if (inputState->guessing==0) {
12144 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12145 }
12146
if ( inputState->guessing==0 ) {
12147 abortable_part_AST =
RefAdaAST(currentAST.
root);
12148
#line 1291 "ada.g"
12149
abortable_part_AST =
12150
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ABORTABLE_PART,
"ABORTABLE_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abortable_part_AST.get()))));
12151
#line 12152 "AdaParser.cpp"
12152
currentAST.
root = abortable_part_AST;
12153
if ( abortable_part_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12154 abortable_part_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12155 currentAST.
child = abortable_part_AST->getFirstChild();
12156
else
12157 currentAST.
child = abortable_part_AST;
12158 currentAST.
advanceChildToEnd();
12159 }
12160 abortable_part_AST = (currentAST.
root);
12161 }
12162
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12163
if( inputState->guessing == 0 ) {
12164
reportError(ex);
12165 consume();
12166 consumeUntil(
_tokenSet_21);
12167 }
else {
12168
throw;
12169 }
12170 }
12171
returnAST = abortable_part_AST;
12172 }
12173
12174 void AdaParser::selective_accept() {
12175
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12176
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12177
RefAdaAST selective_accept_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12178
12179
try {
12180
guard_opt();
12181
if (inputState->guessing==0) {
12182 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12183 }
12184
select_alternative();
12185
if (inputState->guessing==0) {
12186 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12187 }
12188
or_select_opt();
12189
if (inputState->guessing==0) {
12190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12191 }
12192
else_opt();
12193
if (inputState->guessing==0) {
12194 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12195 }
12196 selective_accept_AST = (currentAST.
root);
12197 }
12198
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12199
if( inputState->guessing == 0 ) {
12200
reportError(ex);
12201 consume();
12202 consumeUntil(
_tokenSet_21);
12203 }
else {
12204
throw;
12205 }
12206 }
12207
returnAST = selective_accept_AST;
12208 }
12209
12210 void AdaParser::entry_call_alternative() {
12211
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12212
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12213
RefAdaAST entry_call_alternative_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12214
12215
try {
12216
entry_call_stmt();
12217
if (inputState->guessing==0) {
12218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12219 }
12220
stmts_opt();
12221
if (inputState->guessing==0) {
12222 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12223 }
12224
if ( inputState->guessing==0 ) {
12225 entry_call_alternative_AST =
RefAdaAST(currentAST.
root);
12226
#line 1297 "ada.g"
12227
entry_call_alternative_AST =
12228
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_CALL_ALTERNATIVE,
"ENTRY_CALL_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_call_alternative_AST.get()))));
12229
#line 12230 "AdaParser.cpp"
12230
currentAST.
root = entry_call_alternative_AST;
12231
if ( entry_call_alternative_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12232 entry_call_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12233 currentAST.
child = entry_call_alternative_AST->getFirstChild();
12234
else
12235 currentAST.
child = entry_call_alternative_AST;
12236 currentAST.
advanceChildToEnd();
12237 }
12238 entry_call_alternative_AST = (currentAST.
root);
12239 }
12240
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12241
if( inputState->guessing == 0 ) {
12242
reportError(ex);
12243 consume();
12244 consumeUntil(
_tokenSet_108);
12245 }
else {
12246
throw;
12247 }
12248 }
12249
returnAST = entry_call_alternative_AST;
12250 }
12251
12252 void AdaParser::delay_alternative() {
12253
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12254
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12255
RefAdaAST delay_alternative_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12256
12257
try {
12258
delay_stmt();
12259
if (inputState->guessing==0) {
12260 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12261 }
12262
stmts_opt();
12263
if (inputState->guessing==0) {
12264 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12265 }
12266
if ( inputState->guessing==0 ) {
12267 delay_alternative_AST =
RefAdaAST(currentAST.
root);
12268
#line 1322 "ada.g"
12269
delay_alternative_AST =
12270
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DELAY_ALTERNATIVE,
"DELAY_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(delay_alternative_AST.get()))));
12271
#line 12272 "AdaParser.cpp"
12272
currentAST.
root = delay_alternative_AST;
12273
if ( delay_alternative_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12274 delay_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12275 currentAST.
child = delay_alternative_AST->getFirstChild();
12276
else
12277 currentAST.
child = delay_alternative_AST;
12278 currentAST.
advanceChildToEnd();
12279 }
12280 delay_alternative_AST = (currentAST.
root);
12281 }
12282
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12283
if( inputState->guessing == 0 ) {
12284
reportError(ex);
12285 consume();
12286 consumeUntil(
_tokenSet_109);
12287 }
else {
12288
throw;
12289 }
12290 }
12291
returnAST = delay_alternative_AST;
12292 }
12293
12294 void AdaParser::stmts_opt() {
12295
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12296
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12297
RefAdaAST stmts_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12298
12299
try {
12300 {
12301
for (;;) {
12302
switch ( LA(1)) {
12303
case PRAGMA:
12304 {
12305
pragma();
12306
if (inputState->guessing==0) {
12307 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12308 }
12309
break;
12310 }
12311
case IDENTIFIER:
12312
case NuLL:
12313
case RETURN:
12314
case FOR:
12315
case CASE:
12316
case BEGIN:
12317
case LT_LT:
12318
case IF:
12319
case LOOP:
12320
case WHILE:
12321
case DECLARE:
12322
case EXIT:
12323
case GOTO:
12324
case ACCEPT:
12325
case DELAY:
12326
case SELECT:
12327
case ABORT:
12328
case RAISE:
12329
case REQUEUE:
12330 {
12331
statement();
12332
if (inputState->guessing==0) {
12333 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12334 }
12335
break;
12336 }
12337
default:
12338 {
12339
goto _loop414;
12340 }
12341 }
12342 }
12343 _loop414:;
12344 }
12345 stmts_opt_AST = (currentAST.
root);
12346 }
12347
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12348
if( inputState->guessing == 0 ) {
12349
reportError(ex);
12350 consume();
12351 consumeUntil(
_tokenSet_110);
12352 }
else {
12353
throw;
12354 }
12355 }
12356
returnAST = stmts_opt_AST;
12357 }
12358
12359 void AdaParser::guard_opt() {
12360
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12361
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12362
RefAdaAST guard_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12363
12364
try {
12365 {
12366
switch ( LA(1)) {
12367
case WHEN:
12368 {
12369 match(WHEN);
12370
condition();
12371
if (inputState->guessing==0) {
12372 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12373 }
12374 match(RIGHT_SHAFT);
12375 {
12376
for (;;) {
12377
if ((LA(1) == PRAGMA)) {
12378
pragma();
12379
if (inputState->guessing==0) {
12380 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12381 }
12382 }
12383
else {
12384
goto _loop408;
12385 }
12386
12387 }
12388 _loop408:;
12389 }
12390
break;
12391 }
12392
case ACCEPT:
12393
case DELAY:
12394
case TERMINATE:
12395 {
12396
break;
12397 }
12398
default:
12399 {
12400
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12401 }
12402 }
12403 }
12404
if ( inputState->guessing==0 ) {
12405 guard_opt_AST =
RefAdaAST(currentAST.
root);
12406
#line 1306 "ada.g"
12407
guard_opt_AST =
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(GUARD_OPT,
"GUARD_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(guard_opt_AST.get()))));
12408
#line 12409 "AdaParser.cpp"
12409
currentAST.
root = guard_opt_AST;
12410
if ( guard_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12411 guard_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12412 currentAST.
child = guard_opt_AST->getFirstChild();
12413
else
12414 currentAST.
child = guard_opt_AST;
12415 currentAST.
advanceChildToEnd();
12416 }
12417 guard_opt_AST = (currentAST.
root);
12418 }
12419
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12420
if( inputState->guessing == 0 ) {
12421
reportError(ex);
12422 consume();
12423 consumeUntil(
_tokenSet_111);
12424 }
else {
12425
throw;
12426 }
12427 }
12428
returnAST = guard_opt_AST;
12429 }
12430
12431 void AdaParser::select_alternative() {
12432
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12433
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12434
RefAdaAST select_alternative_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12435
ANTLR_USE_NAMESPACE(antlr)
RefToken t =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
12436
RefAdaAST t_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12437
12438
try {
12439
switch ( LA(1)) {
12440
case ACCEPT:
12441 {
12442
accept_alternative();
12443
if (inputState->guessing==0) {
12444 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12445 }
12446 select_alternative_AST = (currentAST.
root);
12447
break;
12448 }
12449
case DELAY:
12450 {
12451
delay_alternative();
12452
if (inputState->guessing==0) {
12453 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12454 }
12455 select_alternative_AST = (currentAST.
root);
12456
break;
12457 }
12458
case TERMINATE:
12459 {
12460 t = LT(1);
12461
if ( inputState->guessing == 0 ) {
12462 t_AST = astFactory->create(t);
12463 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
12464 }
12465 match(TERMINATE);
12466 match(SEMI);
12467
if ( inputState->guessing==0 ) {
12468
#line 1312 "ada.g"
12469
Set(t_AST, TERMINATE_ALTERNATIVE);
12470
#line 12471 "AdaParser.cpp"
12471
}
12472 select_alternative_AST = (currentAST.
root);
12473
break;
12474 }
12475
default:
12476 {
12477
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12478 }
12479 }
12480 }
12481
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12482
if( inputState->guessing == 0 ) {
12483
reportError(ex);
12484 consume();
12485 consumeUntil(
_tokenSet_109);
12486 }
else {
12487
throw;
12488 }
12489 }
12490
returnAST = select_alternative_AST;
12491 }
12492
12493 void AdaParser::or_select_opt() {
12494
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12495
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12496
RefAdaAST or_select_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12497
12498
try {
12499 {
12500
for (;;) {
12501
if ((LA(1) == OR)) {
12502 match(OR);
12503
guard_opt();
12504
if (inputState->guessing==0) {
12505 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12506 }
12507
select_alternative();
12508
if (inputState->guessing==0) {
12509 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12510 }
12511 }
12512
else {
12513
goto _loop417;
12514 }
12515
12516 }
12517 _loop417:;
12518 }
12519
if ( inputState->guessing==0 ) {
12520 or_select_opt_AST =
RefAdaAST(currentAST.
root);
12521
#line 1331 "ada.g"
12522
or_select_opt_AST =
12523
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(OR_SELECT_OPT,
"OR_SELECT_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(or_select_opt_AST.get()))));
12524
#line 12525 "AdaParser.cpp"
12525
currentAST.
root = or_select_opt_AST;
12526
if ( or_select_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12527 or_select_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12528 currentAST.
child = or_select_opt_AST->getFirstChild();
12529
else
12530 currentAST.
child = or_select_opt_AST;
12531 currentAST.
advanceChildToEnd();
12532 }
12533 or_select_opt_AST = (currentAST.
root);
12534 }
12535
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12536
if( inputState->guessing == 0 ) {
12537
reportError(ex);
12538 consume();
12539 consumeUntil(
_tokenSet_98);
12540 }
else {
12541
throw;
12542 }
12543 }
12544
returnAST = or_select_opt_AST;
12545 }
12546
12547 void AdaParser::accept_alternative() {
12548
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12549
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12550
RefAdaAST accept_alternative_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12551
12552
try {
12553
accept_stmt();
12554
if (inputState->guessing==0) {
12555 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12556 }
12557
stmts_opt();
12558
if (inputState->guessing==0) {
12559 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12560 }
12561
if ( inputState->guessing==0 ) {
12562 accept_alternative_AST =
RefAdaAST(currentAST.
root);
12563
#line 1316 "ada.g"
12564
accept_alternative_AST =
12565
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ACCEPT_ALTERNATIVE,
"ACCEPT_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(accept_alternative_AST.get()))));
12566
#line 12567 "AdaParser.cpp"
12567
currentAST.
root = accept_alternative_AST;
12568
if ( accept_alternative_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12569 accept_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12570 currentAST.
child = accept_alternative_AST->getFirstChild();
12571
else
12572 currentAST.
child = accept_alternative_AST;
12573 currentAST.
advanceChildToEnd();
12574 }
12575 accept_alternative_AST = (currentAST.
root);
12576 }
12577
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12578
if( inputState->guessing == 0 ) {
12579
reportError(ex);
12580 consume();
12581 consumeUntil(
_tokenSet_109);
12582 }
else {
12583
throw;
12584 }
12585 }
12586
returnAST = accept_alternative_AST;
12587 }
12588
12589 void AdaParser::exception_handler() {
12590
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12591
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12592
RefAdaAST exception_handler_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12593
ANTLR_USE_NAMESPACE(antlr)
RefToken w =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
12594
RefAdaAST w_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12595
12596
try {
12597 w = LT(1);
12598
if ( inputState->guessing == 0 ) {
12599 w_AST = astFactory->create(w);
12600 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
12601 }
12602 match(WHEN);
12603
identifier_colon_opt();
12604
if (inputState->guessing==0) {
12605 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12606 }
12607
except_choice_s();
12608
if (inputState->guessing==0) {
12609 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12610 }
12611 match(RIGHT_SHAFT);
12612
statements();
12613
if (inputState->guessing==0) {
12614 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12615 }
12616
if ( inputState->guessing==0 ) {
12617
#line 1347 "ada.g"
12618
Set (w_AST, EXCEPTION_HANDLER);
12619
#line 12620 "AdaParser.cpp"
12620
}
12621 exception_handler_AST = (currentAST.
root);
12622 }
12623
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12624
if( inputState->guessing == 0 ) {
12625
reportError(ex);
12626 consume();
12627 consumeUntil(
_tokenSet_72);
12628 }
else {
12629
throw;
12630 }
12631 }
12632
returnAST = exception_handler_AST;
12633 }
12634
12635 void AdaParser::identifier_colon_opt() {
12636
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12637
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12638
RefAdaAST identifier_colon_opt_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12639
12640
try {
12641 {
12642
if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
12643
RefAdaAST tmp340_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12644
if ( inputState->guessing == 0 ) {
12645 tmp340_AST = astFactory->create(LT(1));
12646 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp340_AST.get()));
12647 }
12648 match(IDENTIFIER);
12649 match(COLON);
12650 }
12651
else if ((LA(1) == IDENTIFIER || LA(1) == OTHERS) && (LA(2) == RIGHT_SHAFT || LA(2) == DOT || LA(2) == PIPE)) {
12652 }
12653
else {
12654
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12655 }
12656
12657 }
12658
if ( inputState->guessing==0 ) {
12659 identifier_colon_opt_AST =
RefAdaAST(currentAST.
root);
12660
#line 1351 "ada.g"
12661
identifier_colon_opt_AST =
12662
RefAdaAST(astFactory->make((
new ANTLR_USE_NAMESPACE(antlr)
ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(IDENTIFIER_COLON_OPT,
"IDENTIFIER_COLON_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(identifier_colon_opt_AST.get()))));
12663
#line 12664 "AdaParser.cpp"
12664
currentAST.
root = identifier_colon_opt_AST;
12665
if ( identifier_colon_opt_AST!=static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) &&
12666 identifier_colon_opt_AST->getFirstChild() != static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get()) )
12667 currentAST.
child = identifier_colon_opt_AST->getFirstChild();
12668
else
12669 currentAST.
child = identifier_colon_opt_AST;
12670 currentAST.
advanceChildToEnd();
12671 }
12672 identifier_colon_opt_AST = (currentAST.
root);
12673 }
12674
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12675
if( inputState->guessing == 0 ) {
12676
reportError(ex);
12677 consume();
12678 consumeUntil(
_tokenSet_112);
12679 }
else {
12680
throw;
12681 }
12682 }
12683
returnAST = identifier_colon_opt_AST;
12684 }
12685
12686 void AdaParser::except_choice_s() {
12687
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12688
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12689
RefAdaAST except_choice_s_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12690
12691
try {
12692
exception_choice();
12693
if (inputState->guessing==0) {
12694 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12695 }
12696 {
12697
for (;;) {
12698
if ((LA(1) == PIPE)) {
12699
RefAdaAST tmp342_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12700
if ( inputState->guessing == 0 ) {
12701 tmp342_AST = astFactory->create(LT(1));
12702 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp342_AST.get()));
12703 }
12704 match(PIPE);
12705
exception_choice();
12706
if (inputState->guessing==0) {
12707 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12708 }
12709 }
12710
else {
12711
goto _loop430;
12712 }
12713
12714 }
12715 _loop430:;
12716 }
12717 except_choice_s_AST = (currentAST.
root);
12718 }
12719
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12720
if( inputState->guessing == 0 ) {
12721
reportError(ex);
12722 consume();
12723 consumeUntil(
_tokenSet_76);
12724 }
else {
12725
throw;
12726 }
12727 }
12728
returnAST = except_choice_s_AST;
12729 }
12730
12731 void AdaParser::exception_choice() {
12732
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12733
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12734
RefAdaAST exception_choice_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12735
12736
try {
12737
switch ( LA(1)) {
12738
case IDENTIFIER:
12739 {
12740
compound_name();
12741
if (inputState->guessing==0) {
12742 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12743 }
12744 exception_choice_AST = (currentAST.
root);
12745
break;
12746 }
12747
case OTHERS:
12748 {
12749
RefAdaAST tmp343_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12750
if ( inputState->guessing == 0 ) {
12751 tmp343_AST = astFactory->create(LT(1));
12752 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp343_AST.get()));
12753 }
12754 match(OTHERS);
12755 exception_choice_AST = (currentAST.
root);
12756
break;
12757 }
12758
default:
12759 {
12760
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12761 }
12762 }
12763 }
12764
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12765
if( inputState->guessing == 0 ) {
12766
reportError(ex);
12767 consume();
12768 consumeUntil(
_tokenSet_68);
12769 }
else {
12770
throw;
12771 }
12772 }
12773
returnAST = exception_choice_AST;
12774 }
12775
12776 void AdaParser::operator_call() {
12777
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12778
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12779
RefAdaAST operator_call_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12780
ANTLR_USE_NAMESPACE(antlr)
RefToken cs =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
12781
RefAdaAST cs_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12782
12783
try {
12784 cs = LT(1);
12785
if ( inputState->guessing == 0 ) {
12786 cs_AST = astFactory->create(cs);
12787 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cs_AST.get()));
12788 }
12789 match(CHAR_STRING);
12790
operator_call_tail(cs_AST);
12791
if (inputState->guessing==0) {
12792 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12793 }
12794 operator_call_AST = /*static_cast<RefAdaAST>*/(currentAST.
root);
12795 }
12796
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12797
if( inputState->guessing == 0 ) {
12798
reportError(ex);
12799 consume();
12800 consumeUntil(
_tokenSet_0);
12801 }
else {
12802
throw;
12803 }
12804 }
12805
returnAST = operator_call_AST;
12806 }
12807
12808 void AdaParser::operator_call_tail(
12809 RefAdaAST opstr
12810 ) {
12811
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12812
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12813
RefAdaAST operator_call_tail_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12814
12815
try {
12816 match(LPAREN);
12817
if (!(
is_operator_symbol(opstr->getText().c_str()) ))
12818
throw ANTLR_USE_NAMESPACE(antlr)
SemanticException(
" is_operator_symbol(opstr->getText().c_str()) ");
12819
value_s();
12820
if (inputState->guessing==0) {
12821 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12822 }
12823 match(RPAREN);
12824
if ( inputState->guessing==0 ) {
12825
#line 1376 "ada.g"
12826
opstr->setType(OPERATOR_SYMBOL);
12827
#line 12828 "AdaParser.cpp"
12828
}
12829 operator_call_tail_AST = /*static_cast<RefAdaAST>*/(currentAST.
root);
12830 }
12831
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
12832
if( inputState->guessing == 0 ) {
12833
reportError(ex);
12834 consume();
12835 consumeUntil(
_tokenSet_113);
12836 }
else {
12837
throw;
12838 }
12839 }
12840
returnAST = operator_call_tail_AST;
12841 }
12842
12843 void AdaParser::relation() {
12844
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12845
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
12846
RefAdaAST relation_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12847
ANTLR_USE_NAMESPACE(antlr)
RefToken n =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
12848
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12849
12850
try {
12851
simple_expression();
12852
if (inputState->guessing==0) {
12853 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12854 }
12855 {
12856
switch ( LA(1)) {
12857
case IN:
12858 {
12859
RefAdaAST tmp346_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12860
if ( inputState->guessing == 0 ) {
12861 tmp346_AST = astFactory->create(LT(1));
12862 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp346_AST.get()));
12863 }
12864 match(IN);
12865
range_or_mark();
12866
if (inputState->guessing==0) {
12867 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12868 }
12869
break;
12870 }
12871
case NOT:
12872 {
12873 n = LT(1);
12874
if ( inputState->guessing == 0 ) {
12875 n_AST = astFactory->create(n);
12876 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
12877 }
12878 match(NOT);
12879 match(IN);
12880
range_or_mark();
12881
if (inputState->guessing==0) {
12882 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12883 }
12884
if ( inputState->guessing==0 ) {
12885
#line 1400 "ada.g"
12886
Set (n_AST, NOT_IN);
12887
#line 12888 "AdaParser.cpp"
12888
}
12889
break;
12890 }
12891
case EQ:
12892 {
12893
RefAdaAST tmp348_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12894
if ( inputState->guessing == 0 ) {
12895 tmp348_AST = astFactory->create(LT(1));
12896 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp348_AST.get()));
12897 }
12898 match(EQ);
12899
simple_expression();
12900
if (inputState->guessing==0) {
12901 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12902 }
12903
break;
12904 }
12905
case NE:
12906 {
12907
RefAdaAST tmp349_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12908
if ( inputState->guessing == 0 ) {
12909 tmp349_AST = astFactory->create(LT(1));
12910 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp349_AST.get()));
12911 }
12912 match(NE);
12913
simple_expression();
12914
if (inputState->guessing==0) {
12915 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12916 }
12917
break;
12918 }
12919
case LT_:
12920 {
12921
RefAdaAST tmp350_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12922
if ( inputState->guessing == 0 ) {
12923 tmp350_AST = astFactory->create(LT(1));
12924 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp350_AST.get()));
12925 }
12926 match(LT_);
12927
simple_expression();
12928
if (inputState->guessing==0) {
12929 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12930 }
12931
break;
12932 }
12933
case LE:
12934 {
12935
RefAdaAST tmp351_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12936
if ( inputState->guessing == 0 ) {
12937 tmp351_AST = astFactory->create(LT(1));
12938 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp351_AST.get()));
12939 }
12940 match(LE);
12941
simple_expression();
12942
if (inputState->guessing==0) {
12943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12944 }
12945
break;
12946 }
12947
case GT:
12948 {
12949
RefAdaAST tmp352_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12950
if ( inputState->guessing == 0 ) {
12951 tmp352_AST = astFactory->create(LT(1));
12952 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp352_AST.get()));
12953 }
12954 match(GT);
12955
simple_expression();
12956
if (inputState->guessing==0) {
12957 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12958 }
12959
break;
12960 }
12961
case GE:
12962 {
12963
RefAdaAST tmp353_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
12964
if ( inputState->guessing == 0 ) {
12965 tmp353_AST = astFactory->create(LT(1));
12966 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp353_AST.get()));
12967 }
12968 match(GE);
12969
simple_expression();
12970
if (inputState->guessing==0) {
12971 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
12972 }
12973
break;
12974 }
12975
case SEMI:
12976
case COMMA:
12977
case RPAREN:
12978
case RIGHT_SHAFT:
12979
case WITH:
12980
case RANGE:
12981
case DIGITS:
12982
case IS:
12983
case PIPE:
12984
case DOT_DOT:
12985
case ASSIGN:
12986
case THEN:
12987
case LOOP:
12988
case OR:
12989
case AND:
12990
case XOR:
12991 {
12992
break;
12993 }
12994
default:
12995 {
12996
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
12997 }
12998 }
12999 }
13000 relation_AST = (currentAST.
root);
13001 }
13002
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13003
if( inputState->guessing == 0 ) {
13004
reportError(ex);
13005 consume();
13006 consumeUntil(
_tokenSet_34);
13007 }
else {
13008
throw;
13009 }
13010 }
13011
returnAST = relation_AST;
13012 }
13013
13014 void AdaParser::range_or_mark() {
13015
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13016
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13017
RefAdaAST range_or_mark_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13018
13019
try {
13020
bool synPredMatched450 =
false;
13021
if (((
_tokenSet_5.member(LA(1))) && (
_tokenSet_33.member(LA(2))))) {
13022
int _m450 = mark();
13023 synPredMatched450 =
true;
13024 inputState->guessing++;
13025
try {
13026 {
13027
range();
13028 }
13029 }
13030
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& pe) {
13031 synPredMatched450 =
false;
13032 }
13033 rewind(_m450);
13034 inputState->guessing--;
13035 }
13036
if ( synPredMatched450 ) {
13037
range();
13038
if (inputState->guessing==0) {
13039 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13040 }
13041 range_or_mark_AST = (currentAST.
root);
13042 }
13043
else if ((LA(1) == IDENTIFIER) && (
_tokenSet_114.member(LA(2)))) {
13044
subtype_mark();
13045
if (inputState->guessing==0) {
13046 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13047 }
13048 range_or_mark_AST = (currentAST.
root);
13049 }
13050
else {
13051
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13052 }
13053
13054 }
13055
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13056
if( inputState->guessing == 0 ) {
13057
reportError(ex);
13058 consume();
13059 consumeUntil(
_tokenSet_34);
13060 }
else {
13061
throw;
13062 }
13063 }
13064
returnAST = range_or_mark_AST;
13065 }
13066
13067 void AdaParser::signed_term() {
13068
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13069
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13070
RefAdaAST signed_term_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13071
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13072
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13073
ANTLR_USE_NAMESPACE(antlr)
RefToken m =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13074
RefAdaAST m_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13075
13076
try {
13077
switch ( LA(1)) {
13078
case PLUS:
13079 {
13080 p = LT(1);
13081
if ( inputState->guessing == 0 ) {
13082 p_AST = astFactory->create(p);
13083 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13084 }
13085 match(PLUS);
13086
term();
13087
if (inputState->guessing==0) {
13088 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13089 }
13090
if ( inputState->guessing==0 ) {
13091
#line 1422 "ada.g"
13092
Set(p_AST, UNARY_PLUS);
13093
#line 13094 "AdaParser.cpp"
13094
}
13095 signed_term_AST = (currentAST.
root);
13096
break;
13097 }
13098
case MINUS:
13099 {
13100 m = LT(1);
13101
if ( inputState->guessing == 0 ) {
13102 m_AST = astFactory->create(m);
13103 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(m_AST.get()));
13104 }
13105 match(MINUS);
13106
term();
13107
if (inputState->guessing==0) {
13108 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13109 }
13110
if ( inputState->guessing==0 ) {
13111
#line 1423 "ada.g"
13112
Set(m_AST, UNARY_MINUS);
13113
#line 13114 "AdaParser.cpp"
13114
}
13115 signed_term_AST = (currentAST.
root);
13116
break;
13117 }
13118
case IDENTIFIER:
13119
case LPAREN:
13120
case NEW:
13121
case CHARACTER_LITERAL:
13122
case CHAR_STRING:
13123
case NuLL:
13124
case NOT:
13125
case ABS:
13126
case NUMERIC_LIT:
13127 {
13128
term();
13129
if (inputState->guessing==0) {
13130 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13131 }
13132 signed_term_AST = (currentAST.
root);
13133
break;
13134 }
13135
default:
13136 {
13137
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13138 }
13139 }
13140 }
13141
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13142
if( inputState->guessing == 0 ) {
13143
reportError(ex);
13144 consume();
13145 consumeUntil(
_tokenSet_115);
13146 }
else {
13147
throw;
13148 }
13149 }
13150
returnAST = signed_term_AST;
13151 }
13152
13153 void AdaParser::term() {
13154
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13155
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13156
RefAdaAST term_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13157
13158
try {
13159
factor();
13160
if (inputState->guessing==0) {
13161 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13162 }
13163 {
13164
for (;;) {
13165
switch ( LA(1)) {
13166
case STAR:
13167 {
13168
RefAdaAST tmp354_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13169
if ( inputState->guessing == 0 ) {
13170 tmp354_AST = astFactory->create(LT(1));
13171 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp354_AST.get()));
13172 }
13173 match(STAR);
13174
factor();
13175
if (inputState->guessing==0) {
13176 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13177 }
13178
break;
13179 }
13180
case DIV:
13181 {
13182
RefAdaAST tmp355_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13183
if ( inputState->guessing == 0 ) {
13184 tmp355_AST = astFactory->create(LT(1));
13185 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp355_AST.get()));
13186 }
13187 match(DIV);
13188
factor();
13189
if (inputState->guessing==0) {
13190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13191 }
13192
break;
13193 }
13194
case MOD:
13195 {
13196
RefAdaAST tmp356_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13197
if ( inputState->guessing == 0 ) {
13198 tmp356_AST = astFactory->create(LT(1));
13199 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp356_AST.get()));
13200 }
13201 match(MOD);
13202
factor();
13203
if (inputState->guessing==0) {
13204 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13205 }
13206
break;
13207 }
13208
case REM:
13209 {
13210
RefAdaAST tmp357_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13211
if ( inputState->guessing == 0 ) {
13212 tmp357_AST = astFactory->create(LT(1));
13213 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp357_AST.get()));
13214 }
13215 match(REM);
13216
factor();
13217
if (inputState->guessing==0) {
13218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13219 }
13220
break;
13221 }
13222
default:
13223 {
13224
goto _loop457;
13225 }
13226 }
13227 }
13228 _loop457:;
13229 }
13230 term_AST = (currentAST.
root);
13231 }
13232
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13233
if( inputState->guessing == 0 ) {
13234
reportError(ex);
13235 consume();
13236 consumeUntil(
_tokenSet_115);
13237 }
else {
13238
throw;
13239 }
13240 }
13241
returnAST = term_AST;
13242 }
13243
13244 void AdaParser::factor() {
13245
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13246
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13247
RefAdaAST factor_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13248
13249
try {
13250 {
13251
switch ( LA(1)) {
13252
case NOT:
13253 {
13254
RefAdaAST tmp358_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13255
if ( inputState->guessing == 0 ) {
13256 tmp358_AST = astFactory->create(LT(1));
13257 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp358_AST.get()));
13258 }
13259 match(NOT);
13260
primary();
13261
if (inputState->guessing==0) {
13262 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13263 }
13264
break;
13265 }
13266
case ABS:
13267 {
13268
RefAdaAST tmp359_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13269
if ( inputState->guessing == 0 ) {
13270 tmp359_AST = astFactory->create(LT(1));
13271 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp359_AST.get()));
13272 }
13273 match(ABS);
13274
primary();
13275
if (inputState->guessing==0) {
13276 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13277 }
13278
break;
13279 }
13280
case IDENTIFIER:
13281
case LPAREN:
13282
case NEW:
13283
case CHARACTER_LITERAL:
13284
case CHAR_STRING:
13285
case NuLL:
13286
case NUMERIC_LIT:
13287 {
13288
primary();
13289
if (inputState->guessing==0) {
13290 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13291 }
13292 {
13293
switch ( LA(1)) {
13294
case EXPON:
13295 {
13296
RefAdaAST tmp360_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13297
if ( inputState->guessing == 0 ) {
13298 tmp360_AST = astFactory->create(LT(1));
13299 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp360_AST.get()));
13300 }
13301 match(EXPON);
13302
primary();
13303
if (inputState->guessing==0) {
13304 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13305 }
13306
break;
13307 }
13308
case SEMI:
13309
case COMMA:
13310
case RPAREN:
13311
case RIGHT_SHAFT:
13312
case WITH:
13313
case RANGE:
13314
case DIGITS:
13315
case IS:
13316
case PIPE:
13317
case DOT_DOT:
13318
case IN:
13319
case ASSIGN:
13320
case MOD:
13321
case THEN:
13322
case LOOP:
13323
case OR:
13324
case AND:
13325
case XOR:
13326
case NOT:
13327
case EQ:
13328
case NE:
13329
case LT_:
13330
case LE:
13331
case GT:
13332
case GE:
13333
case PLUS:
13334
case MINUS:
13335
case CONCAT:
13336
case STAR:
13337
case DIV:
13338
case REM:
13339 {
13340
break;
13341 }
13342
default:
13343 {
13344
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13345 }
13346 }
13347 }
13348
break;
13349 }
13350
default:
13351 {
13352
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13353 }
13354 }
13355 }
13356 factor_AST = (currentAST.
root);
13357 }
13358
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13359
if( inputState->guessing == 0 ) {
13360
reportError(ex);
13361 consume();
13362 consumeUntil(
_tokenSet_116);
13363 }
else {
13364
throw;
13365 }
13366 }
13367
returnAST = factor_AST;
13368 }
13369
13370 void AdaParser::primary() {
13371
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13372
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13373
RefAdaAST primary_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13374
ANTLR_USE_NAMESPACE(antlr)
RefToken cs =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13375
RefAdaAST cs_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13376
13377
try {
13378 {
13379
switch ( LA(1)) {
13380
case IDENTIFIER:
13381 {
13382
name_or_qualified();
13383
if (inputState->guessing==0) {
13384 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13385 }
13386
break;
13387 }
13388
case LPAREN:
13389 {
13390
parenthesized_primary();
13391
if (inputState->guessing==0) {
13392 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13393 }
13394
break;
13395 }
13396
case NEW:
13397 {
13398
allocator();
13399
if (inputState->guessing==0) {
13400 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13401 }
13402
break;
13403 }
13404
case NuLL:
13405 {
13406
RefAdaAST tmp361_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13407
if ( inputState->guessing == 0 ) {
13408 tmp361_AST = astFactory->create(LT(1));
13409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp361_AST.get()));
13410 }
13411 match(NuLL);
13412
break;
13413 }
13414
case NUMERIC_LIT:
13415 {
13416
RefAdaAST tmp362_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13417
if ( inputState->guessing == 0 ) {
13418 tmp362_AST = astFactory->create(LT(1));
13419 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp362_AST.get()));
13420 }
13421 match(NUMERIC_LIT);
13422
break;
13423 }
13424
case CHARACTER_LITERAL:
13425 {
13426
RefAdaAST tmp363_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13427
if ( inputState->guessing == 0 ) {
13428 tmp363_AST = astFactory->create(LT(1));
13429 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp363_AST.get()));
13430 }
13431 match(CHARACTER_LITERAL);
13432
break;
13433 }
13434
case CHAR_STRING:
13435 {
13436 cs = LT(1);
13437
if ( inputState->guessing == 0 ) {
13438 cs_AST = astFactory->create(cs);
13439 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cs_AST.get()));
13440 }
13441 match(CHAR_STRING);
13442 {
13443
switch ( LA(1)) {
13444
case LPAREN:
13445 {
13446
operator_call_tail(cs_AST);
13447
if (inputState->guessing==0) {
13448 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13449 }
13450
break;
13451 }
13452
case SEMI:
13453
case COMMA:
13454
case RPAREN:
13455
case RIGHT_SHAFT:
13456
case WITH:
13457
case RANGE:
13458
case DIGITS:
13459
case IS:
13460
case PIPE:
13461
case DOT_DOT:
13462
case IN:
13463
case ASSIGN:
13464
case MOD:
13465
case THEN:
13466
case LOOP:
13467
case OR:
13468
case AND:
13469
case XOR:
13470
case NOT:
13471
case EQ:
13472
case NE:
13473
case LT_:
13474
case LE:
13475
case GT:
13476
case GE:
13477
case PLUS:
13478
case MINUS:
13479
case CONCAT:
13480
case STAR:
13481
case DIV:
13482
case REM:
13483
case EXPON:
13484 {
13485
break;
13486 }
13487
default:
13488 {
13489
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13490 }
13491 }
13492 }
13493
break;
13494 }
13495
default:
13496 {
13497
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13498 }
13499 }
13500 }
13501 primary_AST = (currentAST.
root);
13502 }
13503
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13504
if( inputState->guessing == 0 ) {
13505
reportError(ex);
13506 consume();
13507 consumeUntil(
_tokenSet_117);
13508 }
else {
13509
throw;
13510 }
13511 }
13512
returnAST = primary_AST;
13513 }
13514
13515 void AdaParser::name_or_qualified() {
13516
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13517
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13518
RefAdaAST name_or_qualified_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13519
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13520
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13521
#line 1454 "ada.g"
13522
RefAdaAST dummy;
13523
#line 13524 "AdaParser.cpp"
13524
13525
try {
13526
RefAdaAST tmp364_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13527
if ( inputState->guessing == 0 ) {
13528 tmp364_AST = astFactory->create(LT(1));
13529 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp364_AST.get()));
13530 }
13531 match(IDENTIFIER);
13532 {
13533
for (;;) {
13534
switch ( LA(1)) {
13535
case DOT:
13536 {
13537
RefAdaAST tmp365_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13538
if ( inputState->guessing == 0 ) {
13539 tmp365_AST = astFactory->create(LT(1));
13540 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp365_AST.get()));
13541 }
13542 match(DOT);
13543 {
13544
switch ( LA(1)) {
13545
case ALL:
13546 {
13547
RefAdaAST tmp366_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13548
if ( inputState->guessing == 0 ) {
13549 tmp366_AST = astFactory->create(LT(1));
13550 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp366_AST.get()));
13551 }
13552 match(ALL);
13553
break;
13554 }
13555
case IDENTIFIER:
13556 {
13557
RefAdaAST tmp367_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13558
if ( inputState->guessing == 0 ) {
13559 tmp367_AST = astFactory->create(LT(1));
13560 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp367_AST.get()));
13561 }
13562 match(IDENTIFIER);
13563
break;
13564 }
13565
case CHARACTER_LITERAL:
13566 {
13567
RefAdaAST tmp368_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13568
if ( inputState->guessing == 0 ) {
13569 tmp368_AST = astFactory->create(LT(1));
13570 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp368_AST.get()));
13571 }
13572 match(CHARACTER_LITERAL);
13573
break;
13574 }
13575
case CHAR_STRING:
13576 {
13577 dummy=
is_operator();
13578
if (inputState->guessing==0) {
13579 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13580 }
13581
break;
13582 }
13583
default:
13584 {
13585
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13586 }
13587 }
13588 }
13589
break;
13590 }
13591
case LPAREN:
13592 {
13593 p = LT(1);
13594
if ( inputState->guessing == 0 ) {
13595 p_AST = astFactory->create(p);
13596 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13597 }
13598 match(LPAREN);
13599
value_s();
13600
if (inputState->guessing==0) {
13601 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13602 }
13603 match(RPAREN);
13604
if ( inputState->guessing==0 ) {
13605
#line 1462 "ada.g"
13606
Set(p_AST, INDEXED_COMPONENT);
13607
#line 13608 "AdaParser.cpp"
13608
}
13609
break;
13610 }
13611
case TIC:
13612 {
13613
RefAdaAST tmp370_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13614
if ( inputState->guessing == 0 ) {
13615 tmp370_AST = astFactory->create(LT(1));
13616 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp370_AST.get()));
13617 }
13618 match(TIC);
13619 {
13620
switch ( LA(1)) {
13621
case LPAREN:
13622 {
13623
parenthesized_primary();
13624
if (inputState->guessing==0) {
13625 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13626 }
13627
break;
13628 }
13629
case IDENTIFIER:
13630
case RANGE:
13631
case DIGITS:
13632
case DELTA:
13633
case ACCESS:
13634 {
13635
attribute_id();
13636
if (inputState->guessing==0) {
13637 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13638 }
13639
break;
13640 }
13641
default:
13642 {
13643
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13644 }
13645 }
13646 }
13647
break;
13648 }
13649
default:
13650 {
13651
goto _loop468;
13652 }
13653 }
13654 }
13655 _loop468:;
13656 }
13657 name_or_qualified_AST = (currentAST.
root);
13658 }
13659
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13660
if( inputState->guessing == 0 ) {
13661
reportError(ex);
13662 consume();
13663 consumeUntil(
_tokenSet_117);
13664 }
else {
13665
throw;
13666 }
13667 }
13668
returnAST = name_or_qualified_AST;
13669 }
13670
13671 void AdaParser::allocator() {
13672
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13673
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13674
RefAdaAST allocator_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13675
ANTLR_USE_NAMESPACE(antlr)
RefToken n =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13676
RefAdaAST n_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13677
13678
try {
13679 n = LT(1);
13680
if ( inputState->guessing == 0 ) {
13681 n_AST = astFactory->create(n);
13682 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
13683 }
13684 match(NEW);
13685
name_or_qualified();
13686
if (inputState->guessing==0) {
13687 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13688 }
13689
if ( inputState->guessing==0 ) {
13690
#line 1468 "ada.g"
13691
Set(n_AST, ALLOCATOR);
13692
#line 13693 "AdaParser.cpp"
13693
}
13694 allocator_AST = (currentAST.
root);
13695 }
13696
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13697
if( inputState->guessing == 0 ) {
13698
reportError(ex);
13699 consume();
13700 consumeUntil(
_tokenSet_117);
13701 }
else {
13702
throw;
13703 }
13704 }
13705
returnAST = allocator_AST;
13706 }
13707
13708 void AdaParser::subprogram_body() {
13709
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13710
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13711
RefAdaAST subprogram_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13712
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13713
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13714
ANTLR_USE_NAMESPACE(antlr)
RefToken f =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13715
RefAdaAST f_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13716
13717
try {
13718
switch ( LA(1)) {
13719
case PROCEDURE:
13720 {
13721 p = LT(1);
13722
if ( inputState->guessing == 0 ) {
13723 p_AST = astFactory->create(p);
13724 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13725 }
13726 match(PROCEDURE);
13727
def_id(
false);
13728
if (inputState->guessing==0) {
13729 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13730 }
13731
formal_part_opt();
13732
if (inputState->guessing==0) {
13733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13734 }
13735 match(IS);
13736
body_part();
13737
if (inputState->guessing==0) {
13738 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13739 }
13740 match(SEMI);
13741
if ( inputState->guessing==0 ) {
13742
#line 1482 "ada.g"
13743
Set(p_AST, PROCEDURE_BODY);
13744
#line 13745 "AdaParser.cpp"
13745
}
13746 subprogram_body_AST = (currentAST.
root);
13747
break;
13748 }
13749
case FUNCTION:
13750 {
13751 f = LT(1);
13752
if ( inputState->guessing == 0 ) {
13753 f_AST = astFactory->create(f);
13754 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
13755 }
13756 match(FUNCTION);
13757
function_tail();
13758
if (inputState->guessing==0) {
13759 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13760 }
13761 match(IS);
13762
body_part();
13763
if (inputState->guessing==0) {
13764 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13765 }
13766 match(SEMI);
13767
if ( inputState->guessing==0 ) {
13768
#line 1484 "ada.g"
13769
Set(f_AST, FUNCTION_BODY);
13770
#line 13771 "AdaParser.cpp"
13771
}
13772 subprogram_body_AST = (currentAST.
root);
13773
break;
13774 }
13775
default:
13776 {
13777
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(LT(1), getFilename());
13778 }
13779 }
13780 }
13781
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13782
if( inputState->guessing == 0 ) {
13783
reportError(ex);
13784 consume();
13785 consumeUntil(
_tokenSet_2);
13786 }
else {
13787
throw;
13788 }
13789 }
13790
returnAST = subprogram_body_AST;
13791 }
13792
13793 void AdaParser::package_body() {
13794
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13795
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13796
RefAdaAST package_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13797
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13798
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13799
13800
try {
13801 p = LT(1);
13802
if ( inputState->guessing == 0 ) {
13803 p_AST = astFactory->create(p);
13804 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13805 }
13806 match(PACKAGE);
13807
body_is();
13808
if (inputState->guessing==0) {
13809 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13810 }
13811
pkg_body_part();
13812
if (inputState->guessing==0) {
13813 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13814 }
13815
end_id_opt();
13816 match(SEMI);
13817
if ( inputState->guessing==0 ) {
13818
#line 1488 "ada.g"
13819
Set(p_AST, PACKAGE_BODY);
13820
#line 13821 "AdaParser.cpp"
13821
}
13822 package_body_AST = (currentAST.
root);
13823 }
13824
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13825
if( inputState->guessing == 0 ) {
13826
reportError(ex);
13827 consume();
13828 consumeUntil(
_tokenSet_2);
13829 }
else {
13830
throw;
13831 }
13832 }
13833
returnAST = package_body_AST;
13834 }
13835
13836 void AdaParser::task_body() {
13837
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13838
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13839
RefAdaAST task_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13840
ANTLR_USE_NAMESPACE(antlr)
RefToken t =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13841
RefAdaAST t_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13842
13843
try {
13844 t = LT(1);
13845
if ( inputState->guessing == 0 ) {
13846 t_AST = astFactory->create(t);
13847 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
13848 }
13849 match(TASK);
13850
body_is();
13851
if (inputState->guessing==0) {
13852 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13853 }
13854
body_part();
13855
if (inputState->guessing==0) {
13856 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13857 }
13858 match(SEMI);
13859
if ( inputState->guessing==0 ) {
13860
#line 1492 "ada.g"
13861
Set(t_AST, TASK_BODY);
13862
#line 13863 "AdaParser.cpp"
13863
}
13864 task_body_AST = (currentAST.
root);
13865 }
13866
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13867
if( inputState->guessing == 0 ) {
13868
reportError(ex);
13869 consume();
13870 consumeUntil(
_tokenSet_2);
13871 }
else {
13872
throw;
13873 }
13874 }
13875
returnAST = task_body_AST;
13876 }
13877
13878 void AdaParser::protected_body() {
13879
returnAST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13880
ANTLR_USE_NAMESPACE(antlr)
ASTPair currentAST;
13881
RefAdaAST protected_body_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13882
ANTLR_USE_NAMESPACE(antlr)
RefToken p =
ANTLR_USE_NAMESPACE(antlr)
nullToken;
13883
RefAdaAST p_AST = static_cast<RefAdaAST>(
ANTLR_USE_NAMESPACE(antlr)
nullAST.
get());
13884
13885
try {
13886 p = LT(1);
13887
if ( inputState->guessing == 0 ) {
13888 p_AST = astFactory->create(p);
13889 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13890 }
13891 match(PROTECTED);
13892
body_is();
13893
if (inputState->guessing==0) {
13894 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13895 }
13896
prot_op_bodies_opt();
13897
if (inputState->guessing==0) {
13898 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(
returnAST.get()));
13899 }
13900
end_id_opt();
13901 match(SEMI);
13902
if ( inputState->guessing==0 ) {
13903
#line 1496 "ada.g"
13904
Set(p_AST, PROTECTED_BODY);
13905
#line 13906 "AdaParser.cpp"
13906
}
13907 protected_body_AST = (currentAST.
root);
13908 }
13909
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
13910
if( inputState->guessing == 0 ) {
13911
reportError(ex);
13912 consume();
13913 consumeUntil(
_tokenSet_2);
13914 }
else {
13915
throw;
13916 }
13917 }
13918
returnAST = protected_body_AST;
13919 }
13920
13921 RefAdaAST AdaParser::getAST()
13922 {
13923
return returnAST;
13924 }
13925
13926 void AdaParser::initializeASTFactory(
ANTLR_USE_NAMESPACE(antlr)
ASTFactory& factory )
13927 {
13928 factory.setMaxNodeType(303);
13929 }
13930 const char*
AdaParser::tokenNames[] = {
13931
"<0>",
13932
"EOF",
13933
"<2>",
13934
"NULL_TREE_LOOKAHEAD",
13935
"\"pragma\"",
13936
"IDENTIFIER",
13937
"SEMI",
13938
"LPAREN",
13939
"COMMA",
13940
"RPAREN",
13941
"RIGHT_SHAFT",
13942
"\"with\"",
13943
"DOT",
13944
"\"use\"",
13945
"\"type\"",
13946
"TIC",
13947
"\"range\"",
13948
"\"digits\"",
13949
"\"delta\"",
13950
"\"access\"",
13951
"\"private\"",
13952
"\"package\"",
13953
"\"body\"",
13954
"\"is\"",
13955
"\"procedure\"",
13956
"\"function\"",
13957
"\"new\"",
13958
"\"others\"",
13959
"PIPE",
13960
"DOT_DOT",
13961
"\"all\"",
13962
"COLON",
13963
"\"in\"",
13964
"\"out\"",
13965
"\"renames\"",
13966
"CHARACTER_LITERAL",
13967
"CHAR_STRING",
13968
"\"null\"",
13969
"\"record\"",
13970
"\"separate\"",
13971
"\"abstract\"",
13972
"\"return\"",
13973
"\"task\"",
13974
"\"protected\"",
13975
"BOX",
13976
"ASSIGN",
13977
"\"entry\"",
13978
"\"for\"",
13979
"\"end\"",
13980
"\"at\"",
13981
"\"mod\"",
13982
"\"subtype\"",
13983
"\"exception\"",
13984
"\"constant\"",
13985
"\"array\"",
13986
"\"of\"",
13987
"\"aliased\"",
13988
"\"case\"",
13989
"\"when\"",
13990
"\"tagged\"",
13991
"\"limited\"",
13992
"\"generic\"",
13993
"\"begin\"",
13994
"LT_LT",
13995
"GT_GT",
13996
"\"if\"",
13997
"\"then\"",
13998
"\"elsif\"",
13999
"\"else\"",
14000
"\"loop\"",
14001
"\"while\"",
14002
"\"reverse\"",
14003
"\"declare\"",
14004
"\"exit\"",
14005
"\"goto\"",
14006
"\"accept\"",
14007
"\"do\"",
14008
"\"delay\"",
14009
"\"until\"",
14010
"\"select\"",
14011
"\"abort\"",
14012
"\"or\"",
14013
"\"terminate\"",
14014
"\"raise\"",
14015
"\"requeue\"",
14016
"\"and\"",
14017
"\"xor\"",
14018
"\"not\"",
14019
"EQ",
14020
"NE",
14021
"LT_",
14022
"LE",
14023
"GT",
14024
"GE",
14025
"PLUS",
14026
"MINUS",
14027
"CONCAT",
14028
"STAR",
14029
"DIV",
14030
"\"rem\"",
14031
"\"abs\"",
14032
"EXPON",
14033
"NUMERIC_LIT",
14034
"ABORTABLE_PART",
14035
"ABORT_STATEMENT",
14036
"ABSTRACT_SUBPROGRAM_DECLARATION",
14037
"ACCEPT_ALTERNATIVE",
14038
"ACCEPT_STATEMENT",
14039
"ALLOCATOR",
14040
"ASSIGNMENT_STATEMENT",
14041
"ASYNCHRONOUS_SELECT",
14042
"ATTRIBUTE_DEFINITION_CLAUSE",
14043
"AT_CLAUSE",
14044
"BLOCK_STATEMENT",
14045
"CASE_STATEMENT",
14046
"CASE_STATEMENT_ALTERNATIVE",
14047
"CODE_STATEMENT",
14048
"COMPONENT_DECLARATION",
14049
"COMPONENT_LIST",
14050
"CONDITION",
14051
"CONDITIONAL_ENTRY_CALL",
14052
"CONTEXT_CLAUSE",
14053
"DECLARATIVE_ITEM",
14054
"DECLARATIVE_PART",
14055
"DEFINING_IDENTIFIER_LIST",
14056
"DELAY_ALTERNATIVE",
14057
"DELAY_STATEMENT",
14058
"DELTA_CONSTRAINT",
14059
"DIGITS_CONSTRAINT",
14060
"DISCRETE_RANGE",
14061
"DISCRIMINANT_ASSOCIATION",
14062
"DISCRIMINANT_CONSTRAINT",
14063
"DISCRIMINANT_SPECIFICATION",
14064
"ENTRY_BODY",
14065
"ENTRY_CALL_ALTERNATIVE",
14066
"ENTRY_CALL_STATEMENT",
14067
"ENTRY_DECLARATION",
14068
"ENTRY_INDEX_SPECIFICATION",
14069
"ENUMERATION_REPESENTATION_CLAUSE",
14070
"EXCEPTION_DECLARATION",
14071
"EXCEPTION_HANDLER",
14072
"EXCEPTION_RENAMING_DECLARATION",
14073
"EXIT_STATEMENT",
14074
"FORMAL_PACKAGE_DECLARATION",
14075
"FORMAL_TYPE_DECLARATION",
14076
"FULL_TYPE_DECLARATION",
14077
"GENERIC_FORMAL_PART",
14078
"GENERIC_INSTANTIATION",
14079
"GENERIC_PACKAGE_DECLARATION",
14080
"GENERIC_RENAMING_DECLARATION",
14081
"GENERIC_SUBPROGRAM_DECLARATION",
14082
"GOTO_STATEMENT",
14083
"HANDLED_SEQUENCE_OF_STATEMENTS",
14084
"IF_STATEMENT",
14085
"INCOMPLETE_TYPE_DECLARATION",
14086
"INDEXED_COMPONENT",
14087
"INDEX_CONSTRAINT",
14088
"LIBRARY_ITEM",
14089
"LOOP_STATEMENT",
14090
"NAME",
14091
"NULL_STATEMENT",
14092
"NUMBER_DECLARATION",
14093
"OBJECT_DECLARATION",
14094
"OBJECT_RENAMING_DECLARATION",
14095
"OPERATOR_SYMBOL",
14096
"PACKAGE_BODY",
14097
"PACKAGE_BODY_STUB",
14098
"PACKAGE_RENAMING_DECLARATION",
14099
"PACKAGE_SPECIFICATION",
14100
"PARAMETER_SPECIFICATION",
14101
"PREFIX",
14102
"PRIMARY",
14103
"PRIVATE_EXTENSION_DECLARATION",
14104
"PRIVATE_TYPE_DECLARATION",
14105
"PROCEDURE_CALL_STATEMENT",
14106
"PROTECTED_BODY",
14107
"PROTECTED_BODY_STUB",
14108
"PROTECTED_TYPE_DECLARATION",
14109
"RAISE_STATEMENT",
14110
"RANGE_ATTRIBUTE_REFERENCE",
14111
"RECORD_REPRESENTATION_CLAUSE",
14112
"REQUEUE_STATEMENT",
14113
"RETURN_STATEMENT",
14114
"SELECTIVE_ACCEPT",
14115
"SELECT_ALTERNATIVE",
14116
"SELECT_STATEMENT",
14117
"SEQUENCE_OF_STATEMENTS",
14118
"SINGLE_PROTECTED_DECLARATION",
14119
"SINGLE_TASK_DECLARATION",
14120
"STATEMENT",
14121
"SUBPROGRAM_BODY",
14122
"SUBPROGRAM_BODY_STUB",
14123
"SUBPROGRAM_DECLARATION",
14124
"SUBPROGRAM_RENAMING_DECLARATION",
14125
"SUBTYPE_DECLARATION",
14126
"SUBTYPE_INDICATION",
14127
"SUBTYPE_MARK",
14128
"SUBUNIT",
14129
"TASK_BODY",
14130
"TASK_BODY_STUB",
14131
"TASK_TYPE_DECLARATION",
14132
"TERMINATE_ALTERNATIVE",
14133
"TIMED_ENTRY_CALL",
14134
"TRIGGERING_ALTERNATIVE",
14135
"TYPE_DECLARATION",
14136
"USE_CLAUSE",
14137
"USE_TYPE_CLAUSE",
14138
"VARIANT",
14139
"VARIANT_PART",
14140
"WITH_CLAUSE",
14141
"ABSTRACT_FUNCTION_DECLARATION",
14142
"ABSTRACT_PROCEDURE_DECLARATION",
14143
"ACCESS_TO_FUNCTION_DECLARATION",
14144
"ACCESS_TO_OBJECT_DECLARATION",
14145
"ACCESS_TO_PROCEDURE_DECLARATION",
14146
"ACCESS_TYPE_DECLARATION",
14147
"ARRAY_OBJECT_DECLARATION",
14148
"ARRAY_TYPE_DECLARATION",
14149
"AND_THEN",
14150
"BASIC_DECLARATIVE_ITEMS_OPT",
14151
"BLOCK_BODY",
14152
"BLOCK_BODY_OPT",
14153
"CALL_STATEMENT",
14154
"COMPONENT_CLAUSES_OPT",
14155
"COMPONENT_ITEMS",
14156
"COND_CLAUSE",
14157
"DECIMAL_FIXED_POINT_DECLARATION",
14158
"DECLARE_OPT",
14159
"DERIVED_RECORD_EXTENSION",
14160
"DERIVED_TYPE_DECLARATION",
14161
"DISCRETE_SUBTYPE_DEF_OPT",
14162
"DISCRIMINANT_SPECIFICATIONS",
14163
"DISCRIM_PART_OPT",
14164
"ELSE_OPT",
14165
"ELSIFS_OPT",
14166
"ENTRY_INDEX_OPT",
14167
"ENUMERATION_TYPE_DECLARATION",
14168
"EXCEPT_HANDLER_PART_OPT",
14169
"EXTENSION_OPT",
14170
"FLOATING_POINT_DECLARATION",
14171
"FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
14172
"FORMAL_DISCRETE_TYPE_DECLARATION",
14173
"FORMAL_FLOATING_POINT_DECLARATION",
14174
"FORMAL_FUNCTION_DECLARATION",
14175
"FORMAL_MODULAR_TYPE_DECLARATION",
14176
"FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
14177
"FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
14178
"FORMAL_PART_OPT",
14179
"FORMAL_PRIVATE_EXTENSION_DECLARATION",
14180
"FORMAL_PRIVATE_TYPE_DECLARATION",
14181
"FORMAL_PROCEDURE_DECLARATION",
14182
"FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
14183
"FUNCTION_BODY",
14184
"FUNCTION_BODY_STUB",
14185
"FUNCTION_DECLARATION",
14186
"FUNCTION_RENAMING_DECLARATION",
14187
"GENERIC_FUNCTION_DECLARATION",
14188
"GENERIC_FUNCTION_INSTANTIATION",
14189
"GENERIC_FUNCTION_RENAMING",
14190
"GENERIC_PACKAGE_INSTANTIATION",
14191
"GENERIC_PACKAGE_RENAMING",
14192
"GENERIC_PROCEDURE_DECLARATION",
14193
"GENERIC_PROCEDURE_INSTANTIATION",
14194
"GENERIC_PROCEDURE_RENAMING",
14195
"GUARD_OPT",
14196
"IDENTIFIER_COLON_OPT",
14197
"INIT_OPT",
14198
"ITERATION_SCHEME_OPT",
14199
"LABEL_OPT",
14200
"MARK_WITH_CONSTRAINT",
14201
"MODIFIERS",
14202
"MODULAR_TYPE_DECLARATION",
14203
"MOD_CLAUSE_OPT",
14204
"NOT_IN",
14205
"ORDINARY_DERIVED_TYPE_DECLARATION",
14206
"ORDINARY_FIXED_POINT_DECLARATION",
14207
"OR_ELSE",
14208
"OR_SELECT_OPT",
14209
"PARENTHESIZED_PRIMARY",
14210
"PRIVATE_TASK_ITEMS_OPT",
14211
"PROCEDURE_BODY",
14212
"PROCEDURE_BODY_STUB",
14213
"PROCEDURE_DECLARATION",
14214
"PROCEDURE_RENAMING_DECLARATION",
14215
"PROT_MEMBER_DECLARATIONS",
14216
"PROT_OP_BODIES_OPT",
14217
"PROT_OP_DECLARATIONS",
14218
"RANGED_EXPRS",
14219
"RECORD_TYPE_DECLARATION",
14220
"SELECTOR_NAMES_OPT",
14221
"SIGNED_INTEGER_TYPE_DECLARATION",
14222
"TASK_ITEMS_OPT",
14223
"UNARY_MINUS",
14224
"UNARY_PLUS",
14225
"VALUE",
14226
"VALUES",
14227
"VARIANTS",
14228
"COMMENT_INTRO",
14229
"DIGIT",
14230
"EXPONENT",
14231
"EXTENDED_DIGIT",
14232
"BASED_INTEGER",
14233
"WS_",
14234
"COMMENT",
14235 0
14236 };
14237
14238 const unsigned long AdaParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14239
14240
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_0(_tokenSet_0_data_,10);
14241 const
unsigned long AdaParser::_tokenSet_1_data_[] = { 53477376UL, 536871040UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14242
14243
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_1(_tokenSet_1_data_,10);
14244 const
unsigned long AdaParser::_tokenSet_2_data_[] = { 18UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14245
14246
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_2(_tokenSet_2_data_,10);
14247 const
unsigned long AdaParser::_tokenSet_3_data_[] = { 53504050UL, 3860450976UL, 2076542UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14248
14249
14250
14251
14252
14253
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_3(_tokenSet_3_data_,10);
14254 const
unsigned long AdaParser::_tokenSet_4_data_[] = { 64UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14255
14256
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_4(_tokenSet_4_data_,10);
14257 const
unsigned long AdaParser::_tokenSet_5_data_[] = { 67109024UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14258
14259
14260
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_5(_tokenSet_5_data_,10);
14261 const
unsigned long AdaParser::_tokenSet_6_data_[] = { 201364384UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14262
14263
14264
14265
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_6(_tokenSet_6_data_,10);
14266 const
unsigned long AdaParser::_tokenSet_7_data_[] = { 768UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14267
14268
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_7(_tokenSet_7_data_,10);
14269 const
unsigned long AdaParser::_tokenSet_8_data_[] = { 813895488UL, 8192UL, 36UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14270
14271
14272
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_8(_tokenSet_8_data_,10);
14273 const
unsigned long AdaParser::_tokenSet_9_data_[] = { 53487632UL, 536871040UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14274
14275
14276
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_9(_tokenSet_9_data_,10);
14277 const
unsigned long AdaParser::_tokenSet_10_data_[] = { 53504050UL, 1611238528UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14278
14279
14280
14281
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_10(_tokenSet_10_data_,10);
14282 const
unsigned long AdaParser::_tokenSet_11_data_[] = { 814198720UL, 67248645UL, 6426660UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14283
14284
14285
14286
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_11(_tokenSet_11_data_,10);
14287 const
unsigned long AdaParser::_tokenSet_12_data_[] = { 814165952UL, 139268UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14288
14289
14290
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_12(_tokenSet_12_data_,10);
14291 const
unsigned long AdaParser::_tokenSet_13_data_[] = { 814202816UL, 401413UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14292
14293
14294
14295
14296
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_13(_tokenSet_13_data_,10);
14297 const
unsigned long AdaParser::_tokenSet_14_data_[] = { 52428800UL, 536870912UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14298
14299
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_14(_tokenSet_14_data_,10);
14300 const
unsigned long AdaParser::_tokenSet_15_data_[] = { 8388800UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14301
14302
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_15(_tokenSet_15_data_,10);
14303 const
unsigned long AdaParser::_tokenSet_16_data_[] = { 52453426UL, 1611238800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14304
14305
14306
14307
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_16(_tokenSet_16_data_,10);
14308 const
unsigned long AdaParser::_tokenSet_17_data_[] = { 52453426UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14309
14310
14311
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_17(_tokenSet_17_data_,10);
14312 const
unsigned long AdaParser::_tokenSet_18_data_[] = { 53502002UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14313
14314
14315
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_18(_tokenSet_18_data_,10);
14316 const
unsigned long AdaParser::_tokenSet_19_data_[] = { 8392896UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14317
14318
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_19(_tokenSet_19_data_,10);
14319 const
unsigned long AdaParser::_tokenSet_20_data_[] = { 8388800UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14320
14321
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_20(_tokenSet_20_data_,10);
14322 const
unsigned long AdaParser::_tokenSet_21_data_[] = { 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14323
14324
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_21(_tokenSet_21_data_,10);
14325 const
unsigned long AdaParser::_tokenSet_22_data_[] = { 53502002UL, 537496976UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14326
14327
14328
14329
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_22(_tokenSet_22_data_,10);
14330 const
unsigned long AdaParser::_tokenSet_23_data_[] = { 53502002UL, 537496576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14331
14332
14333
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_23(_tokenSet_23_data_,10);
14334 const
unsigned long AdaParser::_tokenSet_24_data_[] = { 8388672UL, 67108868UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14335
14336
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_24(_tokenSet_24_data_,10);
14337 const
unsigned long AdaParser::_tokenSet_25_data_[] = { 8392832UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14338
14339
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_25(_tokenSet_25_data_,10);
14340 const
unsigned long AdaParser::_tokenSet_26_data_[] = { 8388736UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14341
14342
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_26(_tokenSet_26_data_,10);
14343 const
unsigned long AdaParser::_tokenSet_27_data_[] = { 8388672UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14344
14345
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_27(_tokenSet_27_data_,10);
14346 const
unsigned long AdaParser::_tokenSet_28_data_[] = { 2560UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14347
14348
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_28(_tokenSet_28_data_,10);
14349 const
unsigned long AdaParser::_tokenSet_29_data_[] = { 2816UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14350
14351
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_29(_tokenSet_29_data_,10);
14352 const
unsigned long AdaParser::_tokenSet_30_data_[] = { 3840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14353
14354
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_30(_tokenSet_30_data_,10);
14355 const
unsigned long AdaParser::_tokenSet_31_data_[] = { 268439296UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14356
14357
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_31(_tokenSet_31_data_,10);
14358 const
unsigned long AdaParser::_tokenSet_32_data_[] = { 813895488UL, 8193UL, 1071775780UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14359
14360
14361
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_32(_tokenSet_32_data_,10);
14362 const
unsigned long AdaParser::_tokenSet_33_data_[] = { 738234528UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14363
14364
14365
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_33(_tokenSet_33_data_,10);
14366 const
unsigned long AdaParser::_tokenSet_34_data_[] = { 813895488UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14367
14368
14369
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_34(_tokenSet_34_data_,10);
14370 const
unsigned long AdaParser::_tokenSet_35_data_[] = { 268439360UL, 8192UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14371
14372
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_35(_tokenSet_35_data_,10);
14373 const
unsigned long AdaParser::_tokenSet_36_data_[] = { 32768UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14374
14375
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_36(_tokenSet_36_data_,10);
14376 const
unsigned long AdaParser::_tokenSet_37_data_[] = { 576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14377
14378
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_37(_tokenSet_37_data_,10);
14379 const
unsigned long AdaParser::_tokenSet_38_data_[] = { 524320UL, 16777219UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14380
14381
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_38(_tokenSet_38_data_,10);
14382 const
unsigned long AdaParser::_tokenSet_39_data_[] = { 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14383
14384
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_39(_tokenSet_39_data_,10);
14385 const
unsigned long AdaParser::_tokenSet_40_data_[] = { 2147484160UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14386
14387
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_40(_tokenSet_40_data_,10);
14388 const
unsigned long AdaParser::_tokenSet_41_data_[] = { 2368UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14389
14390
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_41(_tokenSet_41_data_,10);
14391 const
unsigned long AdaParser::_tokenSet_42_data_[] = { 8388800UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14392
14393
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_42(_tokenSet_42_data_,10);
14394 const
unsigned long AdaParser::_tokenSet_43_data_[] = { 813932480UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14395
14396
14397
14398
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_43(_tokenSet_43_data_,10);
14399 const
unsigned long AdaParser::_tokenSet_44_data_[] = { 201326752UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14400
14401
14402
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_44(_tokenSet_44_data_,10);
14403 const
unsigned long AdaParser::_tokenSet_45_data_[] = { 1006739360UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14404
14405
14406
14407
14408
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_45(_tokenSet_45_data_,10);
14409 const
unsigned long AdaParser::_tokenSet_46_data_[] = { 1006737312UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14410
14411
14412
14413
14414
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_46(_tokenSet_46_data_,10);
14415 const
unsigned long AdaParser::_tokenSet_47_data_[] = { 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14416
14417
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_47(_tokenSet_47_data_,10);
14418 const
unsigned long AdaParser::_tokenSet_48_data_[] = { 0UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14419
14420
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_48(_tokenSet_48_data_,10);
14421 const
unsigned long AdaParser::_tokenSet_49_data_[] = { 1048576UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14422
14423
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_49(_tokenSet_49_data_,10);
14424 const
unsigned long AdaParser::_tokenSet_50_data_[] = { 32UL, 23068672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14425
14426
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_50(_tokenSet_50_data_,10);
14427 const
unsigned long AdaParser::_tokenSet_51_data_[] = { 495840UL, 6299648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14428
14429
14430
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_51(_tokenSet_51_data_,10);
14431 const
unsigned long AdaParser::_tokenSet_52_data_[] = { 8388672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14432
14433
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_52(_tokenSet_52_data_,10);
14434 const
unsigned long AdaParser::_tokenSet_53_data_[] = { 68157504UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14435
14436
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_53(_tokenSet_53_data_,10);
14437 const
unsigned long AdaParser::_tokenSet_54_data_[] = { 51380272UL, 114688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14438
14439
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_54(_tokenSet_54_data_,10);
14440 const
unsigned long AdaParser::_tokenSet_55_data_[] = { 192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14441
14442
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_55(_tokenSet_55_data_,10);
14443 const
unsigned long AdaParser::_tokenSet_56_data_[] = { 496256UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14444
14445
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_56(_tokenSet_56_data_,10);
14446 const
unsigned long AdaParser::_tokenSet_57_data_[] = { 512UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14447
14448
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_57(_tokenSet_57_data_,10);
14449 const
unsigned long AdaParser::_tokenSet_58_data_[] = { 2880UL, 8192UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14450
14451
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_58(_tokenSet_58_data_,10);
14452 const
unsigned long AdaParser::_tokenSet_59_data_[] = { 48UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14453
14454
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_59(_tokenSet_59_data_,10);
14455 const
unsigned long AdaParser::_tokenSet_60_data_[] = { 50331664UL, 49152UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14456
14457
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_60(_tokenSet_60_data_,10);
14458 const
unsigned long AdaParser::_tokenSet_61_data_[] = { 50331696UL, 100777984UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14459
14460
14461
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_61(_tokenSet_61_data_,10);
14462 const
unsigned long AdaParser::_tokenSet_62_data_[] = { 64UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14463
14464
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_62(_tokenSet_62_data_,10);
14465 const
unsigned long AdaParser::_tokenSet_63_data_[] = { 1048576UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14466
14467
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_63(_tokenSet_63_data_,10);
14468 const
unsigned long AdaParser::_tokenSet_64_data_[] = { 1048688UL, 436207712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14469
14470
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_64(_tokenSet_64_data_,10);
14471 const
unsigned long AdaParser::_tokenSet_65_data_[] = { 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14472
14473
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_65(_tokenSet_65_data_,10);
14474 const
unsigned long AdaParser::_tokenSet_66_data_[] = { 32UL, 4194304UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14475
14476
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_66(_tokenSet_66_data_,10);
14477 const
unsigned long AdaParser::_tokenSet_67_data_[] = { 496512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14478
14479
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_67(_tokenSet_67_data_,10);
14480 const
unsigned long AdaParser::_tokenSet_68_data_[] = { 268436480UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14481
14482
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_68(_tokenSet_68_data_,10);
14483 const
unsigned long AdaParser::_tokenSet_69_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14484
14485
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_69(_tokenSet_69_data_,10);
14486 const
unsigned long AdaParser::_tokenSet_70_data_[] = { 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14487
14488
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_70(_tokenSet_70_data_,10);
14489 const
unsigned long AdaParser::_tokenSet_71_data_[] = { 1048576UL, 96UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14490
14491
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_71(_tokenSet_71_data_,10);
14492 const
unsigned long AdaParser::_tokenSet_72_data_[] = { 0UL, 67174400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14493
14494
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_72(_tokenSet_72_data_,10);
14495 const
unsigned long AdaParser::_tokenSet_73_data_[] = { 0UL, 100728832UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14496
14497
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_73(_tokenSet_73_data_,10);
14498 const
unsigned long AdaParser::_tokenSet_74_data_[] = { 0UL, 33554432UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14499
14500
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_74(_tokenSet_74_data_,10);
14501 const
unsigned long AdaParser::_tokenSet_75_data_[] = { 8388608UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14502
14503
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_75(_tokenSet_75_data_,10);
14504 const
unsigned long AdaParser::_tokenSet_76_data_[] = { 1024UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14505
14506
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_76(_tokenSet_76_data_,10);
14507 const
unsigned long AdaParser::_tokenSet_77_data_[] = { 738300064UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14508
14509
14510
14511
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_77(_tokenSet_77_data_,10);
14512 const
unsigned long AdaParser::_tokenSet_78_data_[] = { 469800096UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14513
14514
14515
14516
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_78(_tokenSet_78_data_,10);
14517 const
unsigned long AdaParser::_tokenSet_79_data_[] = { 52428800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14518
14519
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_79(_tokenSet_79_data_,10);
14520 const
unsigned long AdaParser::_tokenSet_80_data_[] = { 52455472UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14521
14522
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_80(_tokenSet_80_data_,10);
14523 const
unsigned long AdaParser::_tokenSet_81_data_[] = { 1048576UL, 402653440UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14524
14525
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_81(_tokenSet_81_data_,10);
14526 const
unsigned long AdaParser::_tokenSet_82_data_[] = { 1048640UL, 402653184UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14527
14528
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_82(_tokenSet_82_data_,10);
14529 const
unsigned long AdaParser::_tokenSet_83_data_[] = { 0UL, 1073807360UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14530
14531
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_83(_tokenSet_83_data_,10);
14532 const
unsigned long AdaParser::_tokenSet_84_data_[] = { 52453424UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14533
14534
14535
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_84(_tokenSet_84_data_,10);
14536 const
unsigned long AdaParser::_tokenSet_85_data_[] = { 52453424UL, 1611254912UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14537
14538
14539
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_85(_tokenSet_85_data_,10);
14540 const
unsigned long AdaParser::_tokenSet_86_data_[] = { 50331664UL, 81920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14541
14542
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_86(_tokenSet_86_data_,10);
14543 const
unsigned long AdaParser::_tokenSet_87_data_[] = { 0UL, 68222976UL, 24UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14544
14545
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_87(_tokenSet_87_data_,10);
14546 const
unsigned long AdaParser::_tokenSet_88_data_[] = { 37056UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14547
14548
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_88(_tokenSet_88_data_,10);
14549 const
unsigned long AdaParser::_tokenSet_89_data_[] = { 48UL, 3323036192UL, 1814398UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14550
14551
14552
14553
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_89(_tokenSet_89_data_,10);
14554 const
unsigned long AdaParser::_tokenSet_90_data_[] = { 32UL, 1107329568UL, 1683298UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14555
14556
14557
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_90(_tokenSet_90_data_,10);
14558 const
unsigned long AdaParser::_tokenSet_91_data_[] = { 67145952UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14559
14560
14561
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_91(_tokenSet_91_data_,10);
14562 const
unsigned long AdaParser::_tokenSet_92_data_[] = { 0UL, 67108864UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14563
14564
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_92(_tokenSet_92_data_,10);
14565 const
unsigned long AdaParser::_tokenSet_93_data_[] = { 67109088UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14566
14567
14568
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_93(_tokenSet_93_data_,10);
14569 const
unsigned long AdaParser::_tokenSet_94_data_[] = { 37056UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14570
14571
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_94(_tokenSet_94_data_,10);
14572 const
unsigned long AdaParser::_tokenSet_95_data_[] = { 96UL, 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14573
14574
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_95(_tokenSet_95_data_,10);
14575 const
unsigned long AdaParser::_tokenSet_96_data_[] = { 0UL, 1073774592UL, 352UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14576
14577
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_96(_tokenSet_96_data_,10);
14578 const
unsigned long AdaParser::_tokenSet_97_data_[] = { 0UL, 65536UL, 24UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14579
14580
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_97(_tokenSet_97_data_,10);
14581 const
unsigned long AdaParser::_tokenSet_98_data_[] = { 0UL, 65536UL, 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14582
14583
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_98(_tokenSet_98_data_,10);
14584 const
unsigned long AdaParser::_tokenSet_99_data_[] = { 8389696UL, 0UL, 36UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14585
14586
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_99(_tokenSet_99_data_,10);
14587 const
unsigned long AdaParser::_tokenSet_100_data_[] = { 0UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14588
14589
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_100(_tokenSet_100_data_,10);
14590 const
unsigned long AdaParser::_tokenSet_101_data_[] = { 0UL, 1073741824UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14591
14592
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_101(_tokenSet_101_data_,10);
14593 const
unsigned long AdaParser::_tokenSet_102_data_[] = { 64UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14594
14595
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_102(_tokenSet_102_data_,10);
14596 const
unsigned long AdaParser::_tokenSet_103_data_[] = { 0UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14597
14598
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_103(_tokenSet_103_data_,10);
14599 const
unsigned long AdaParser::_tokenSet_104_data_[] = { 128UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14600
14601
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_104(_tokenSet_104_data_,10);
14602 const
unsigned long AdaParser::_tokenSet_105_data_[] = { 48UL, 3254813216UL, 1814390UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14603
14604
14605
14606
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_105(_tokenSet_105_data_,10);
14607 const
unsigned long AdaParser::_tokenSet_106_data_[] = { 192UL, 0UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14608
14609
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_106(_tokenSet_106_data_,10);
14610 const
unsigned long AdaParser::_tokenSet_107_data_[] = { 0UL, 0UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14611
14612
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_107(_tokenSet_107_data_,10);
14613 const
unsigned long AdaParser::_tokenSet_108_data_[] = { 0UL, 0UL, 131088UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14614
14615
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_108(_tokenSet_108_data_,10);
14616 const
unsigned long AdaParser::_tokenSet_109_data_[] = { 0UL, 65536UL, 131088UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14617
14618
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_109(_tokenSet_109_data_,10);
14619 const
unsigned long AdaParser::_tokenSet_110_data_[] = { 0UL, 65536UL, 131092UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14620
14621
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_110(_tokenSet_110_data_,10);
14622 const
unsigned long AdaParser::_tokenSet_111_data_[] = { 0UL, 0UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14623
14624
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_111(_tokenSet_111_data_,10);
14625 const
unsigned long AdaParser::_tokenSet_112_data_[] = { 134217760UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14626
14627
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_112(_tokenSet_112_data_,10);
14628 const
unsigned long AdaParser::_tokenSet_113_data_[] = { 813895490UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14629
14630
14631
14632
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_113(_tokenSet_113_data_,10);
14633 const
unsigned long AdaParser::_tokenSet_114_data_[] = { 813932352UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14634
14635
14636
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_114(_tokenSet_114_data_,10);
14637 const
unsigned long AdaParser::_tokenSet_115_data_[] = { 813895488UL, 8193UL, 4293001252UL, 1UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14638
14639
14640
14641
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_115(_tokenSet_115_data_,10);
14642 const
unsigned long AdaParser::_tokenSet_116_data_[] = { 813895488UL, 270337UL, 4293001252UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14643
14644
14645
14646
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_116(_tokenSet_116_data_,10);
14647 const
unsigned long AdaParser::_tokenSet_117_data_[] = { 813895488UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14648
14649
14650
14651
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaParser::_tokenSet_117(_tokenSet_117_data_,10);
14652
14653