00001
00002
#include "AdaTreeParserSuper.hpp"
00003
#include <antlr/Token.hpp>
00004
#include <antlr/AST.hpp>
00005
#include <antlr/NoViableAltException.hpp>
00006
#include <antlr/MismatchedTokenException.hpp>
00007
#include <antlr/SemanticException.hpp>
00008
#include <antlr/BitSet.hpp>
00009
#line 1 "ada.tree.g"
00010
#line 11 "AdaTreeParserSuper.cpp"
00011 AdaTreeParserSuper::AdaTreeParserSuper()
00012 :
ANTLR_USE_NAMESPACE(antlr)
TreeParser() {
00013 }
00014
00015 void AdaTreeParserSuper::compilation_unit(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00016
ANTLR_USE_NAMESPACE(antlr)
RefAST compilation_unit_AST_in = _t;
00017
00018
try {
00019
context_items_opt(_t);
00020 _t = _retTree;
00021 {
00022
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00023 _t = ASTNULL;
00024
switch ( _t->getType()) {
00025
case LIBRARY_ITEM:
00026 {
00027
library_item(_t);
00028 _t = _retTree;
00029
break;
00030 }
00031
case SUBUNIT:
00032 {
00033
subunit(_t);
00034 _t = _retTree;
00035
break;
00036 }
00037
default:
00038 {
00039
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00040 }
00041 }
00042 }
00043 {
00044
for (;;) {
00045
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00046 _t = ASTNULL;
00047
if ((_t->getType() == PRAGMA)) {
00048
pragma(_t);
00049 _t = _retTree;
00050 }
00051
else {
00052
goto _loop4;
00053 }
00054
00055 }
00056 _loop4:;
00057 }
00058 }
00059
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00060 reportError(ex);
00061
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00062 _t = _t->getNextSibling();
00063 }
00064 _retTree = _t;
00065 }
00066
00067 void AdaTreeParserSuper::context_items_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00068
ANTLR_USE_NAMESPACE(antlr)
RefAST context_items_opt_AST_in = _t;
00069
00070
try {
00071
ANTLR_USE_NAMESPACE(antlr)
RefAST __t12 = _t;
00072
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp1_AST_in = _t;
00073 match(_t,CONTEXT_CLAUSE);
00074 _t = _t->getFirstChild();
00075 {
00076
for (;;) {
00077
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00078 _t = ASTNULL;
00079
switch ( _t->getType()) {
00080
case PRAGMA:
00081 {
00082
pragma(_t);
00083 _t = _retTree;
00084
break;
00085 }
00086
case WITH_CLAUSE:
00087 {
00088
with_clause(_t);
00089 _t = _retTree;
00090
break;
00091 }
00092
case USE_CLAUSE:
00093
case USE_TYPE_CLAUSE:
00094 {
00095
use_clause(_t);
00096 _t = _retTree;
00097
break;
00098 }
00099
default:
00100 {
00101
goto _loop14;
00102 }
00103 }
00104 }
00105 _loop14:;
00106 }
00107 _t = __t12;
00108 _t = _t->getNextSibling();
00109 }
00110
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00111 reportError(ex);
00112
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00113 _t = _t->getNextSibling();
00114 }
00115 _retTree = _t;
00116 }
00117
00118 void AdaTreeParserSuper::library_item(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00119
ANTLR_USE_NAMESPACE(antlr)
RefAST library_item_AST_in = _t;
00120
00121
try {
00122
ANTLR_USE_NAMESPACE(antlr)
RefAST __t32 = _t;
00123
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp2_AST_in = _t;
00124 match(_t,LIBRARY_ITEM);
00125 _t = _t->getFirstChild();
00126
modifiers(_t);
00127 _t = _retTree;
00128 {
00129
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00130 _t = ASTNULL;
00131
switch ( _t->getType()) {
00132
case ABSTRACT_FUNCTION_DECLARATION:
00133
case ABSTRACT_PROCEDURE_DECLARATION:
00134
case FUNCTION_BODY:
00135
case FUNCTION_BODY_STUB:
00136
case FUNCTION_DECLARATION:
00137
case FUNCTION_RENAMING_DECLARATION:
00138
case GENERIC_FUNCTION_INSTANTIATION:
00139
case GENERIC_PROCEDURE_INSTANTIATION:
00140
case PROCEDURE_BODY:
00141
case PROCEDURE_BODY_STUB:
00142
case PROCEDURE_DECLARATION:
00143
case PROCEDURE_RENAMING_DECLARATION:
00144 {
00145
subprog_decl_or_rename_or_inst_or_body(_t);
00146 _t = _retTree;
00147
break;
00148 }
00149
case PACKAGE_BODY:
00150 {
00151
ANTLR_USE_NAMESPACE(antlr)
RefAST __t34 = _t;
00152
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp3_AST_in = _t;
00153 match(_t,PACKAGE_BODY);
00154 _t = _t->getFirstChild();
00155
def_id(_t);
00156 _t = _retTree;
00157
pkg_body_part(_t);
00158 _t = _retTree;
00159 _t = __t34;
00160 _t = _t->getNextSibling();
00161
break;
00162 }
00163
case GENERIC_PACKAGE_INSTANTIATION:
00164 {
00165
ANTLR_USE_NAMESPACE(antlr)
RefAST __t35 = _t;
00166
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp4_AST_in = _t;
00167 match(_t,GENERIC_PACKAGE_INSTANTIATION);
00168 _t = _t->getFirstChild();
00169
def_id(_t);
00170 _t = _retTree;
00171
generic_inst(_t);
00172 _t = _retTree;
00173 _t = __t35;
00174 _t = _t->getNextSibling();
00175
break;
00176 }
00177
case PACKAGE_SPECIFICATION:
00178 {
00179
ANTLR_USE_NAMESPACE(antlr)
RefAST __t36 = _t;
00180
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp5_AST_in = _t;
00181 match(_t,PACKAGE_SPECIFICATION);
00182 _t = _t->getFirstChild();
00183
def_id(_t);
00184 _t = _retTree;
00185
pkg_spec_part(_t);
00186 _t = _retTree;
00187 _t = __t36;
00188 _t = _t->getNextSibling();
00189
break;
00190 }
00191
case PACKAGE_RENAMING_DECLARATION:
00192 {
00193
ANTLR_USE_NAMESPACE(antlr)
RefAST __t37 = _t;
00194
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp6_AST_in = _t;
00195 match(_t,PACKAGE_RENAMING_DECLARATION);
00196 _t = _t->getFirstChild();
00197
def_id(_t);
00198 _t = _retTree;
00199
renames(_t);
00200 _t = _retTree;
00201 _t = __t37;
00202 _t = _t->getNextSibling();
00203
break;
00204 }
00205
case GENERIC_PACKAGE_DECLARATION:
00206
case GENERIC_FUNCTION_DECLARATION:
00207
case GENERIC_FUNCTION_RENAMING:
00208
case GENERIC_PACKAGE_RENAMING:
00209
case GENERIC_PROCEDURE_DECLARATION:
00210
case GENERIC_PROCEDURE_RENAMING:
00211 {
00212
generic_decl(_t);
00213 _t = _retTree;
00214
break;
00215 }
00216
default:
00217 {
00218
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00219 }
00220 }
00221 }
00222 _t = __t32;
00223 _t = _t->getNextSibling();
00224 }
00225
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00226 reportError(ex);
00227
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00228 _t = _t->getNextSibling();
00229 }
00230 _retTree = _t;
00231 }
00232
00233 void AdaTreeParserSuper::subunit(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00234
ANTLR_USE_NAMESPACE(antlr)
RefAST subunit_AST_in = _t;
00235
00236
try {
00237
ANTLR_USE_NAMESPACE(antlr)
RefAST __t501 = _t;
00238
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp7_AST_in = _t;
00239 match(_t,SUBUNIT);
00240 _t = _t->getFirstChild();
00241
compound_name(_t);
00242 _t = _retTree;
00243 {
00244
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00245 _t = ASTNULL;
00246
switch ( _t->getType()) {
00247
case FUNCTION_BODY:
00248
case PROCEDURE_BODY:
00249 {
00250
subprogram_body(_t);
00251 _t = _retTree;
00252
break;
00253 }
00254
case PACKAGE_BODY:
00255 {
00256
package_body(_t);
00257 _t = _retTree;
00258
break;
00259 }
00260
case TASK_BODY:
00261 {
00262
task_body(_t);
00263 _t = _retTree;
00264
break;
00265 }
00266
case PROTECTED_BODY:
00267 {
00268
protected_body(_t);
00269 _t = _retTree;
00270
break;
00271 }
00272
default:
00273 {
00274
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00275 }
00276 }
00277 }
00278 _t = __t501;
00279 _t = _t->getNextSibling();
00280 }
00281
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00282 reportError(ex);
00283
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00284 _t = _t->getNextSibling();
00285 }
00286 _retTree = _t;
00287 }
00288
00289 void AdaTreeParserSuper::pragma(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00290
ANTLR_USE_NAMESPACE(antlr)
RefAST pragma_AST_in = _t;
00291
00292
try {
00293
ANTLR_USE_NAMESPACE(antlr)
RefAST __t6 = _t;
00294
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp8_AST_in = _t;
00295 match(_t,PRAGMA);
00296 _t = _t->getFirstChild();
00297
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp9_AST_in = _t;
00298 match(_t,IDENTIFIER);
00299 _t = _t->getNextSibling();
00300 {
00301
for (;;) {
00302
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00303 _t = ASTNULL;
00304
if ((
_tokenSet_0.member(_t->getType()))) {
00305
pragma_arg(_t);
00306 _t = _retTree;
00307 }
00308
else {
00309
goto _loop8;
00310 }
00311
00312 }
00313 _loop8:;
00314 }
00315 _t = __t6;
00316 _t = _t->getNextSibling();
00317 }
00318
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00319 reportError(ex);
00320
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00321 _t = _t->getNextSibling();
00322 }
00323 _retTree = _t;
00324 }
00325
00326 void AdaTreeParserSuper::pragma_arg(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00327
ANTLR_USE_NAMESPACE(antlr)
RefAST pragma_arg_AST_in = _t;
00328
00329
try {
00330
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00331 _t = ASTNULL;
00332
switch ( _t->getType()) {
00333
case RIGHT_SHAFT:
00334 {
00335
ANTLR_USE_NAMESPACE(antlr)
RefAST __t10 = _t;
00336
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp10_AST_in = _t;
00337 match(_t,RIGHT_SHAFT);
00338 _t = _t->getFirstChild();
00339
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp11_AST_in = _t;
00340 match(_t,IDENTIFIER);
00341 _t = _t->getNextSibling();
00342
expression(_t);
00343 _t = _retTree;
00344 _t = __t10;
00345 _t = _t->getNextSibling();
00346
break;
00347 }
00348
case IDENTIFIER:
00349
case DOT:
00350
case TIC:
00351
case IN:
00352
case CHARACTER_LITERAL:
00353
case CHAR_STRING:
00354
case NuLL:
00355
case MOD:
00356
case OR:
00357
case AND:
00358
case XOR:
00359
case NOT:
00360
case EQ:
00361
case NE:
00362
case LT_:
00363
case LE:
00364
case GT:
00365
case GE:
00366
case PLUS:
00367
case MINUS:
00368
case CONCAT:
00369
case STAR:
00370
case DIV:
00371
case REM:
00372
case ABS:
00373
case EXPON:
00374
case NUMERIC_LIT:
00375
case ALLOCATOR:
00376
case INDEXED_COMPONENT:
00377
case OPERATOR_SYMBOL:
00378
case AND_THEN:
00379
case NOT_IN:
00380
case OR_ELSE:
00381
case PARENTHESIZED_PRIMARY:
00382
case UNARY_MINUS:
00383
case UNARY_PLUS:
00384 {
00385
expression(_t);
00386 _t = _retTree;
00387
break;
00388 }
00389
default:
00390 {
00391
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00392 }
00393 }
00394 }
00395
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00396 reportError(ex);
00397
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00398 _t = _t->getNextSibling();
00399 }
00400 _retTree = _t;
00401 }
00402
00403 void AdaTreeParserSuper::expression(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00404
ANTLR_USE_NAMESPACE(antlr)
RefAST expression_AST_in = _t;
00405
00406
try {
00407
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00408 _t = ASTNULL;
00409
switch ( _t->getType()) {
00410
case AND:
00411 {
00412
ANTLR_USE_NAMESPACE(antlr)
RefAST __t459 = _t;
00413
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp12_AST_in = _t;
00414 match(_t,AND);
00415 _t = _t->getFirstChild();
00416
expression(_t);
00417 _t = _retTree;
00418
relation(_t);
00419 _t = _retTree;
00420 _t = __t459;
00421 _t = _t->getNextSibling();
00422
break;
00423 }
00424
case AND_THEN:
00425 {
00426
ANTLR_USE_NAMESPACE(antlr)
RefAST __t460 = _t;
00427
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp13_AST_in = _t;
00428 match(_t,AND_THEN);
00429 _t = _t->getFirstChild();
00430
expression(_t);
00431 _t = _retTree;
00432
relation(_t);
00433 _t = _retTree;
00434 _t = __t460;
00435 _t = _t->getNextSibling();
00436
break;
00437 }
00438
case OR:
00439 {
00440
ANTLR_USE_NAMESPACE(antlr)
RefAST __t461 = _t;
00441
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp14_AST_in = _t;
00442 match(_t,OR);
00443 _t = _t->getFirstChild();
00444
expression(_t);
00445 _t = _retTree;
00446
relation(_t);
00447 _t = _retTree;
00448 _t = __t461;
00449 _t = _t->getNextSibling();
00450
break;
00451 }
00452
case OR_ELSE:
00453 {
00454
ANTLR_USE_NAMESPACE(antlr)
RefAST __t462 = _t;
00455
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp15_AST_in = _t;
00456 match(_t,OR_ELSE);
00457 _t = _t->getFirstChild();
00458
expression(_t);
00459 _t = _retTree;
00460
relation(_t);
00461 _t = _retTree;
00462 _t = __t462;
00463 _t = _t->getNextSibling();
00464
break;
00465 }
00466
case XOR:
00467 {
00468
ANTLR_USE_NAMESPACE(antlr)
RefAST __t463 = _t;
00469
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp16_AST_in = _t;
00470 match(_t,XOR);
00471 _t = _t->getFirstChild();
00472
expression(_t);
00473 _t = _retTree;
00474
relation(_t);
00475 _t = _retTree;
00476 _t = __t463;
00477 _t = _t->getNextSibling();
00478
break;
00479 }
00480
case IDENTIFIER:
00481
case DOT:
00482
case TIC:
00483
case IN:
00484
case CHARACTER_LITERAL:
00485
case CHAR_STRING:
00486
case NuLL:
00487
case MOD:
00488
case NOT:
00489
case EQ:
00490
case NE:
00491
case LT_:
00492
case LE:
00493
case GT:
00494
case GE:
00495
case PLUS:
00496
case MINUS:
00497
case CONCAT:
00498
case STAR:
00499
case DIV:
00500
case REM:
00501
case ABS:
00502
case EXPON:
00503
case NUMERIC_LIT:
00504
case ALLOCATOR:
00505
case INDEXED_COMPONENT:
00506
case OPERATOR_SYMBOL:
00507
case NOT_IN:
00508
case PARENTHESIZED_PRIMARY:
00509
case UNARY_MINUS:
00510
case UNARY_PLUS:
00511 {
00512
relation(_t);
00513 _t = _retTree;
00514
break;
00515 }
00516
default:
00517 {
00518
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00519 }
00520 }
00521 }
00522
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00523 reportError(ex);
00524
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00525 _t = _t->getNextSibling();
00526 }
00527 _retTree = _t;
00528 }
00529
00530 void AdaTreeParserSuper::with_clause(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00531
ANTLR_USE_NAMESPACE(antlr)
RefAST with_clause_AST_in = _t;
00532
00533
try {
00534
ANTLR_USE_NAMESPACE(antlr)
RefAST __t16 = _t;
00535
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp17_AST_in = _t;
00536 match(_t,WITH_CLAUSE);
00537 _t = _t->getFirstChild();
00538 {
00539
int _cnt18=0;
00540
for (;;) {
00541
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00542 _t = ASTNULL;
00543
if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) {
00544
compound_name(_t);
00545 _t = _retTree;
00546 }
00547
else {
00548
if ( _cnt18>=1 ) {
goto _loop18; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
00549 }
00550
00551 _cnt18++;
00552 }
00553 _loop18:;
00554 }
00555 _t = __t16;
00556 _t = _t->getNextSibling();
00557 }
00558
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00559 reportError(ex);
00560
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00561 _t = _t->getNextSibling();
00562 }
00563 _retTree = _t;
00564 }
00565
00566 void AdaTreeParserSuper::use_clause(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00567
ANTLR_USE_NAMESPACE(antlr)
RefAST use_clause_AST_in = _t;
00568
00569
try {
00570
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00571 _t = ASTNULL;
00572
switch ( _t->getType()) {
00573
case USE_TYPE_CLAUSE:
00574 {
00575
ANTLR_USE_NAMESPACE(antlr)
RefAST __t22 = _t;
00576
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp18_AST_in = _t;
00577 match(_t,USE_TYPE_CLAUSE);
00578 _t = _t->getFirstChild();
00579 {
00580
int _cnt24=0;
00581
for (;;) {
00582
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00583 _t = ASTNULL;
00584
if ((_t->getType() == IDENTIFIER || _t->getType() == DOT || _t->getType() == TIC)) {
00585
subtype_mark(_t);
00586 _t = _retTree;
00587 }
00588
else {
00589
if ( _cnt24>=1 ) {
goto _loop24; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
00590 }
00591
00592 _cnt24++;
00593 }
00594 _loop24:;
00595 }
00596 _t = __t22;
00597 _t = _t->getNextSibling();
00598
break;
00599 }
00600
case USE_CLAUSE:
00601 {
00602
ANTLR_USE_NAMESPACE(antlr)
RefAST __t25 = _t;
00603
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp19_AST_in = _t;
00604 match(_t,USE_CLAUSE);
00605 _t = _t->getFirstChild();
00606 {
00607
int _cnt27=0;
00608
for (;;) {
00609
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00610 _t = ASTNULL;
00611
if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) {
00612
compound_name(_t);
00613 _t = _retTree;
00614 }
00615
else {
00616
if ( _cnt27>=1 ) {
goto _loop27; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
00617 }
00618
00619 _cnt27++;
00620 }
00621 _loop27:;
00622 }
00623 _t = __t25;
00624 _t = _t->getNextSibling();
00625
break;
00626 }
00627
default:
00628 {
00629
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00630 }
00631 }
00632 }
00633
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00634 reportError(ex);
00635
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00636 _t = _t->getNextSibling();
00637 }
00638 _retTree = _t;
00639 }
00640
00641 void AdaTreeParserSuper::compound_name(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00642
ANTLR_USE_NAMESPACE(antlr)
RefAST compound_name_AST_in = _t;
00643
00644
try {
00645
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00646 _t = ASTNULL;
00647
switch ( _t->getType()) {
00648
case IDENTIFIER:
00649 {
00650
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp20_AST_in = _t;
00651 match(_t,IDENTIFIER);
00652 _t = _t->getNextSibling();
00653
break;
00654 }
00655
case DOT:
00656 {
00657
ANTLR_USE_NAMESPACE(antlr)
RefAST __t20 = _t;
00658
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp21_AST_in = _t;
00659 match(_t,DOT);
00660 _t = _t->getFirstChild();
00661
compound_name(_t);
00662 _t = _retTree;
00663
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp22_AST_in = _t;
00664 match(_t,IDENTIFIER);
00665 _t = _t->getNextSibling();
00666 _t = __t20;
00667 _t = _t->getNextSibling();
00668
break;
00669 }
00670
default:
00671 {
00672
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00673 }
00674 }
00675 }
00676
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00677 reportError(ex);
00678
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00679 _t = _t->getNextSibling();
00680 }
00681 _retTree = _t;
00682 }
00683
00684 void AdaTreeParserSuper::subtype_mark(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00685
ANTLR_USE_NAMESPACE(antlr)
RefAST subtype_mark_AST_in = _t;
00686
00687
try {
00688
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00689 _t = ASTNULL;
00690
switch ( _t->getType()) {
00691
case IDENTIFIER:
00692
case DOT:
00693 {
00694
compound_name(_t);
00695 _t = _retTree;
00696
break;
00697 }
00698
case TIC:
00699 {
00700
ANTLR_USE_NAMESPACE(antlr)
RefAST __t29 = _t;
00701
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp23_AST_in = _t;
00702 match(_t,TIC);
00703 _t = _t->getFirstChild();
00704
compound_name(_t);
00705 _t = _retTree;
00706
attribute_id(_t);
00707 _t = _retTree;
00708 _t = __t29;
00709 _t = _t->getNextSibling();
00710
break;
00711 }
00712
default:
00713 {
00714
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00715 }
00716 }
00717 }
00718
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00719 reportError(ex);
00720
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00721 _t = _t->getNextSibling();
00722 }
00723 _retTree = _t;
00724 }
00725
00726 void AdaTreeParserSuper::attribute_id(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00727
ANTLR_USE_NAMESPACE(antlr)
RefAST attribute_id_AST_in = _t;
00728
00729
try {
00730
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00731 _t = ASTNULL;
00732
switch ( _t->getType()) {
00733
case RANGE:
00734 {
00735
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp24_AST_in = _t;
00736 match(_t,RANGE);
00737 _t = _t->getNextSibling();
00738
break;
00739 }
00740
case DIGITS:
00741 {
00742
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp25_AST_in = _t;
00743 match(_t,DIGITS);
00744 _t = _t->getNextSibling();
00745
break;
00746 }
00747
case DELTA:
00748 {
00749
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp26_AST_in = _t;
00750 match(_t,DELTA);
00751 _t = _t->getNextSibling();
00752
break;
00753 }
00754
case ACCESS:
00755 {
00756
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp27_AST_in = _t;
00757 match(_t,ACCESS);
00758 _t = _t->getNextSibling();
00759
break;
00760 }
00761
case IDENTIFIER:
00762 {
00763
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp28_AST_in = _t;
00764 match(_t,IDENTIFIER);
00765 _t = _t->getNextSibling();
00766
break;
00767 }
00768
default:
00769 {
00770
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00771 }
00772 }
00773 }
00774
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00775 reportError(ex);
00776
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00777 _t = _t->getNextSibling();
00778 }
00779 _retTree = _t;
00780 }
00781
00782 void AdaTreeParserSuper::modifiers(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00783
ANTLR_USE_NAMESPACE(antlr)
RefAST modifiers_AST_in = _t;
00784
00785
try {
00786
ANTLR_USE_NAMESPACE(antlr)
RefAST __t39 = _t;
00787
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp29_AST_in = _t;
00788 match(_t,MODIFIERS);
00789 _t = _t->getFirstChild();
00790 {
00791
for (;;) {
00792
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00793 _t = ASTNULL;
00794
switch ( _t->getType()) {
00795
case ABSTRACT:
00796 {
00797
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp30_AST_in = _t;
00798 match(_t,ABSTRACT);
00799 _t = _t->getNextSibling();
00800
break;
00801 }
00802
case ACCESS:
00803 {
00804
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp31_AST_in = _t;
00805 match(_t,ACCESS);
00806 _t = _t->getNextSibling();
00807
break;
00808 }
00809
case ALIASED:
00810 {
00811
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp32_AST_in = _t;
00812 match(_t,ALIASED);
00813 _t = _t->getNextSibling();
00814
break;
00815 }
00816
case ALL:
00817 {
00818
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp33_AST_in = _t;
00819 match(_t,ALL);
00820 _t = _t->getNextSibling();
00821
break;
00822 }
00823
case CONSTANT:
00824 {
00825
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp34_AST_in = _t;
00826 match(_t,CONSTANT);
00827 _t = _t->getNextSibling();
00828
break;
00829 }
00830
case IN:
00831 {
00832
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp35_AST_in = _t;
00833 match(_t,IN);
00834 _t = _t->getNextSibling();
00835
break;
00836 }
00837
case LIMITED:
00838 {
00839
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp36_AST_in = _t;
00840 match(_t,LIMITED);
00841 _t = _t->getNextSibling();
00842
break;
00843 }
00844
case OUT:
00845 {
00846
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp37_AST_in = _t;
00847 match(_t,OUT);
00848 _t = _t->getNextSibling();
00849
break;
00850 }
00851
case PRIVATE:
00852 {
00853
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp38_AST_in = _t;
00854 match(_t,PRIVATE);
00855 _t = _t->getNextSibling();
00856
break;
00857 }
00858
case PROTECTED:
00859 {
00860
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp39_AST_in = _t;
00861 match(_t,PROTECTED);
00862 _t = _t->getNextSibling();
00863
break;
00864 }
00865
case REVERSE:
00866 {
00867
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp40_AST_in = _t;
00868 match(_t,REVERSE);
00869 _t = _t->getNextSibling();
00870
break;
00871 }
00872
case TAGGED:
00873 {
00874
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp41_AST_in = _t;
00875 match(_t,TAGGED);
00876 _t = _t->getNextSibling();
00877
break;
00878 }
00879
default:
00880 {
00881
goto _loop41;
00882 }
00883 }
00884 }
00885 _loop41:;
00886 }
00887 _t = __t39;
00888 _t = _t->getNextSibling();
00889 }
00890
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00891 reportError(ex);
00892
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00893 _t = _t->getNextSibling();
00894 }
00895 _retTree = _t;
00896 }
00897
00898 void AdaTreeParserSuper::subprog_decl_or_rename_or_inst_or_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00899
ANTLR_USE_NAMESPACE(antlr)
RefAST subprog_decl_or_rename_or_inst_or_body_AST_in = _t;
00900
00901
try {
00902
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00903 _t = ASTNULL;
00904
switch ( _t->getType()) {
00905
case ABSTRACT_FUNCTION_DECLARATION:
00906
case ABSTRACT_PROCEDURE_DECLARATION:
00907
case FUNCTION_BODY_STUB:
00908
case FUNCTION_DECLARATION:
00909
case FUNCTION_RENAMING_DECLARATION:
00910
case GENERIC_FUNCTION_INSTANTIATION:
00911
case GENERIC_PROCEDURE_INSTANTIATION:
00912
case PROCEDURE_BODY_STUB:
00913
case PROCEDURE_DECLARATION:
00914
case PROCEDURE_RENAMING_DECLARATION:
00915 {
00916
subprog_decl(_t);
00917 _t = _retTree;
00918
break;
00919 }
00920
case PROCEDURE_BODY:
00921 {
00922
procedure_body(_t);
00923 _t = _retTree;
00924
break;
00925 }
00926
case FUNCTION_BODY:
00927 {
00928
function_body(_t);
00929 _t = _retTree;
00930
break;
00931 }
00932
default:
00933 {
00934
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
00935 }
00936 }
00937 }
00938
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00939 reportError(ex);
00940
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00941 _t = _t->getNextSibling();
00942 }
00943 _retTree = _t;
00944 }
00945
00946 void AdaTreeParserSuper::def_id(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00947
ANTLR_USE_NAMESPACE(antlr)
RefAST def_id_AST_in = _t;
00948
00949
try {
00950
compound_name(_t);
00951 _t = _retTree;
00952 }
00953
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00954 reportError(ex);
00955
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00956 _t = _t->getNextSibling();
00957 }
00958 _retTree = _t;
00959 }
00960
00961 void AdaTreeParserSuper::pkg_body_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00962
ANTLR_USE_NAMESPACE(antlr)
RefAST pkg_body_part_AST_in = _t;
00963
00964
try {
00965
declarative_part(_t);
00966 _t = _retTree;
00967
block_body_opt(_t);
00968 _t = _retTree;
00969 }
00970
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
00971 reportError(ex);
00972
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00973 _t = _t->getNextSibling();
00974 }
00975 _retTree = _t;
00976 }
00977
00978 void AdaTreeParserSuper::generic_inst(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
00979
ANTLR_USE_NAMESPACE(antlr)
RefAST generic_inst_AST_in = _t;
00980
00981
try {
00982
compound_name(_t);
00983 _t = _retTree;
00984 {
00985
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
00986 _t = ASTNULL;
00987
switch ( _t->getType()) {
00988
case VALUES:
00989 {
00990
value_s(_t);
00991 _t = _retTree;
00992
break;
00993 }
00994
case 3:
00995 {
00996
break;
00997 }
00998
default:
00999 {
01000
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01001 }
01002 }
01003 }
01004 }
01005
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01006 reportError(ex);
01007
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01008 _t = _t->getNextSibling();
01009 }
01010 _retTree = _t;
01011 }
01012
01013 void AdaTreeParserSuper::pkg_spec_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01014
ANTLR_USE_NAMESPACE(antlr)
RefAST pkg_spec_part_AST_in = _t;
01015
01016
try {
01017
basic_declarative_items_opt(_t);
01018 _t = _retTree;
01019 {
01020
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01021 _t = ASTNULL;
01022
switch ( _t->getType()) {
01023
case BASIC_DECLARATIVE_ITEMS_OPT:
01024 {
01025
basic_declarative_items_opt(_t);
01026 _t = _retTree;
01027
break;
01028 }
01029
case 3:
01030 {
01031
break;
01032 }
01033
default:
01034 {
01035
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01036 }
01037 }
01038 }
01039 }
01040
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01041 reportError(ex);
01042
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01043 _t = _t->getNextSibling();
01044 }
01045 _retTree = _t;
01046 }
01047
01048 void AdaTreeParserSuper::renames(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01049
ANTLR_USE_NAMESPACE(antlr)
RefAST renames_AST_in = _t;
01050
01051
try {
01052
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01053 _t = ASTNULL;
01054
switch ( _t->getType()) {
01055
case CHARACTER_STRING:
01056 {
01057
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp42_AST_in = _t;
01058 match(_t,CHARACTER_STRING);
01059 _t = _t->getNextSibling();
01060
break;
01061 }
01062
case OPERATOR_SYMBOL:
01063 {
01064
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp43_AST_in = _t;
01065 match(_t,OPERATOR_SYMBOL);
01066 _t = _t->getNextSibling();
01067
break;
01068 }
01069
case IDENTIFIER:
01070
case DOT:
01071
case TIC:
01072
case INDEXED_COMPONENT:
01073 {
01074
name(_t);
01075 _t = _retTree;
01076
break;
01077 }
01078
default:
01079 {
01080
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01081 }
01082 }
01083 }
01084
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01085 reportError(ex);
01086
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01087 _t = _t->getNextSibling();
01088 }
01089 _retTree = _t;
01090 }
01091
01092 void AdaTreeParserSuper::generic_decl(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01093
ANTLR_USE_NAMESPACE(antlr)
RefAST generic_decl_AST_in = _t;
01094
01095
try {
01096
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01097 _t = ASTNULL;
01098
switch ( _t->getType()) {
01099
case GENERIC_PACKAGE_RENAMING:
01100 {
01101
ANTLR_USE_NAMESPACE(antlr)
RefAST __t266 = _t;
01102
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp44_AST_in = _t;
01103 match(_t,GENERIC_PACKAGE_RENAMING);
01104 _t = _t->getFirstChild();
01105
generic_formal_part_opt(_t);
01106 _t = _retTree;
01107
def_id(_t);
01108 _t = _retTree;
01109
renames(_t);
01110 _t = _retTree;
01111 _t = __t266;
01112 _t = _t->getNextSibling();
01113
break;
01114 }
01115
case GENERIC_PACKAGE_DECLARATION:
01116 {
01117
ANTLR_USE_NAMESPACE(antlr)
RefAST __t267 = _t;
01118
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp45_AST_in = _t;
01119 match(_t,GENERIC_PACKAGE_DECLARATION);
01120 _t = _t->getFirstChild();
01121
generic_formal_part_opt(_t);
01122 _t = _retTree;
01123
def_id(_t);
01124 _t = _retTree;
01125
pkg_spec_part(_t);
01126 _t = _retTree;
01127 _t = __t267;
01128 _t = _t->getNextSibling();
01129
break;
01130 }
01131
case GENERIC_PROCEDURE_RENAMING:
01132 {
01133
ANTLR_USE_NAMESPACE(antlr)
RefAST __t268 = _t;
01134
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp46_AST_in = _t;
01135 match(_t,GENERIC_PROCEDURE_RENAMING);
01136 _t = _t->getFirstChild();
01137
generic_formal_part_opt(_t);
01138 _t = _retTree;
01139
def_id(_t);
01140 _t = _retTree;
01141
formal_part_opt(_t);
01142 _t = _retTree;
01143
renames(_t);
01144 _t = _retTree;
01145 _t = __t268;
01146 _t = _t->getNextSibling();
01147
break;
01148 }
01149
case GENERIC_PROCEDURE_DECLARATION:
01150 {
01151
ANTLR_USE_NAMESPACE(antlr)
RefAST __t269 = _t;
01152
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp47_AST_in = _t;
01153 match(_t,GENERIC_PROCEDURE_DECLARATION);
01154 _t = _t->getFirstChild();
01155
generic_formal_part_opt(_t);
01156 _t = _retTree;
01157
def_id(_t);
01158 _t = _retTree;
01159
formal_part_opt(_t);
01160 _t = _retTree;
01161 _t = __t269;
01162 _t = _t->getNextSibling();
01163
break;
01164 }
01165
case GENERIC_FUNCTION_RENAMING:
01166 {
01167
ANTLR_USE_NAMESPACE(antlr)
RefAST __t270 = _t;
01168
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp48_AST_in = _t;
01169 match(_t,GENERIC_FUNCTION_RENAMING);
01170 _t = _t->getFirstChild();
01171
generic_formal_part_opt(_t);
01172 _t = _retTree;
01173
def_designator(_t);
01174 _t = _retTree;
01175
function_tail(_t);
01176 _t = _retTree;
01177
renames(_t);
01178 _t = _retTree;
01179 _t = __t270;
01180 _t = _t->getNextSibling();
01181
break;
01182 }
01183
case GENERIC_FUNCTION_DECLARATION:
01184 {
01185
ANTLR_USE_NAMESPACE(antlr)
RefAST __t271 = _t;
01186
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp49_AST_in = _t;
01187 match(_t,GENERIC_FUNCTION_DECLARATION);
01188 _t = _t->getFirstChild();
01189
generic_formal_part_opt(_t);
01190 _t = _retTree;
01191
def_id(_t);
01192 _t = _retTree;
01193
function_tail(_t);
01194 _t = _retTree;
01195 _t = __t271;
01196 _t = _t->getNextSibling();
01197
break;
01198 }
01199
default:
01200 {
01201
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01202 }
01203 }
01204 }
01205
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01206 reportError(ex);
01207
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01208 _t = _t->getNextSibling();
01209 }
01210 _retTree = _t;
01211 }
01212
01213 void AdaTreeParserSuper::subprog_decl(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01214
ANTLR_USE_NAMESPACE(antlr)
RefAST subprog_decl_AST_in = _t;
01215
01216
try {
01217
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01218 _t = ASTNULL;
01219
switch ( _t->getType()) {
01220
case GENERIC_PROCEDURE_INSTANTIATION:
01221 {
01222
ANTLR_USE_NAMESPACE(antlr)
RefAST __t43 = _t;
01223
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp50_AST_in = _t;
01224 match(_t,GENERIC_PROCEDURE_INSTANTIATION);
01225 _t = _t->getFirstChild();
01226
def_id(_t);
01227 _t = _retTree;
01228
generic_inst(_t);
01229 _t = _retTree;
01230 _t = __t43;
01231 _t = _t->getNextSibling();
01232
break;
01233 }
01234
case PROCEDURE_RENAMING_DECLARATION:
01235 {
01236
ANTLR_USE_NAMESPACE(antlr)
RefAST __t44 = _t;
01237
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp51_AST_in = _t;
01238 match(_t,PROCEDURE_RENAMING_DECLARATION);
01239 _t = _t->getFirstChild();
01240
def_id(_t);
01241 _t = _retTree;
01242
formal_part_opt(_t);
01243 _t = _retTree;
01244
renames(_t);
01245 _t = _retTree;
01246 _t = __t44;
01247 _t = _t->getNextSibling();
01248
break;
01249 }
01250
case PROCEDURE_DECLARATION:
01251 {
01252
ANTLR_USE_NAMESPACE(antlr)
RefAST __t45 = _t;
01253
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp52_AST_in = _t;
01254 match(_t,PROCEDURE_DECLARATION);
01255 _t = _t->getFirstChild();
01256
def_id(_t);
01257 _t = _retTree;
01258
formal_part_opt(_t);
01259 _t = _retTree;
01260 _t = __t45;
01261 _t = _t->getNextSibling();
01262
break;
01263 }
01264
case PROCEDURE_BODY_STUB:
01265 {
01266
ANTLR_USE_NAMESPACE(antlr)
RefAST __t46 = _t;
01267
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp53_AST_in = _t;
01268 match(_t,PROCEDURE_BODY_STUB);
01269 _t = _t->getFirstChild();
01270
def_id(_t);
01271 _t = _retTree;
01272
formal_part_opt(_t);
01273 _t = _retTree;
01274 _t = __t46;
01275 _t = _t->getNextSibling();
01276
break;
01277 }
01278
case ABSTRACT_PROCEDURE_DECLARATION:
01279 {
01280
ANTLR_USE_NAMESPACE(antlr)
RefAST __t47 = _t;
01281
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp54_AST_in = _t;
01282 match(_t,ABSTRACT_PROCEDURE_DECLARATION);
01283 _t = _t->getFirstChild();
01284
def_id(_t);
01285 _t = _retTree;
01286
formal_part_opt(_t);
01287 _t = _retTree;
01288 _t = __t47;
01289 _t = _t->getNextSibling();
01290
break;
01291 }
01292
case GENERIC_FUNCTION_INSTANTIATION:
01293 {
01294
ANTLR_USE_NAMESPACE(antlr)
RefAST __t48 = _t;
01295
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp55_AST_in = _t;
01296 match(_t,GENERIC_FUNCTION_INSTANTIATION);
01297 _t = _t->getFirstChild();
01298
def_designator(_t);
01299 _t = _retTree;
01300
generic_inst(_t);
01301 _t = _retTree;
01302 _t = __t48;
01303 _t = _t->getNextSibling();
01304
break;
01305 }
01306
case FUNCTION_RENAMING_DECLARATION:
01307 {
01308
ANTLR_USE_NAMESPACE(antlr)
RefAST __t49 = _t;
01309
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp56_AST_in = _t;
01310 match(_t,FUNCTION_RENAMING_DECLARATION);
01311 _t = _t->getFirstChild();
01312
def_designator(_t);
01313 _t = _retTree;
01314
function_tail(_t);
01315 _t = _retTree;
01316
renames(_t);
01317 _t = _retTree;
01318 _t = __t49;
01319 _t = _t->getNextSibling();
01320
break;
01321 }
01322
case FUNCTION_DECLARATION:
01323 {
01324
ANTLR_USE_NAMESPACE(antlr)
RefAST __t50 = _t;
01325
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp57_AST_in = _t;
01326 match(_t,FUNCTION_DECLARATION);
01327 _t = _t->getFirstChild();
01328
def_designator(_t);
01329 _t = _retTree;
01330
function_tail(_t);
01331 _t = _retTree;
01332 _t = __t50;
01333 _t = _t->getNextSibling();
01334
break;
01335 }
01336
case FUNCTION_BODY_STUB:
01337 {
01338
ANTLR_USE_NAMESPACE(antlr)
RefAST __t51 = _t;
01339
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp58_AST_in = _t;
01340 match(_t,FUNCTION_BODY_STUB);
01341 _t = _t->getFirstChild();
01342
def_designator(_t);
01343 _t = _retTree;
01344
function_tail(_t);
01345 _t = _retTree;
01346 _t = __t51;
01347 _t = _t->getNextSibling();
01348
break;
01349 }
01350
case ABSTRACT_FUNCTION_DECLARATION:
01351 {
01352
ANTLR_USE_NAMESPACE(antlr)
RefAST __t52 = _t;
01353
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp59_AST_in = _t;
01354 match(_t,ABSTRACT_FUNCTION_DECLARATION);
01355 _t = _t->getFirstChild();
01356
def_id(_t);
01357 _t = _retTree;
01358
function_tail(_t);
01359 _t = _retTree;
01360 _t = __t52;
01361 _t = _t->getNextSibling();
01362
break;
01363 }
01364
default:
01365 {
01366
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01367 }
01368 }
01369 }
01370
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01371 reportError(ex);
01372
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01373 _t = _t->getNextSibling();
01374 }
01375 _retTree = _t;
01376 }
01377
01378 void AdaTreeParserSuper::formal_part_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01379
ANTLR_USE_NAMESPACE(antlr)
RefAST formal_part_opt_AST_in = _t;
01380
01381
try {
01382
ANTLR_USE_NAMESPACE(antlr)
RefAST __t77 = _t;
01383
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp60_AST_in = _t;
01384 match(_t,FORMAL_PART_OPT);
01385 _t = _t->getFirstChild();
01386 {
01387
for (;;) {
01388
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01389 _t = ASTNULL;
01390
if ((_t->getType() == PARAMETER_SPECIFICATION)) {
01391
parameter_specification(_t);
01392 _t = _retTree;
01393 }
01394
else {
01395
goto _loop79;
01396 }
01397
01398 }
01399 _loop79:;
01400 }
01401 _t = __t77;
01402 _t = _t->getNextSibling();
01403 }
01404
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01405 reportError(ex);
01406
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01407 _t = _t->getNextSibling();
01408 }
01409 _retTree = _t;
01410 }
01411
01412 void AdaTreeParserSuper::def_designator(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01413
ANTLR_USE_NAMESPACE(antlr)
RefAST def_designator_AST_in = _t;
01414
01415
try {
01416
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01417 _t = ASTNULL;
01418
switch ( _t->getType()) {
01419
case IDENTIFIER:
01420
case DOT:
01421 {
01422
compound_name(_t);
01423 _t = _retTree;
01424
break;
01425 }
01426
case OPERATOR_SYMBOL:
01427 {
01428
definable_operator_symbol(_t);
01429 _t = _retTree;
01430
break;
01431 }
01432
default:
01433 {
01434
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01435 }
01436 }
01437 }
01438
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01439 reportError(ex);
01440
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01441 _t = _t->getNextSibling();
01442 }
01443 _retTree = _t;
01444 }
01445
01446 void AdaTreeParserSuper::function_tail(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01447
ANTLR_USE_NAMESPACE(antlr)
RefAST function_tail_AST_in = _t;
01448
01449
try {
01450
formal_part_opt(_t);
01451 _t = _retTree;
01452
subtype_mark(_t);
01453 _t = _retTree;
01454 }
01455
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01456 reportError(ex);
01457
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01458 _t = _t->getNextSibling();
01459 }
01460 _retTree = _t;
01461 }
01462
01463 void AdaTreeParserSuper::value_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01464
ANTLR_USE_NAMESPACE(antlr)
RefAST value_s_AST_in = _t;
01465
01466
try {
01467
ANTLR_USE_NAMESPACE(antlr)
RefAST __t455 = _t;
01468
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp61_AST_in = _t;
01469 match(_t,VALUES);
01470 _t = _t->getFirstChild();
01471 {
01472
int _cnt457=0;
01473
for (;;) {
01474
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01475 _t = ASTNULL;
01476
if ((
_tokenSet_1.member(_t->getType()))) {
01477
value(_t);
01478 _t = _retTree;
01479 }
01480
else {
01481
if ( _cnt457>=1 ) {
goto _loop457; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
01482 }
01483
01484 _cnt457++;
01485 }
01486 _loop457:;
01487 }
01488 _t = __t455;
01489 _t = _t->getNextSibling();
01490 }
01491
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01492 reportError(ex);
01493
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01494 _t = _t->getNextSibling();
01495 }
01496 _retTree = _t;
01497 }
01498
01499 void AdaTreeParserSuper::value(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01500
ANTLR_USE_NAMESPACE(antlr)
RefAST value_AST_in = _t;
01501
01502
try {
01503
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01504 _t = ASTNULL;
01505
switch ( _t->getType()) {
01506
case OTHERS:
01507 {
01508
ANTLR_USE_NAMESPACE(antlr)
RefAST __t57 = _t;
01509
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp62_AST_in = _t;
01510 match(_t,OTHERS);
01511 _t = _t->getFirstChild();
01512
expression(_t);
01513 _t = _retTree;
01514 _t = __t57;
01515 _t = _t->getNextSibling();
01516
break;
01517 }
01518
case RIGHT_SHAFT:
01519 {
01520
ANTLR_USE_NAMESPACE(antlr)
RefAST __t58 = _t;
01521
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp63_AST_in = _t;
01522 match(_t,RIGHT_SHAFT);
01523 _t = _t->getFirstChild();
01524
ranged_expr_s(_t);
01525 _t = _retTree;
01526
expression(_t);
01527 _t = _retTree;
01528 _t = __t58;
01529 _t = _t->getNextSibling();
01530
break;
01531 }
01532
case IDENTIFIER:
01533
case DOT:
01534
case TIC:
01535
case RANGE:
01536
case PIPE:
01537
case DOT_DOT:
01538
case IN:
01539
case CHARACTER_LITERAL:
01540
case CHAR_STRING:
01541
case NuLL:
01542
case MOD:
01543
case OR:
01544
case AND:
01545
case XOR:
01546
case NOT:
01547
case EQ:
01548
case NE:
01549
case LT_:
01550
case LE:
01551
case GT:
01552
case GE:
01553
case PLUS:
01554
case MINUS:
01555
case CONCAT:
01556
case STAR:
01557
case DIV:
01558
case REM:
01559
case ABS:
01560
case EXPON:
01561
case NUMERIC_LIT:
01562
case ALLOCATOR:
01563
case INDEXED_COMPONENT:
01564
case OPERATOR_SYMBOL:
01565
case AND_THEN:
01566
case NOT_IN:
01567
case OR_ELSE:
01568
case PARENTHESIZED_PRIMARY:
01569
case UNARY_MINUS:
01570
case UNARY_PLUS:
01571 {
01572
ranged_expr_s(_t);
01573 _t = _retTree;
01574
break;
01575 }
01576
default:
01577 {
01578
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01579 }
01580 }
01581 }
01582
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01583 reportError(ex);
01584
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01585 _t = _t->getNextSibling();
01586 }
01587 _retTree = _t;
01588 }
01589
01590 void AdaTreeParserSuper::ranged_expr_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01591
ANTLR_USE_NAMESPACE(antlr)
RefAST ranged_expr_s_AST_in = _t;
01592
01593
try {
01594
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01595 _t = ASTNULL;
01596
switch ( _t->getType()) {
01597
case PIPE:
01598 {
01599
ANTLR_USE_NAMESPACE(antlr)
RefAST __t60 = _t;
01600
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp64_AST_in = _t;
01601 match(_t,PIPE);
01602 _t = _t->getFirstChild();
01603
ranged_expr_s(_t);
01604 _t = _retTree;
01605
ranged_expr(_t);
01606 _t = _retTree;
01607 _t = __t60;
01608 _t = _t->getNextSibling();
01609
break;
01610 }
01611
case IDENTIFIER:
01612
case DOT:
01613
case TIC:
01614
case RANGE:
01615
case DOT_DOT:
01616
case IN:
01617
case CHARACTER_LITERAL:
01618
case CHAR_STRING:
01619
case NuLL:
01620
case MOD:
01621
case OR:
01622
case AND:
01623
case XOR:
01624
case NOT:
01625
case EQ:
01626
case NE:
01627
case LT_:
01628
case LE:
01629
case GT:
01630
case GE:
01631
case PLUS:
01632
case MINUS:
01633
case CONCAT:
01634
case STAR:
01635
case DIV:
01636
case REM:
01637
case ABS:
01638
case EXPON:
01639
case NUMERIC_LIT:
01640
case ALLOCATOR:
01641
case INDEXED_COMPONENT:
01642
case OPERATOR_SYMBOL:
01643
case AND_THEN:
01644
case NOT_IN:
01645
case OR_ELSE:
01646
case PARENTHESIZED_PRIMARY:
01647
case UNARY_MINUS:
01648
case UNARY_PLUS:
01649 {
01650
ranged_expr(_t);
01651 _t = _retTree;
01652
break;
01653 }
01654
default:
01655 {
01656
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01657 }
01658 }
01659 }
01660
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01661 reportError(ex);
01662
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01663 _t = _t->getNextSibling();
01664 }
01665 _retTree = _t;
01666 }
01667
01668 void AdaTreeParserSuper::ranged_expr(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01669
ANTLR_USE_NAMESPACE(antlr)
RefAST ranged_expr_AST_in = _t;
01670
01671
try {
01672
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01673 _t = ASTNULL;
01674
switch ( _t->getType()) {
01675
case DOT_DOT:
01676 {
01677
ANTLR_USE_NAMESPACE(antlr)
RefAST __t62 = _t;
01678
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp65_AST_in = _t;
01679 match(_t,DOT_DOT);
01680 _t = _t->getFirstChild();
01681
expression(_t);
01682 _t = _retTree;
01683
simple_expression(_t);
01684 _t = _retTree;
01685 _t = __t62;
01686 _t = _t->getNextSibling();
01687
break;
01688 }
01689
case RANGE:
01690 {
01691
ANTLR_USE_NAMESPACE(antlr)
RefAST __t63 = _t;
01692
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp66_AST_in = _t;
01693 match(_t,RANGE);
01694 _t = _t->getFirstChild();
01695
expression(_t);
01696 _t = _retTree;
01697
range(_t);
01698 _t = _retTree;
01699 _t = __t63;
01700 _t = _t->getNextSibling();
01701
break;
01702 }
01703
case IDENTIFIER:
01704
case DOT:
01705
case TIC:
01706
case IN:
01707
case CHARACTER_LITERAL:
01708
case CHAR_STRING:
01709
case NuLL:
01710
case MOD:
01711
case OR:
01712
case AND:
01713
case XOR:
01714
case NOT:
01715
case EQ:
01716
case NE:
01717
case LT_:
01718
case LE:
01719
case GT:
01720
case GE:
01721
case PLUS:
01722
case MINUS:
01723
case CONCAT:
01724
case STAR:
01725
case DIV:
01726
case REM:
01727
case ABS:
01728
case EXPON:
01729
case NUMERIC_LIT:
01730
case ALLOCATOR:
01731
case INDEXED_COMPONENT:
01732
case OPERATOR_SYMBOL:
01733
case AND_THEN:
01734
case NOT_IN:
01735
case OR_ELSE:
01736
case PARENTHESIZED_PRIMARY:
01737
case UNARY_MINUS:
01738
case UNARY_PLUS:
01739 {
01740
expression(_t);
01741 _t = _retTree;
01742
break;
01743 }
01744
default:
01745 {
01746
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01747 }
01748 }
01749 }
01750
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01751 reportError(ex);
01752
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01753 _t = _t->getNextSibling();
01754 }
01755 _retTree = _t;
01756 }
01757
01758 void AdaTreeParserSuper::simple_expression(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01759
ANTLR_USE_NAMESPACE(antlr)
RefAST simple_expression_AST_in = _t;
01760
01761
try {
01762
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01763 _t = ASTNULL;
01764
switch ( _t->getType()) {
01765
case PLUS:
01766 {
01767
ANTLR_USE_NAMESPACE(antlr)
RefAST __t475 = _t;
01768
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp67_AST_in = _t;
01769 match(_t,PLUS);
01770 _t = _t->getFirstChild();
01771
simple_expression(_t);
01772 _t = _retTree;
01773
signed_term(_t);
01774 _t = _retTree;
01775 _t = __t475;
01776 _t = _t->getNextSibling();
01777
break;
01778 }
01779
case MINUS:
01780 {
01781
ANTLR_USE_NAMESPACE(antlr)
RefAST __t476 = _t;
01782
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp68_AST_in = _t;
01783 match(_t,MINUS);
01784 _t = _t->getFirstChild();
01785
simple_expression(_t);
01786 _t = _retTree;
01787
signed_term(_t);
01788 _t = _retTree;
01789 _t = __t476;
01790 _t = _t->getNextSibling();
01791
break;
01792 }
01793
case CONCAT:
01794 {
01795
ANTLR_USE_NAMESPACE(antlr)
RefAST __t477 = _t;
01796
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp69_AST_in = _t;
01797 match(_t,CONCAT);
01798 _t = _t->getFirstChild();
01799
simple_expression(_t);
01800 _t = _retTree;
01801
signed_term(_t);
01802 _t = _retTree;
01803 _t = __t477;
01804 _t = _t->getNextSibling();
01805
break;
01806 }
01807
case IDENTIFIER:
01808
case DOT:
01809
case TIC:
01810
case CHARACTER_LITERAL:
01811
case CHAR_STRING:
01812
case NuLL:
01813
case MOD:
01814
case NOT:
01815
case STAR:
01816
case DIV:
01817
case REM:
01818
case ABS:
01819
case EXPON:
01820
case NUMERIC_LIT:
01821
case ALLOCATOR:
01822
case INDEXED_COMPONENT:
01823
case OPERATOR_SYMBOL:
01824
case PARENTHESIZED_PRIMARY:
01825
case UNARY_MINUS:
01826
case UNARY_PLUS:
01827 {
01828
signed_term(_t);
01829 _t = _retTree;
01830
break;
01831 }
01832
default:
01833 {
01834
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01835 }
01836 }
01837 }
01838
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01839 reportError(ex);
01840
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01841 _t = _t->getNextSibling();
01842 }
01843 _retTree = _t;
01844 }
01845
01846 void AdaTreeParserSuper::range(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01847
ANTLR_USE_NAMESPACE(antlr)
RefAST range_AST_in = _t;
01848
01849
try {
01850 {
01851
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01852 _t = ASTNULL;
01853
switch ( _t->getType()) {
01854
case DOT_DOT:
01855 {
01856
range_dots(_t);
01857 _t = _retTree;
01858
break;
01859 }
01860
case RANGE_ATTRIBUTE_REFERENCE:
01861 {
01862
range_attrib_ref(_t);
01863 _t = _retTree;
01864
break;
01865 }
01866
default:
01867 {
01868
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01869 }
01870 }
01871 }
01872 }
01873
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01874 reportError(ex);
01875
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01876 _t = _t->getNextSibling();
01877 }
01878 _retTree = _t;
01879 }
01880
01881 void AdaTreeParserSuper::range_constraint(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01882
ANTLR_USE_NAMESPACE(antlr)
RefAST range_constraint_AST_in = _t;
01883
01884
try {
01885
range(_t);
01886 _t = _retTree;
01887 }
01888
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01889 reportError(ex);
01890
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01891 _t = _t->getNextSibling();
01892 }
01893 _retTree = _t;
01894 }
01895
01896 void AdaTreeParserSuper::range_dots(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01897
ANTLR_USE_NAMESPACE(antlr)
RefAST range_dots_AST_in = _t;
01898
01899
try {
01900
ANTLR_USE_NAMESPACE(antlr)
RefAST __t68 = _t;
01901
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp70_AST_in = _t;
01902 match(_t,DOT_DOT);
01903 _t = _t->getFirstChild();
01904
simple_expression(_t);
01905 _t = _retTree;
01906
simple_expression(_t);
01907 _t = _retTree;
01908 _t = __t68;
01909 _t = _t->getNextSibling();
01910 }
01911
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01912 reportError(ex);
01913
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01914 _t = _t->getNextSibling();
01915 }
01916 _retTree = _t;
01917 }
01918
01919 void AdaTreeParserSuper::range_attrib_ref(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01920
ANTLR_USE_NAMESPACE(antlr)
RefAST range_attrib_ref_AST_in = _t;
01921
01922
try {
01923
ANTLR_USE_NAMESPACE(antlr)
RefAST __t70 = _t;
01924
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp71_AST_in = _t;
01925 match(_t,RANGE_ATTRIBUTE_REFERENCE);
01926 _t = _t->getFirstChild();
01927
prefix(_t);
01928 _t = _retTree;
01929 {
01930
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01931 _t = ASTNULL;
01932
switch ( _t->getType()) {
01933
case IDENTIFIER:
01934
case DOT:
01935
case TIC:
01936
case IN:
01937
case CHARACTER_LITERAL:
01938
case CHAR_STRING:
01939
case NuLL:
01940
case MOD:
01941
case OR:
01942
case AND:
01943
case XOR:
01944
case NOT:
01945
case EQ:
01946
case NE:
01947
case LT_:
01948
case LE:
01949
case GT:
01950
case GE:
01951
case PLUS:
01952
case MINUS:
01953
case CONCAT:
01954
case STAR:
01955
case DIV:
01956
case REM:
01957
case ABS:
01958
case EXPON:
01959
case NUMERIC_LIT:
01960
case ALLOCATOR:
01961
case INDEXED_COMPONENT:
01962
case OPERATOR_SYMBOL:
01963
case AND_THEN:
01964
case NOT_IN:
01965
case OR_ELSE:
01966
case PARENTHESIZED_PRIMARY:
01967
case UNARY_MINUS:
01968
case UNARY_PLUS:
01969 {
01970
expression(_t);
01971 _t = _retTree;
01972
break;
01973 }
01974
case 3:
01975 {
01976
break;
01977 }
01978
default:
01979 {
01980
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
01981 }
01982 }
01983 }
01984 _t = __t70;
01985 _t = _t->getNextSibling();
01986 }
01987
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
01988 reportError(ex);
01989
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
01990 _t = _t->getNextSibling();
01991 }
01992 _retTree = _t;
01993 }
01994
01995 void AdaTreeParserSuper::prefix(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
01996
ANTLR_USE_NAMESPACE(antlr)
RefAST prefix_AST_in = _t;
01997
01998
try {
01999
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02000 _t = ASTNULL;
02001
switch ( _t->getType()) {
02002
case IDENTIFIER:
02003 {
02004
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp72_AST_in = _t;
02005 match(_t,IDENTIFIER);
02006 _t = _t->getNextSibling();
02007
break;
02008 }
02009
case DOT:
02010 {
02011
ANTLR_USE_NAMESPACE(antlr)
RefAST __t73 = _t;
02012
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp73_AST_in = _t;
02013 match(_t,DOT);
02014 _t = _t->getFirstChild();
02015
prefix(_t);
02016 _t = _retTree;
02017 {
02018
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02019 _t = ASTNULL;
02020
switch ( _t->getType()) {
02021
case ALL:
02022 {
02023
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp74_AST_in = _t;
02024 match(_t,ALL);
02025 _t = _t->getNextSibling();
02026
break;
02027 }
02028
case IDENTIFIER:
02029 {
02030
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp75_AST_in = _t;
02031 match(_t,IDENTIFIER);
02032 _t = _t->getNextSibling();
02033
break;
02034 }
02035
default:
02036 {
02037
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02038 }
02039 }
02040 }
02041 _t = __t73;
02042 _t = _t->getNextSibling();
02043
break;
02044 }
02045
case INDEXED_COMPONENT:
02046 {
02047
ANTLR_USE_NAMESPACE(antlr)
RefAST __t75 = _t;
02048
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp76_AST_in = _t;
02049 match(_t,INDEXED_COMPONENT);
02050 _t = _t->getFirstChild();
02051
prefix(_t);
02052 _t = _retTree;
02053
value_s(_t);
02054 _t = _retTree;
02055 _t = __t75;
02056 _t = _t->getNextSibling();
02057
break;
02058 }
02059
default:
02060 {
02061
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02062 }
02063 }
02064 }
02065
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02066 reportError(ex);
02067
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02068 _t = _t->getNextSibling();
02069 }
02070 _retTree = _t;
02071 }
02072
02073 void AdaTreeParserSuper::parameter_specification(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02074
ANTLR_USE_NAMESPACE(antlr)
RefAST parameter_specification_AST_in = _t;
02075
02076
try {
02077
ANTLR_USE_NAMESPACE(antlr)
RefAST __t81 = _t;
02078
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp77_AST_in = _t;
02079 match(_t,PARAMETER_SPECIFICATION);
02080 _t = _t->getFirstChild();
02081
defining_identifier_list(_t);
02082 _t = _retTree;
02083
modifiers(_t);
02084 _t = _retTree;
02085
subtype_mark(_t);
02086 _t = _retTree;
02087
init_opt(_t);
02088 _t = _retTree;
02089 _t = __t81;
02090 _t = _t->getNextSibling();
02091 }
02092
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02093 reportError(ex);
02094
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02095 _t = _t->getNextSibling();
02096 }
02097 _retTree = _t;
02098 }
02099
02100 void AdaTreeParserSuper::defining_identifier_list(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02101
ANTLR_USE_NAMESPACE(antlr)
RefAST defining_identifier_list_AST_in = _t;
02102
02103
try {
02104
ANTLR_USE_NAMESPACE(antlr)
RefAST __t83 = _t;
02105
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp78_AST_in = _t;
02106 match(_t,DEFINING_IDENTIFIER_LIST);
02107 _t = _t->getFirstChild();
02108 {
02109
int _cnt85=0;
02110
for (;;) {
02111
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02112 _t = ASTNULL;
02113
if ((_t->getType() == IDENTIFIER)) {
02114
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp79_AST_in = _t;
02115 match(_t,IDENTIFIER);
02116 _t = _t->getNextSibling();
02117 }
02118
else {
02119
if ( _cnt85>=1 ) {
goto _loop85; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
02120 }
02121
02122 _cnt85++;
02123 }
02124 _loop85:;
02125 }
02126 _t = __t83;
02127 _t = _t->getNextSibling();
02128 }
02129
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02130 reportError(ex);
02131
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02132 _t = _t->getNextSibling();
02133 }
02134 _retTree = _t;
02135 }
02136
02137 void AdaTreeParserSuper::init_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02138
ANTLR_USE_NAMESPACE(antlr)
RefAST init_opt_AST_in = _t;
02139
02140
try {
02141
ANTLR_USE_NAMESPACE(antlr)
RefAST __t127 = _t;
02142
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp80_AST_in = _t;
02143 match(_t,INIT_OPT);
02144 _t = _t->getFirstChild();
02145 {
02146
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02147 _t = ASTNULL;
02148
switch ( _t->getType()) {
02149
case IDENTIFIER:
02150
case DOT:
02151
case TIC:
02152
case IN:
02153
case CHARACTER_LITERAL:
02154
case CHAR_STRING:
02155
case NuLL:
02156
case MOD:
02157
case OR:
02158
case AND:
02159
case XOR:
02160
case NOT:
02161
case EQ:
02162
case NE:
02163
case LT_:
02164
case LE:
02165
case GT:
02166
case GE:
02167
case PLUS:
02168
case MINUS:
02169
case CONCAT:
02170
case STAR:
02171
case DIV:
02172
case REM:
02173
case ABS:
02174
case EXPON:
02175
case NUMERIC_LIT:
02176
case ALLOCATOR:
02177
case INDEXED_COMPONENT:
02178
case OPERATOR_SYMBOL:
02179
case AND_THEN:
02180
case NOT_IN:
02181
case OR_ELSE:
02182
case PARENTHESIZED_PRIMARY:
02183
case UNARY_MINUS:
02184
case UNARY_PLUS:
02185 {
02186
expression(_t);
02187 _t = _retTree;
02188
break;
02189 }
02190
case 3:
02191 {
02192
break;
02193 }
02194
default:
02195 {
02196
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02197 }
02198 }
02199 }
02200 _t = __t127;
02201 _t = _t->getNextSibling();
02202 }
02203
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02204 reportError(ex);
02205
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02206 _t = _t->getNextSibling();
02207 }
02208 _retTree = _t;
02209 }
02210
02211 void AdaTreeParserSuper::name(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02212
ANTLR_USE_NAMESPACE(antlr)
RefAST name_AST_in = _t;
02213
02214
try {
02215
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02216 _t = ASTNULL;
02217
switch ( _t->getType()) {
02218
case IDENTIFIER:
02219 {
02220
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp81_AST_in = _t;
02221 match(_t,IDENTIFIER);
02222 _t = _t->getNextSibling();
02223
break;
02224 }
02225
case DOT:
02226 {
02227
ANTLR_USE_NAMESPACE(antlr)
RefAST __t88 = _t;
02228
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp82_AST_in = _t;
02229 match(_t,DOT);
02230 _t = _t->getFirstChild();
02231
name(_t);
02232 _t = _retTree;
02233 {
02234
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02235 _t = ASTNULL;
02236
switch ( _t->getType()) {
02237
case ALL:
02238 {
02239
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp83_AST_in = _t;
02240 match(_t,ALL);
02241 _t = _t->getNextSibling();
02242
break;
02243 }
02244
case IDENTIFIER:
02245 {
02246
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp84_AST_in = _t;
02247 match(_t,IDENTIFIER);
02248 _t = _t->getNextSibling();
02249
break;
02250 }
02251
case CHARACTER_LITERAL:
02252 {
02253
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp85_AST_in = _t;
02254 match(_t,CHARACTER_LITERAL);
02255 _t = _t->getNextSibling();
02256
break;
02257 }
02258
case OPERATOR_SYMBOL:
02259 {
02260
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp86_AST_in = _t;
02261 match(_t,OPERATOR_SYMBOL);
02262 _t = _t->getNextSibling();
02263
break;
02264 }
02265
default:
02266 {
02267
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02268 }
02269 }
02270 }
02271 _t = __t88;
02272 _t = _t->getNextSibling();
02273
break;
02274 }
02275
case INDEXED_COMPONENT:
02276 {
02277
ANTLR_USE_NAMESPACE(antlr)
RefAST __t90 = _t;
02278
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp87_AST_in = _t;
02279 match(_t,INDEXED_COMPONENT);
02280 _t = _t->getFirstChild();
02281
name(_t);
02282 _t = _retTree;
02283
value_s(_t);
02284 _t = _retTree;
02285 _t = __t90;
02286 _t = _t->getNextSibling();
02287
break;
02288 }
02289
case TIC:
02290 {
02291
ANTLR_USE_NAMESPACE(antlr)
RefAST __t91 = _t;
02292
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp88_AST_in = _t;
02293 match(_t,TIC);
02294 _t = _t->getFirstChild();
02295
name(_t);
02296 _t = _retTree;
02297
attribute_id(_t);
02298 _t = _retTree;
02299 _t = __t91;
02300 _t = _t->getNextSibling();
02301
break;
02302 }
02303
default:
02304 {
02305
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02306 }
02307 }
02308 }
02309
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02310 reportError(ex);
02311
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02312 _t = _t->getNextSibling();
02313 }
02314 _retTree = _t;
02315 }
02316
02317 void AdaTreeParserSuper::definable_operator_symbol(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02318
ANTLR_USE_NAMESPACE(antlr)
RefAST definable_operator_symbol_AST_in = _t;
02319
02320
try {
02321
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp89_AST_in = _t;
02322 match(_t,OPERATOR_SYMBOL);
02323 _t = _t->getNextSibling();
02324 }
02325
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02326 reportError(ex);
02327
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02328 _t = _t->getNextSibling();
02329 }
02330 _retTree = _t;
02331 }
02332
02333 void AdaTreeParserSuper::parenthesized_primary(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02334
ANTLR_USE_NAMESPACE(antlr)
RefAST parenthesized_primary_AST_in = _t;
02335
02336
try {
02337
ANTLR_USE_NAMESPACE(antlr)
RefAST __t94 = _t;
02338
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp90_AST_in = _t;
02339 match(_t,PARENTHESIZED_PRIMARY);
02340 _t = _t->getFirstChild();
02341 {
02342
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02343 _t = ASTNULL;
02344
switch ( _t->getType()) {
02345
case NuLL:
02346 {
02347
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp91_AST_in = _t;
02348 match(_t,NuLL);
02349 _t = _t->getNextSibling();
02350
break;
02351 }
02352
case VALUES:
02353 {
02354
value_s(_t);
02355 _t = _retTree;
02356
extension_opt(_t);
02357 _t = _retTree;
02358
break;
02359 }
02360
default:
02361 {
02362
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02363 }
02364 }
02365 }
02366 _t = __t94;
02367 _t = _t->getNextSibling();
02368 }
02369
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02370 reportError(ex);
02371
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02372 _t = _t->getNextSibling();
02373 }
02374 _retTree = _t;
02375 }
02376
02377 void AdaTreeParserSuper::extension_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02378
ANTLR_USE_NAMESPACE(antlr)
RefAST extension_opt_AST_in = _t;
02379
02380
try {
02381
ANTLR_USE_NAMESPACE(antlr)
RefAST __t97 = _t;
02382
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp92_AST_in = _t;
02383 match(_t,EXTENSION_OPT);
02384 _t = _t->getFirstChild();
02385 {
02386
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02387 _t = ASTNULL;
02388
switch ( _t->getType()) {
02389
case NuLL:
02390 {
02391
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp93_AST_in = _t;
02392 match(_t,NuLL);
02393 _t = _t->getNextSibling();
02394
break;
02395 }
02396
case VALUES:
02397 {
02398
value_s(_t);
02399 _t = _retTree;
02400
break;
02401 }
02402
case 3:
02403 {
02404
break;
02405 }
02406
default:
02407 {
02408
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02409 }
02410 }
02411 }
02412 _t = __t97;
02413 _t = _t->getNextSibling();
02414 }
02415
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02416 reportError(ex);
02417
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02418 _t = _t->getNextSibling();
02419 }
02420 _retTree = _t;
02421 }
02422
02423 void AdaTreeParserSuper::spec_decl_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02424
ANTLR_USE_NAMESPACE(antlr)
RefAST spec_decl_part_AST_in = _t;
02425
02426
try {
02427
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02428 _t = ASTNULL;
02429
switch ( _t->getType()) {
02430
case GENERIC_PACKAGE_INSTANTIATION:
02431 {
02432
ANTLR_USE_NAMESPACE(antlr)
RefAST __t102 = _t;
02433
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp94_AST_in = _t;
02434 match(_t,GENERIC_PACKAGE_INSTANTIATION);
02435 _t = _t->getFirstChild();
02436
def_id(_t);
02437 _t = _retTree;
02438
generic_inst(_t);
02439 _t = _retTree;
02440 _t = __t102;
02441 _t = _t->getNextSibling();
02442
break;
02443 }
02444
case PACKAGE_SPECIFICATION:
02445 {
02446
ANTLR_USE_NAMESPACE(antlr)
RefAST __t103 = _t;
02447
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp95_AST_in = _t;
02448 match(_t,PACKAGE_SPECIFICATION);
02449 _t = _t->getFirstChild();
02450
def_id(_t);
02451 _t = _retTree;
02452
pkg_spec_part(_t);
02453 _t = _retTree;
02454 _t = __t103;
02455 _t = _t->getNextSibling();
02456
break;
02457 }
02458
case PACKAGE_RENAMING_DECLARATION:
02459 {
02460
ANTLR_USE_NAMESPACE(antlr)
RefAST __t104 = _t;
02461
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp96_AST_in = _t;
02462 match(_t,PACKAGE_RENAMING_DECLARATION);
02463 _t = _t->getFirstChild();
02464
def_id(_t);
02465 _t = _retTree;
02466
renames(_t);
02467 _t = _retTree;
02468 _t = __t104;
02469 _t = _t->getNextSibling();
02470
break;
02471 }
02472
default:
02473 {
02474
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02475 }
02476 }
02477 }
02478
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02479 reportError(ex);
02480
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02481 _t = _t->getNextSibling();
02482 }
02483 _retTree = _t;
02484 }
02485
02486 void AdaTreeParserSuper::basic_declarative_items_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02487
ANTLR_USE_NAMESPACE(antlr)
RefAST basic_declarative_items_opt_AST_in = _t;
02488
02489
try {
02490
ANTLR_USE_NAMESPACE(antlr)
RefAST __t108 = _t;
02491
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp97_AST_in = _t;
02492 match(_t,BASIC_DECLARATIVE_ITEMS_OPT);
02493 _t = _t->getFirstChild();
02494 {
02495
for (;;) {
02496
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02497 _t = ASTNULL;
02498
if ((
_tokenSet_2.member(_t->getType()))) {
02499
basic_decl_item(_t);
02500 _t = _retTree;
02501 }
02502
else {
02503
goto _loop110;
02504 }
02505
02506 }
02507 _loop110:;
02508 }
02509 _t = __t108;
02510 _t = _t->getNextSibling();
02511 }
02512
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02513 reportError(ex);
02514
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02515 _t = _t->getNextSibling();
02516 }
02517 _retTree = _t;
02518 }
02519
02520 void AdaTreeParserSuper::basic_decl_item(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02521
ANTLR_USE_NAMESPACE(antlr)
RefAST basic_decl_item_AST_in = _t;
02522
02523
try {
02524
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02525 _t = ASTNULL;
02526
switch ( _t->getType()) {
02527
case PACKAGE_RENAMING_DECLARATION:
02528
case PACKAGE_SPECIFICATION:
02529
case GENERIC_PACKAGE_INSTANTIATION:
02530 {
02531
spec_decl_part(_t);
02532 _t = _retTree;
02533
break;
02534 }
02535
case SINGLE_TASK_DECLARATION:
02536
case TASK_TYPE_DECLARATION:
02537 {
02538
task_type_or_single_decl(_t);
02539 _t = _retTree;
02540
break;
02541 }
02542
case PROTECTED_TYPE_DECLARATION:
02543
case SINGLE_PROTECTED_DECLARATION:
02544 {
02545
prot_type_or_single_decl(_t);
02546 _t = _retTree;
02547
break;
02548 }
02549
case ABSTRACT_FUNCTION_DECLARATION:
02550
case ABSTRACT_PROCEDURE_DECLARATION:
02551
case FUNCTION_BODY_STUB:
02552
case FUNCTION_DECLARATION:
02553
case FUNCTION_RENAMING_DECLARATION:
02554
case GENERIC_FUNCTION_INSTANTIATION:
02555
case GENERIC_PROCEDURE_INSTANTIATION:
02556
case PROCEDURE_BODY_STUB:
02557
case PROCEDURE_DECLARATION:
02558
case PROCEDURE_RENAMING_DECLARATION:
02559 {
02560
subprog_decl(_t);
02561 _t = _retTree;
02562
break;
02563 }
02564
case ATTRIBUTE_DEFINITION_CLAUSE:
02565
case AT_CLAUSE:
02566
case ENUMERATION_REPESENTATION_CLAUSE:
02567
case EXCEPTION_DECLARATION:
02568
case EXCEPTION_RENAMING_DECLARATION:
02569
case GENERIC_PACKAGE_DECLARATION:
02570
case INCOMPLETE_TYPE_DECLARATION:
02571
case NUMBER_DECLARATION:
02572
case OBJECT_DECLARATION:
02573
case OBJECT_RENAMING_DECLARATION:
02574
case PRIVATE_EXTENSION_DECLARATION:
02575
case PRIVATE_TYPE_DECLARATION:
02576
case RECORD_REPRESENTATION_CLAUSE:
02577
case SUBTYPE_DECLARATION:
02578
case USE_CLAUSE:
02579
case USE_TYPE_CLAUSE:
02580
case ACCESS_TO_FUNCTION_DECLARATION:
02581
case ACCESS_TO_OBJECT_DECLARATION:
02582
case ACCESS_TO_PROCEDURE_DECLARATION:
02583
case ARRAY_OBJECT_DECLARATION:
02584
case ARRAY_TYPE_DECLARATION:
02585
case DECIMAL_FIXED_POINT_DECLARATION:
02586
case DERIVED_RECORD_EXTENSION:
02587
case ENUMERATION_TYPE_DECLARATION:
02588
case FLOATING_POINT_DECLARATION:
02589
case GENERIC_FUNCTION_DECLARATION:
02590
case GENERIC_FUNCTION_RENAMING:
02591
case GENERIC_PACKAGE_RENAMING:
02592
case GENERIC_PROCEDURE_DECLARATION:
02593
case GENERIC_PROCEDURE_RENAMING:
02594
case MODULAR_TYPE_DECLARATION:
02595
case ORDINARY_DERIVED_TYPE_DECLARATION:
02596
case ORDINARY_FIXED_POINT_DECLARATION:
02597
case RECORD_TYPE_DECLARATION:
02598
case SIGNED_INTEGER_TYPE_DECLARATION:
02599 {
02600
decl_common(_t);
02601 _t = _retTree;
02602
break;
02603 }
02604
default:
02605 {
02606
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02607 }
02608 }
02609 }
02610
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02611 reportError(ex);
02612
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02613 _t = _t->getNextSibling();
02614 }
02615 _retTree = _t;
02616 }
02617
02618 void AdaTreeParserSuper::task_type_or_single_decl(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02619
ANTLR_USE_NAMESPACE(antlr)
RefAST task_type_or_single_decl_AST_in = _t;
02620
02621
try {
02622
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02623 _t = ASTNULL;
02624
switch ( _t->getType()) {
02625
case TASK_TYPE_DECLARATION:
02626 {
02627
ANTLR_USE_NAMESPACE(antlr)
RefAST __t113 = _t;
02628
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp98_AST_in = _t;
02629 match(_t,TASK_TYPE_DECLARATION);
02630 _t = _t->getFirstChild();
02631
def_id(_t);
02632 _t = _retTree;
02633
discrim_part_opt(_t);
02634 _t = _retTree;
02635
task_definition_opt(_t);
02636 _t = _retTree;
02637 _t = __t113;
02638 _t = _t->getNextSibling();
02639
break;
02640 }
02641
case SINGLE_TASK_DECLARATION:
02642 {
02643
ANTLR_USE_NAMESPACE(antlr)
RefAST __t114 = _t;
02644
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp99_AST_in = _t;
02645 match(_t,SINGLE_TASK_DECLARATION);
02646 _t = _t->getFirstChild();
02647
def_id(_t);
02648 _t = _retTree;
02649
task_definition_opt(_t);
02650 _t = _retTree;
02651 _t = __t114;
02652 _t = _t->getNextSibling();
02653
break;
02654 }
02655
default:
02656 {
02657
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02658 }
02659 }
02660 }
02661
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02662 reportError(ex);
02663
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02664 _t = _t->getNextSibling();
02665 }
02666 _retTree = _t;
02667 }
02668
02669 void AdaTreeParserSuper::prot_type_or_single_decl(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02670
ANTLR_USE_NAMESPACE(antlr)
RefAST prot_type_or_single_decl_AST_in = _t;
02671
02672
try {
02673
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02674 _t = ASTNULL;
02675
switch ( _t->getType()) {
02676
case PROTECTED_TYPE_DECLARATION:
02677 {
02678
ANTLR_USE_NAMESPACE(antlr)
RefAST __t155 = _t;
02679
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp100_AST_in = _t;
02680 match(_t,PROTECTED_TYPE_DECLARATION);
02681 _t = _t->getFirstChild();
02682
def_id(_t);
02683 _t = _retTree;
02684
discrim_part_opt(_t);
02685 _t = _retTree;
02686
protected_definition(_t);
02687 _t = _retTree;
02688 _t = __t155;
02689 _t = _t->getNextSibling();
02690
break;
02691 }
02692
case SINGLE_PROTECTED_DECLARATION:
02693 {
02694
ANTLR_USE_NAMESPACE(antlr)
RefAST __t156 = _t;
02695
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp101_AST_in = _t;
02696 match(_t,SINGLE_PROTECTED_DECLARATION);
02697 _t = _t->getFirstChild();
02698
def_id(_t);
02699 _t = _retTree;
02700
protected_definition(_t);
02701 _t = _retTree;
02702 _t = __t156;
02703 _t = _t->getNextSibling();
02704
break;
02705 }
02706
default:
02707 {
02708
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
02709 }
02710 }
02711 }
02712
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
02713 reportError(ex);
02714
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02715 _t = _t->getNextSibling();
02716 }
02717 _retTree = _t;
02718 }
02719
02720 void AdaTreeParserSuper::decl_common(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
02721
ANTLR_USE_NAMESPACE(antlr)
RefAST decl_common_AST_in = _t;
02722
02723
try {
02724
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
02725 _t = ASTNULL;
02726
switch ( _t->getType()) {
02727
case ENUMERATION_TYPE_DECLARATION:
02728 {
02729
ANTLR_USE_NAMESPACE(antlr)
RefAST __t173 = _t;
02730
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp102_AST_in = _t;
02731 match(_t,ENUMERATION_TYPE_DECLARATION);
02732 _t = _t->getFirstChild();
02733
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp103_AST_in = _t;
02734 match(_t,IDENTIFIER);
02735 _t = _t->getNextSibling();
02736
enum_id_s(_t);
02737 _t = _retTree;
02738 _t = __t173;
02739 _t = _t->getNextSibling();
02740
break;
02741 }
02742
case SIGNED_INTEGER_TYPE_DECLARATION:
02743 {
02744
ANTLR_USE_NAMESPACE(antlr)
RefAST __t174 = _t;
02745
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp104_AST_in = _t;
02746 match(_t,SIGNED_INTEGER_TYPE_DECLARATION);
02747 _t = _t->getFirstChild();
02748
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp105_AST_in = _t;
02749 match(_t,IDENTIFIER);
02750 _t = _t->getNextSibling();
02751
range(_t);
02752 _t = _retTree;
02753 _t = __t174;
02754 _t = _t->getNextSibling();
02755
break;
02756 }
02757
case MODULAR_TYPE_DECLARATION:
02758 {
02759
ANTLR_USE_NAMESPACE(antlr)
RefAST __t175 = _t;
02760
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp106_AST_in = _t;
02761 match(_t,MODULAR_TYPE_DECLARATION);
02762 _t = _t->getFirstChild();
02763
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp107_AST_in = _t;
02764 match(_t,IDENTIFIER);
02765 _t = _t->getNextSibling();
02766
expression(_t);
02767 _t = _retTree;
02768 _t = __t175;
02769 _t = _t->getNextSibling();
02770
break;
02771 }
02772
case FLOATING_POINT_DECLARATION:
02773 {
02774
ANTLR_USE_NAMESPACE(antlr)
RefAST __t176 = _t;
02775
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp108_AST_in = _t;
02776 match(_t,FLOATING_POINT_DECLARATION);
02777 _t = _t->getFirstChild();
02778
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp109_AST_in = _t;
02779 match(_t,IDENTIFIER);
02780 _t = _t->getNextSibling();
02781
expression(_t);
02782 _t = _retTree;
02783
range_constraint_opt(_t);
02784 _t = _retTree;
02785 _t = __t176;
02786 _t = _t->getNextSibling();
02787
break;
02788 }
02789
case ORDINARY_FIXED_POINT_DECLARATION:
02790 {
02791
ANTLR_USE_NAMESPACE(antlr)
RefAST __t177 = _t;
02792
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp110_AST_in = _t;
02793 match(_t,ORDINARY_FIXED_POINT_DECLARATION);
02794 _t = _t->getFirstChild();
02795
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp111_AST_in = _t;
02796 match(_t,IDENTIFIER);
02797 _t = _t->getNextSibling();
02798
expression(_t);
02799 _t = _retTree;
02800
range(_t);
02801 _t = _retTree;
02802 _t = __t177;
02803 _t = _t->getNextSibling();
02804
break;
02805 }
02806
case DECIMAL_FIXED_POINT_DECLARATION:
02807 {
02808
ANTLR_USE_NAMESPACE(antlr)
RefAST __t178 = _t;
02809
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp112_AST_in = _t;
02810 match(_t,DECIMAL_FIXED_POINT_DECLARATION);
02811 _t = _t->getFirstChild();
02812
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp113_AST_in = _t;
02813 match(_t,IDENTIFIER);
02814 _t = _t->getNextSibling();
02815
expression(_t);
02816 _t = _retTree;
02817
expression(_t);
02818 _t = _retTree;
02819
range_constraint_opt(_t);
02820 _t = _retTree;
02821 _t = __t178;
02822 _t = _t->getNextSibling();
02823
break;
02824 }
02825
case ARRAY_TYPE_DECLARATION:
02826 {
02827
array_type_declaration(_t);
02828 _t = _retTree;
02829
break;
02830 }
02831
case ACCESS_TO_FUNCTION_DECLARATION:
02832
case ACCESS_TO_OBJECT_DECLARATION:
02833
case ACCESS_TO_PROCEDURE_DECLARATION:
02834 {
02835
access_type_declaration(_t);
02836 _t = _retTree;
02837
break;
02838 }
02839
case INCOMPLETE_TYPE_DECLARATION:
02840 {
02841
ANTLR_USE_NAMESPACE(antlr)
RefAST __t179 = _t;
02842
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp114_AST_in = _t;
02843 match(_t,INCOMPLETE_TYPE_DECLARATION);
02844 _t = _t->getFirstChild();
02845
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp115_AST_in = _t;
02846 match(_t,IDENTIFIER);
02847 _t = _t->getNextSibling();
02848
discrim_part_opt(_t);
02849 _t = _retTree;
02850 _t = __t179;
02851 _t = _t->getNextSibling();
02852
break;
02853 }
02854
case PRIVATE_EXTENSION_DECLARATION:
02855 {
02856
ANTLR_USE_NAMESPACE(antlr)
RefAST __t180 = _t;
02857
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp116_AST_in = _t;
02858 match(_t,PRIVATE_EXTENSION_DECLARATION);
02859 _t = _t->getFirstChild();
02860
id_and_discrim(_t);
02861 _t = _retTree;
02862
modifiers(_t);
02863 _t = _retTree;
02864
subtype_ind(_t);
02865 _t = _retTree;
02866 _t = __t180;
02867 _t = _t->getNextSibling();
02868
break;
02869 }
02870
case DERIVED_RECORD_EXTENSION:
02871 {
02872
ANTLR_USE_NAMESPACE(antlr)
RefAST __t181 = _t;
02873
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp117_AST_in = _t;
02874 match(_t,DERIVED_RECORD_EXTENSION);
02875 _t = _t->getFirstChild();
02876
id_and_discrim(_t);
02877 _t = _retTree;
02878
modifiers(_t);
02879 _t = _retTree;
02880
subtype_ind(_t);
02881 _t = _retTree;
02882
record_definition(_t);
02883 _t = _retTree;
02884 _t = __t181;
02885 _t = _t->getNextSibling();
02886
break;
02887 }
02888
case ORDINARY_DERIVED_TYPE_DECLARATION:
02889 {
02890
ANTLR_USE_NAMESPACE(antlr)
RefAST __t182 = _t;
02891
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp118_AST_in = _t;
02892 match(_t,ORDINARY_DERIVED_TYPE_DECLARATION);
02893 _t = _t->getFirstChild();
02894
id_and_discrim(_t);
02895 _t = _retTree;
02896
subtype_ind(_t);
02897 _t = _retTree;
02898 _t = __t182;
02899 _t = _t->getNextSibling();
02900
break;
02901 }
02902
case PRIVATE_TYPE_DECLARATION:
02903 {
02904
ANTLR_USE_NAMESPACE(antlr)
RefAST __t183 = _t;
02905
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp119_AST_in = _t;
02906 match(_t,PRIVATE_TYPE_DECLARATION);
02907 _t = _t->getFirstChild();
02908
id_and_discrim(_t);
02909 _t = _retTree;
02910
modifiers(_t);
02911 _t = _retTree;
02912 _t = __t183;
02913 _t = _t->getNextSibling();
02914
break;
02915 }
02916
case RECORD_TYPE_DECLARATION:
02917 {
02918
ANTLR_USE_NAMESPACE(antlr)
RefAST __t184 = _t;
02919
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp120_AST_in = _t;
02920 match(_t,RECORD_TYPE_DECLARATION);
02921 _t = _t->getFirstChild();
02922
id_and_discrim(_t);
02923 _t = _retTree;
02924
modifiers(_t);
02925 _t = _retTree;
02926
record_definition(_t);
02927 _t = _retTree;
02928 _t = __t184;
02929 _t = _t->getNextSibling();
02930
break;
02931 }
02932
case SUBTYPE_DECLARATION:
02933 {
02934
ANTLR_USE_NAMESPACE(antlr)
RefAST __t185 = _t;
02935
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp121_AST_in = _t;
02936 match(_t,SUBTYPE_DECLARATION);
02937 _t = _t->getFirstChild();
02938
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp122_AST_in = _t;
02939 match(_t,IDENTIFIER);
02940 _t = _t->getNextSibling();
02941
subtype_ind(_t);
02942 _t = _retTree;
02943 _t = __t185;
02944 _t = _t->getNextSibling();
02945
break;
02946 }
02947
case GENERIC_PACKAGE_DECLARATION:
02948
case GENERIC_FUNCTION_DECLARATION:
02949
case GENERIC_FUNCTION_RENAMING:
02950
case GENERIC_PACKAGE_RENAMING:
02951
case GENERIC_PROCEDURE_DECLARATION:
02952
case GENERIC_PROCEDURE_RENAMING:
02953 {
02954
generic_decl(_t);
02955 _t = _retTree;
02956
break;
02957 }
02958
case USE_CLAUSE:
02959
case USE_TYPE_CLAUSE:
02960 {
02961
use_clause(_t);
02962 _t = _retTree;
02963
break;
02964 }
02965
case ATTRIBUTE_DEFINITION_CLAUSE:
02966
case AT_CLAUSE:
02967
case ENUMERATION_REPESENTATION_CLAUSE:
02968
case RECORD_REPRESENTATION_CLAUSE:
02969 {
02970
rep_spec(_t);
02971 _t = _retTree;
02972
break;
02973 }
02974
case EXCEPTION_RENAMING_DECLARATION:
02975 {
02976
ANTLR_USE_NAMESPACE(antlr)
RefAST __t186 = _t;
02977
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp123_AST_in = _t;
02978 match(_t,EXCEPTION_RENAMING_DECLARATION);
02979 _t = _t->getFirstChild();
02980
def_id(_t);
02981 _t = _retTree;
02982
compound_name(_t);
02983 _t = _retTree;
02984 _t = __t186;
02985 _t = _t->getNextSibling();
02986
break;
02987 }
02988
case OBJECT_RENAMING_DECLARATION:
02989 {
02990
ANTLR_USE_NAMESPACE(antlr)
RefAST __t187 = _t;
02991
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp124_AST_in = _t;
02992 match(_t,OBJECT_RENAMING_DECLARATION);
02993 _t = _t->getFirstChild();
02994
def_id(_t);
02995 _t = _retTree;
02996
subtype_mark(_t);
02997 _t = _retTree;
02998
name(_t);
02999 _t = _retTree;
03000 _t = __t187;
03001 _t = _t->getNextSibling();
03002
break;
03003 }
03004
case EXCEPTION_DECLARATION:
03005 {
03006
ANTLR_USE_NAMESPACE(antlr)
RefAST __t188 = _t;
03007
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp125_AST_in = _t;
03008 match(_t,EXCEPTION_DECLARATION);
03009 _t = _t->getFirstChild();
03010
defining_identifier_list(_t);
03011 _t = _retTree;
03012 _t = __t188;
03013 _t = _t->getNextSibling();
03014
break;
03015 }
03016
case NUMBER_DECLARATION:
03017 {
03018
ANTLR_USE_NAMESPACE(antlr)
RefAST __t189 = _t;
03019
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp126_AST_in = _t;
03020 match(_t,NUMBER_DECLARATION);
03021 _t = _t->getFirstChild();
03022
defining_identifier_list(_t);
03023 _t = _retTree;
03024
expression(_t);
03025 _t = _retTree;
03026 _t = __t189;
03027 _t = _t->getNextSibling();
03028
break;
03029 }
03030
case ARRAY_OBJECT_DECLARATION:
03031 {
03032
ANTLR_USE_NAMESPACE(antlr)
RefAST __t190 = _t;
03033
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp127_AST_in = _t;
03034 match(_t,ARRAY_OBJECT_DECLARATION);
03035 _t = _t->getFirstChild();
03036
defining_identifier_list(_t);
03037 _t = _retTree;
03038
modifiers(_t);
03039 _t = _retTree;
03040
array_type_definition(_t);
03041 _t = _retTree;
03042
init_opt(_t);
03043 _t = _retTree;
03044 _t = __t190;
03045 _t = _t->getNextSibling();
03046
break;
03047 }
03048
case OBJECT_DECLARATION:
03049 {
03050
ANTLR_USE_NAMESPACE(antlr)
RefAST __t191 = _t;
03051
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp128_AST_in = _t;
03052 match(_t,OBJECT_DECLARATION);
03053 _t = _t->getFirstChild();
03054
defining_identifier_list(_t);
03055 _t = _retTree;
03056
modifiers(_t);
03057 _t = _retTree;
03058
subtype_ind(_t);
03059 _t = _retTree;
03060
init_opt(_t);
03061 _t = _retTree;
03062 _t = __t191;
03063 _t = _t->getNextSibling();
03064
break;
03065 }
03066
default:
03067 {
03068
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03069 }
03070 }
03071 }
03072
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03073 reportError(ex);
03074
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03075 _t = _t->getNextSibling();
03076 }
03077 _retTree = _t;
03078 }
03079
03080 void AdaTreeParserSuper::discrim_part_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03081
ANTLR_USE_NAMESPACE(antlr)
RefAST discrim_part_opt_AST_in = _t;
03082
03083
try {
03084
ANTLR_USE_NAMESPACE(antlr)
RefAST __t118 = _t;
03085
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp129_AST_in = _t;
03086 match(_t,DISCRIM_PART_OPT);
03087 _t = _t->getFirstChild();
03088 {
03089
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03090 _t = ASTNULL;
03091
switch ( _t->getType()) {
03092
case BOX:
03093 {
03094
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp130_AST_in = _t;
03095 match(_t,BOX);
03096 _t = _t->getNextSibling();
03097
break;
03098 }
03099
case DISCRIMINANT_SPECIFICATIONS:
03100 {
03101
discriminant_specifications(_t);
03102 _t = _retTree;
03103
break;
03104 }
03105
case 3:
03106 {
03107
break;
03108 }
03109
default:
03110 {
03111
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03112 }
03113 }
03114 }
03115 _t = __t118;
03116 _t = _t->getNextSibling();
03117 }
03118
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03119 reportError(ex);
03120
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03121 _t = _t->getNextSibling();
03122 }
03123 _retTree = _t;
03124 }
03125
03126 void AdaTreeParserSuper::task_definition_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03127
ANTLR_USE_NAMESPACE(antlr)
RefAST task_definition_opt_AST_in = _t;
03128
03129
try {
03130 {
03131
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03132 _t = ASTNULL;
03133
switch ( _t->getType()) {
03134
case TASK_ITEMS_OPT:
03135 {
03136
task_items_opt(_t);
03137 _t = _retTree;
03138
private_task_items_opt(_t);
03139 _t = _retTree;
03140
break;
03141 }
03142
case 3:
03143 {
03144
break;
03145 }
03146
default:
03147 {
03148
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03149 }
03150 }
03151 }
03152 }
03153
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03154 reportError(ex);
03155
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03156 _t = _t->getNextSibling();
03157 }
03158 _retTree = _t;
03159 }
03160
03161 void AdaTreeParserSuper::task_items_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03162
ANTLR_USE_NAMESPACE(antlr)
RefAST task_items_opt_AST_in = _t;
03163
03164
try {
03165
ANTLR_USE_NAMESPACE(antlr)
RefAST __t130 = _t;
03166
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp131_AST_in = _t;
03167 match(_t,TASK_ITEMS_OPT);
03168 _t = _t->getFirstChild();
03169
entrydecls_repspecs_opt(_t);
03170 _t = _retTree;
03171 _t = __t130;
03172 _t = _t->getNextSibling();
03173 }
03174
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03175 reportError(ex);
03176
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03177 _t = _t->getNextSibling();
03178 }
03179 _retTree = _t;
03180 }
03181
03182 void AdaTreeParserSuper::private_task_items_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03183
ANTLR_USE_NAMESPACE(antlr)
RefAST private_task_items_opt_AST_in = _t;
03184
03185
try {
03186
ANTLR_USE_NAMESPACE(antlr)
RefAST __t153 = _t;
03187
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp132_AST_in = _t;
03188 match(_t,PRIVATE_TASK_ITEMS_OPT);
03189 _t = _t->getFirstChild();
03190
entrydecls_repspecs_opt(_t);
03191 _t = _retTree;
03192 _t = __t153;
03193 _t = _t->getNextSibling();
03194 }
03195
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03196 reportError(ex);
03197
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03198 _t = _t->getNextSibling();
03199 }
03200 _retTree = _t;
03201 }
03202
03203 void AdaTreeParserSuper::discriminant_specifications(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03204
ANTLR_USE_NAMESPACE(antlr)
RefAST discriminant_specifications_AST_in = _t;
03205
03206
try {
03207
ANTLR_USE_NAMESPACE(antlr)
RefAST __t121 = _t;
03208
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp133_AST_in = _t;
03209 match(_t,DISCRIMINANT_SPECIFICATIONS);
03210 _t = _t->getFirstChild();
03211 {
03212
for (;;) {
03213
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03214 _t = ASTNULL;
03215
if ((_t->getType() == DISCRIMINANT_SPECIFICATION)) {
03216
discriminant_specification(_t);
03217 _t = _retTree;
03218 }
03219
else {
03220
goto _loop123;
03221 }
03222
03223 }
03224 _loop123:;
03225 }
03226 _t = __t121;
03227 _t = _t->getNextSibling();
03228 }
03229
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03230 reportError(ex);
03231
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03232 _t = _t->getNextSibling();
03233 }
03234 _retTree = _t;
03235 }
03236
03237 void AdaTreeParserSuper::discriminant_specification(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03238
ANTLR_USE_NAMESPACE(antlr)
RefAST discriminant_specification_AST_in = _t;
03239
03240
try {
03241
ANTLR_USE_NAMESPACE(antlr)
RefAST __t125 = _t;
03242
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp134_AST_in = _t;
03243 match(_t,DISCRIMINANT_SPECIFICATION);
03244 _t = _t->getFirstChild();
03245
defining_identifier_list(_t);
03246 _t = _retTree;
03247
modifiers(_t);
03248 _t = _retTree;
03249
subtype_mark(_t);
03250 _t = _retTree;
03251
init_opt(_t);
03252 _t = _retTree;
03253 _t = __t125;
03254 _t = _t->getNextSibling();
03255 }
03256
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03257 reportError(ex);
03258
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03259 _t = _t->getNextSibling();
03260 }
03261 _retTree = _t;
03262 }
03263
03264 void AdaTreeParserSuper::entrydecls_repspecs_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03265
ANTLR_USE_NAMESPACE(antlr)
RefAST entrydecls_repspecs_opt_AST_in = _t;
03266
03267
try {
03268 {
03269
for (;;) {
03270
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03271 _t = ASTNULL;
03272
switch ( _t->getType()) {
03273
case ENTRY_DECLARATION:
03274 {
03275
entry_declaration(_t);
03276 _t = _retTree;
03277
break;
03278 }
03279
case PRAGMA:
03280 {
03281
pragma(_t);
03282 _t = _retTree;
03283
break;
03284 }
03285
case ATTRIBUTE_DEFINITION_CLAUSE:
03286
case AT_CLAUSE:
03287
case ENUMERATION_REPESENTATION_CLAUSE:
03288
case RECORD_REPRESENTATION_CLAUSE:
03289 {
03290
rep_spec(_t);
03291 _t = _retTree;
03292
break;
03293 }
03294
default:
03295 {
03296
goto _loop133;
03297 }
03298 }
03299 }
03300 _loop133:;
03301 }
03302 }
03303
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03304 reportError(ex);
03305
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03306 _t = _t->getNextSibling();
03307 }
03308 _retTree = _t;
03309 }
03310
03311 void AdaTreeParserSuper::entry_declaration(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03312
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_declaration_AST_in = _t;
03313
03314
try {
03315
ANTLR_USE_NAMESPACE(antlr)
RefAST __t135 = _t;
03316
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp135_AST_in = _t;
03317 match(_t,ENTRY_DECLARATION);
03318 _t = _t->getFirstChild();
03319
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp136_AST_in = _t;
03320 match(_t,IDENTIFIER);
03321 _t = _t->getNextSibling();
03322
discrete_subtype_def_opt(_t);
03323 _t = _retTree;
03324
formal_part_opt(_t);
03325 _t = _retTree;
03326 _t = __t135;
03327 _t = _t->getNextSibling();
03328 }
03329
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03330 reportError(ex);
03331
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03332 _t = _t->getNextSibling();
03333 }
03334 _retTree = _t;
03335 }
03336
03337 void AdaTreeParserSuper::rep_spec(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03338
ANTLR_USE_NAMESPACE(antlr)
RefAST rep_spec_AST_in = _t;
03339
03340
try {
03341
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03342 _t = ASTNULL;
03343
switch ( _t->getType()) {
03344
case RECORD_REPRESENTATION_CLAUSE:
03345 {
03346
ANTLR_USE_NAMESPACE(antlr)
RefAST __t141 = _t;
03347
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp137_AST_in = _t;
03348 match(_t,RECORD_REPRESENTATION_CLAUSE);
03349 _t = _t->getFirstChild();
03350
subtype_mark(_t);
03351 _t = _retTree;
03352
align_opt(_t);
03353 _t = _retTree;
03354
comp_loc_s(_t);
03355 _t = _retTree;
03356 _t = __t141;
03357 _t = _t->getNextSibling();
03358
break;
03359 }
03360
case AT_CLAUSE:
03361 {
03362
ANTLR_USE_NAMESPACE(antlr)
RefAST __t142 = _t;
03363
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp138_AST_in = _t;
03364 match(_t,AT_CLAUSE);
03365 _t = _t->getFirstChild();
03366
subtype_mark(_t);
03367 _t = _retTree;
03368
expression(_t);
03369 _t = _retTree;
03370 _t = __t142;
03371 _t = _t->getNextSibling();
03372
break;
03373 }
03374
case ATTRIBUTE_DEFINITION_CLAUSE:
03375 {
03376
ANTLR_USE_NAMESPACE(antlr)
RefAST __t143 = _t;
03377
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp139_AST_in = _t;
03378 match(_t,ATTRIBUTE_DEFINITION_CLAUSE);
03379 _t = _t->getFirstChild();
03380
subtype_mark(_t);
03381 _t = _retTree;
03382
expression(_t);
03383 _t = _retTree;
03384 _t = __t143;
03385 _t = _t->getNextSibling();
03386
break;
03387 }
03388
case ENUMERATION_REPESENTATION_CLAUSE:
03389 {
03390
ANTLR_USE_NAMESPACE(antlr)
RefAST __t144 = _t;
03391
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp140_AST_in = _t;
03392 match(_t,ENUMERATION_REPESENTATION_CLAUSE);
03393 _t = _t->getFirstChild();
03394
local_enum_name(_t);
03395 _t = _retTree;
03396
enumeration_aggregate(_t);
03397 _t = _retTree;
03398 _t = __t144;
03399 _t = _t->getNextSibling();
03400
break;
03401 }
03402
default:
03403 {
03404
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03405 }
03406 }
03407 }
03408
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03409 reportError(ex);
03410
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03411 _t = _t->getNextSibling();
03412 }
03413 _retTree = _t;
03414 }
03415
03416 void AdaTreeParserSuper::discrete_subtype_def_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03417
ANTLR_USE_NAMESPACE(antlr)
RefAST discrete_subtype_def_opt_AST_in = _t;
03418
03419
try {
03420
ANTLR_USE_NAMESPACE(antlr)
RefAST __t137 = _t;
03421
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp141_AST_in = _t;
03422 match(_t,DISCRETE_SUBTYPE_DEF_OPT);
03423 _t = _t->getFirstChild();
03424 {
03425
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03426 _t = ASTNULL;
03427
switch ( _t->getType()) {
03428
case DOT_DOT:
03429
case RANGE_ATTRIBUTE_REFERENCE:
03430
case SUBTYPE_INDICATION:
03431 {
03432
discrete_subtype_definition(_t);
03433 _t = _retTree;
03434
break;
03435 }
03436
case 3:
03437 {
03438
break;
03439 }
03440
default:
03441 {
03442
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03443 }
03444 }
03445 }
03446 _t = __t137;
03447 _t = _t->getNextSibling();
03448 }
03449
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03450 reportError(ex);
03451
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03452 _t = _t->getNextSibling();
03453 }
03454 _retTree = _t;
03455 }
03456
03457 void AdaTreeParserSuper::discrete_subtype_definition(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03458
ANTLR_USE_NAMESPACE(antlr)
RefAST discrete_subtype_definition_AST_in = _t;
03459
03460
try {
03461
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03462 _t = ASTNULL;
03463
switch ( _t->getType()) {
03464
case DOT_DOT:
03465
case RANGE_ATTRIBUTE_REFERENCE:
03466 {
03467
range(_t);
03468 _t = _retTree;
03469
break;
03470 }
03471
case SUBTYPE_INDICATION:
03472 {
03473
subtype_ind(_t);
03474 _t = _retTree;
03475
break;
03476 }
03477
default:
03478 {
03479
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03480 }
03481 }
03482 }
03483
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03484 reportError(ex);
03485
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03486 _t = _t->getNextSibling();
03487 }
03488 _retTree = _t;
03489 }
03490
03491 void AdaTreeParserSuper::subtype_ind(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03492
ANTLR_USE_NAMESPACE(antlr)
RefAST subtype_ind_AST_in = _t;
03493
03494
try {
03495
ANTLR_USE_NAMESPACE(antlr)
RefAST __t210 = _t;
03496
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp142_AST_in = _t;
03497 match(_t,SUBTYPE_INDICATION);
03498 _t = _t->getFirstChild();
03499
subtype_mark(_t);
03500 _t = _retTree;
03501
constraint_opt(_t);
03502 _t = _retTree;
03503 _t = __t210;
03504 _t = _t->getNextSibling();
03505 }
03506
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03507 reportError(ex);
03508
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03509 _t = _t->getNextSibling();
03510 }
03511 _retTree = _t;
03512 }
03513
03514 void AdaTreeParserSuper::align_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03515
ANTLR_USE_NAMESPACE(antlr)
RefAST align_opt_AST_in = _t;
03516
03517
try {
03518
ANTLR_USE_NAMESPACE(antlr)
RefAST __t146 = _t;
03519
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp143_AST_in = _t;
03520 match(_t,MOD_CLAUSE_OPT);
03521 _t = _t->getFirstChild();
03522 {
03523
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03524 _t = ASTNULL;
03525
switch ( _t->getType()) {
03526
case IDENTIFIER:
03527
case DOT:
03528
case TIC:
03529
case IN:
03530
case CHARACTER_LITERAL:
03531
case CHAR_STRING:
03532
case NuLL:
03533
case MOD:
03534
case OR:
03535
case AND:
03536
case XOR:
03537
case NOT:
03538
case EQ:
03539
case NE:
03540
case LT_:
03541
case LE:
03542
case GT:
03543
case GE:
03544
case PLUS:
03545
case MINUS:
03546
case CONCAT:
03547
case STAR:
03548
case DIV:
03549
case REM:
03550
case ABS:
03551
case EXPON:
03552
case NUMERIC_LIT:
03553
case ALLOCATOR:
03554
case INDEXED_COMPONENT:
03555
case OPERATOR_SYMBOL:
03556
case AND_THEN:
03557
case NOT_IN:
03558
case OR_ELSE:
03559
case PARENTHESIZED_PRIMARY:
03560
case UNARY_MINUS:
03561
case UNARY_PLUS:
03562 {
03563
expression(_t);
03564 _t = _retTree;
03565
break;
03566 }
03567
case 3:
03568 {
03569
break;
03570 }
03571
default:
03572 {
03573
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03574 }
03575 }
03576 }
03577 _t = __t146;
03578 _t = _t->getNextSibling();
03579 }
03580
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03581 reportError(ex);
03582
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03583 _t = _t->getNextSibling();
03584 }
03585 _retTree = _t;
03586 }
03587
03588 void AdaTreeParserSuper::comp_loc_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03589
ANTLR_USE_NAMESPACE(antlr)
RefAST comp_loc_s_AST_in = _t;
03590
03591
try {
03592
ANTLR_USE_NAMESPACE(antlr)
RefAST __t149 = _t;
03593
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp144_AST_in = _t;
03594 match(_t,COMPONENT_CLAUSES_OPT);
03595 _t = _t->getFirstChild();
03596 {
03597
for (;;) {
03598
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03599 _t = ASTNULL;
03600
switch ( _t->getType()) {
03601
case PRAGMA:
03602 {
03603
pragma(_t);
03604 _t = _retTree;
03605
break;
03606 }
03607
case IDENTIFIER:
03608
case DOT:
03609
case TIC:
03610 {
03611
subtype_mark(_t);
03612 _t = _retTree;
03613
expression(_t);
03614 _t = _retTree;
03615
range(_t);
03616 _t = _retTree;
03617
break;
03618 }
03619
default:
03620 {
03621
goto _loop151;
03622 }
03623 }
03624 }
03625 _loop151:;
03626 }
03627 _t = __t149;
03628 _t = _t->getNextSibling();
03629 }
03630
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03631 reportError(ex);
03632
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03633 _t = _t->getNextSibling();
03634 }
03635 _retTree = _t;
03636 }
03637
03638 void AdaTreeParserSuper::local_enum_name(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03639
ANTLR_USE_NAMESPACE(antlr)
RefAST local_enum_name_AST_in = _t;
03640
03641
try {
03642
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp145_AST_in = _t;
03643 match(_t,IDENTIFIER);
03644 _t = _t->getNextSibling();
03645 }
03646
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03647 reportError(ex);
03648
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03649 _t = _t->getNextSibling();
03650 }
03651 _retTree = _t;
03652 }
03653
03654 void AdaTreeParserSuper::enumeration_aggregate(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03655
ANTLR_USE_NAMESPACE(antlr)
RefAST enumeration_aggregate_AST_in = _t;
03656
03657
try {
03658 {
03659
for (;;) {
03660
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03661 _t = ASTNULL;
03662
if ((
_tokenSet_1.member(_t->getType()))) {
03663
value(_t);
03664 _t = _retTree;
03665 }
03666
else {
03667
goto _loop264;
03668 }
03669
03670 }
03671 _loop264:;
03672 }
03673 }
03674
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03675 reportError(ex);
03676
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03677 _t = _t->getNextSibling();
03678 }
03679 _retTree = _t;
03680 }
03681
03682 void AdaTreeParserSuper::protected_definition(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03683
ANTLR_USE_NAMESPACE(antlr)
RefAST protected_definition_AST_in = _t;
03684
03685
try {
03686
prot_op_decl_s(_t);
03687 _t = _retTree;
03688 {
03689
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03690 _t = ASTNULL;
03691
switch ( _t->getType()) {
03692
case PROT_MEMBER_DECLARATIONS:
03693 {
03694
prot_member_decl_s(_t);
03695 _t = _retTree;
03696
break;
03697 }
03698
case 3:
03699 {
03700
break;
03701 }
03702
default:
03703 {
03704
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03705 }
03706 }
03707 }
03708 }
03709
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03710 reportError(ex);
03711
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03712 _t = _t->getNextSibling();
03713 }
03714 _retTree = _t;
03715 }
03716
03717 void AdaTreeParserSuper::prot_op_decl_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03718
ANTLR_USE_NAMESPACE(antlr)
RefAST prot_op_decl_s_AST_in = _t;
03719
03720
try {
03721
ANTLR_USE_NAMESPACE(antlr)
RefAST __t160 = _t;
03722
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp146_AST_in = _t;
03723 match(_t,PROT_OP_DECLARATIONS);
03724 _t = _t->getFirstChild();
03725 {
03726
for (;;) {
03727
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03728 _t = ASTNULL;
03729
if ((
_tokenSet_3.member(_t->getType()))) {
03730
prot_op_decl(_t);
03731 _t = _retTree;
03732 }
03733
else {
03734
goto _loop162;
03735 }
03736
03737 }
03738 _loop162:;
03739 }
03740 _t = __t160;
03741 _t = _t->getNextSibling();
03742 }
03743
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03744 reportError(ex);
03745
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03746 _t = _t->getNextSibling();
03747 }
03748 _retTree = _t;
03749 }
03750
03751 void AdaTreeParserSuper::prot_member_decl_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03752
ANTLR_USE_NAMESPACE(antlr)
RefAST prot_member_decl_s_AST_in = _t;
03753
03754
try {
03755
ANTLR_USE_NAMESPACE(antlr)
RefAST __t167 = _t;
03756
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp147_AST_in = _t;
03757 match(_t,PROT_MEMBER_DECLARATIONS);
03758 _t = _t->getFirstChild();
03759 {
03760
for (;;) {
03761
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03762 _t = ASTNULL;
03763
switch ( _t->getType()) {
03764
case PRAGMA:
03765
case ATTRIBUTE_DEFINITION_CLAUSE:
03766
case AT_CLAUSE:
03767
case ENTRY_DECLARATION:
03768
case ENUMERATION_REPESENTATION_CLAUSE:
03769
case RECORD_REPRESENTATION_CLAUSE:
03770
case FUNCTION_DECLARATION:
03771
case PROCEDURE_DECLARATION:
03772 {
03773
prot_op_decl(_t);
03774 _t = _retTree;
03775
break;
03776 }
03777
case COMPONENT_DECLARATION:
03778 {
03779
comp_decl(_t);
03780 _t = _retTree;
03781
break;
03782 }
03783
default:
03784 {
03785
goto _loop169;
03786 }
03787 }
03788 }
03789 _loop169:;
03790 }
03791 _t = __t167;
03792 _t = _t->getNextSibling();
03793 }
03794
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03795 reportError(ex);
03796
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03797 _t = _t->getNextSibling();
03798 }
03799 _retTree = _t;
03800 }
03801
03802 void AdaTreeParserSuper::prot_op_decl(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03803
ANTLR_USE_NAMESPACE(antlr)
RefAST prot_op_decl_AST_in = _t;
03804
03805
try {
03806
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03807 _t = ASTNULL;
03808
switch ( _t->getType()) {
03809
case ENTRY_DECLARATION:
03810 {
03811
entry_declaration(_t);
03812 _t = _retTree;
03813
break;
03814 }
03815
case PROCEDURE_DECLARATION:
03816 {
03817
ANTLR_USE_NAMESPACE(antlr)
RefAST __t164 = _t;
03818
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp148_AST_in = _t;
03819 match(_t,PROCEDURE_DECLARATION);
03820 _t = _t->getFirstChild();
03821
def_id(_t);
03822 _t = _retTree;
03823
formal_part_opt(_t);
03824 _t = _retTree;
03825 _t = __t164;
03826 _t = _t->getNextSibling();
03827
break;
03828 }
03829
case FUNCTION_DECLARATION:
03830 {
03831
ANTLR_USE_NAMESPACE(antlr)
RefAST __t165 = _t;
03832
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp149_AST_in = _t;
03833 match(_t,FUNCTION_DECLARATION);
03834 _t = _t->getFirstChild();
03835
def_designator(_t);
03836 _t = _retTree;
03837
function_tail(_t);
03838 _t = _retTree;
03839 _t = __t165;
03840 _t = _t->getNextSibling();
03841
break;
03842 }
03843
case ATTRIBUTE_DEFINITION_CLAUSE:
03844
case AT_CLAUSE:
03845
case ENUMERATION_REPESENTATION_CLAUSE:
03846
case RECORD_REPRESENTATION_CLAUSE:
03847 {
03848
rep_spec(_t);
03849 _t = _retTree;
03850
break;
03851 }
03852
case PRAGMA:
03853 {
03854
pragma(_t);
03855 _t = _retTree;
03856
break;
03857 }
03858
default:
03859 {
03860
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03861 }
03862 }
03863 }
03864
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03865 reportError(ex);
03866
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03867 _t = _t->getNextSibling();
03868 }
03869 _retTree = _t;
03870 }
03871
03872 void AdaTreeParserSuper::comp_decl(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03873
ANTLR_USE_NAMESPACE(antlr)
RefAST comp_decl_AST_in = _t;
03874
03875
try {
03876
ANTLR_USE_NAMESPACE(antlr)
RefAST __t171 = _t;
03877
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp150_AST_in = _t;
03878 match(_t,COMPONENT_DECLARATION);
03879 _t = _t->getFirstChild();
03880
defining_identifier_list(_t);
03881 _t = _retTree;
03882
component_subtype_def(_t);
03883 _t = _retTree;
03884
init_opt(_t);
03885 _t = _retTree;
03886 _t = __t171;
03887 _t = _t->getNextSibling();
03888 }
03889
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03890 reportError(ex);
03891
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03892 _t = _t->getNextSibling();
03893 }
03894 _retTree = _t;
03895 }
03896
03897 void AdaTreeParserSuper::component_subtype_def(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03898
ANTLR_USE_NAMESPACE(antlr)
RefAST component_subtype_def_AST_in = _t;
03899
03900
try {
03901
modifiers(_t);
03902 _t = _retTree;
03903
subtype_ind(_t);
03904 _t = _retTree;
03905 }
03906
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03907 reportError(ex);
03908
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03909 _t = _t->getNextSibling();
03910 }
03911 _retTree = _t;
03912 }
03913
03914 void AdaTreeParserSuper::enum_id_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03915
ANTLR_USE_NAMESPACE(antlr)
RefAST enum_id_s_AST_in = _t;
03916
03917
try {
03918 {
03919
int _cnt195=0;
03920
for (;;) {
03921
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03922 _t = ASTNULL;
03923
if ((_t->getType() == IDENTIFIER || _t->getType() == CHARACTER_LITERAL)) {
03924
enumeration_literal_specification(_t);
03925 _t = _retTree;
03926 }
03927
else {
03928
if ( _cnt195>=1 ) {
goto _loop195; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
03929 }
03930
03931 _cnt195++;
03932 }
03933 _loop195:;
03934 }
03935 }
03936
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03937 reportError(ex);
03938
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03939 _t = _t->getNextSibling();
03940 }
03941 _retTree = _t;
03942 }
03943
03944 void AdaTreeParserSuper::range_constraint_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03945
ANTLR_USE_NAMESPACE(antlr)
RefAST range_constraint_opt_AST_in = _t;
03946
03947
try {
03948 {
03949
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03950 _t = ASTNULL;
03951
switch ( _t->getType()) {
03952
case DOT_DOT:
03953
case RANGE_ATTRIBUTE_REFERENCE:
03954 {
03955
range_constraint(_t);
03956 _t = _retTree;
03957
break;
03958 }
03959
case 3:
03960 {
03961
break;
03962 }
03963
default:
03964 {
03965
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
03966 }
03967 }
03968 }
03969 }
03970
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03971 reportError(ex);
03972
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03973 _t = _t->getNextSibling();
03974 }
03975 _retTree = _t;
03976 }
03977
03978 void AdaTreeParserSuper::array_type_declaration(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
03979
ANTLR_USE_NAMESPACE(antlr)
RefAST array_type_declaration_AST_in = _t;
03980
03981
try {
03982
ANTLR_USE_NAMESPACE(antlr)
RefAST __t201 = _t;
03983
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp151_AST_in = _t;
03984 match(_t,ARRAY_TYPE_DECLARATION);
03985 _t = _t->getFirstChild();
03986
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp152_AST_in = _t;
03987 match(_t,IDENTIFIER);
03988 _t = _t->getNextSibling();
03989
array_type_definition(_t);
03990 _t = _retTree;
03991 _t = __t201;
03992 _t = _t->getNextSibling();
03993 }
03994
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
03995 reportError(ex);
03996
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
03997 _t = _t->getNextSibling();
03998 }
03999 _retTree = _t;
04000 }
04001
04002 void AdaTreeParserSuper::access_type_declaration(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04003
ANTLR_USE_NAMESPACE(antlr)
RefAST access_type_declaration_AST_in = _t;
04004
04005
try {
04006
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04007 _t = ASTNULL;
04008
switch ( _t->getType()) {
04009
case ACCESS_TO_PROCEDURE_DECLARATION:
04010 {
04011
ANTLR_USE_NAMESPACE(antlr)
RefAST __t234 = _t;
04012
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp153_AST_in = _t;
04013 match(_t,ACCESS_TO_PROCEDURE_DECLARATION);
04014 _t = _t->getFirstChild();
04015
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp154_AST_in = _t;
04016 match(_t,IDENTIFIER);
04017 _t = _t->getNextSibling();
04018
modifiers(_t);
04019 _t = _retTree;
04020
formal_part_opt(_t);
04021 _t = _retTree;
04022 _t = __t234;
04023 _t = _t->getNextSibling();
04024
break;
04025 }
04026
case ACCESS_TO_FUNCTION_DECLARATION:
04027 {
04028
ANTLR_USE_NAMESPACE(antlr)
RefAST __t235 = _t;
04029
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp155_AST_in = _t;
04030 match(_t,ACCESS_TO_FUNCTION_DECLARATION);
04031 _t = _t->getFirstChild();
04032
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp156_AST_in = _t;
04033 match(_t,IDENTIFIER);
04034 _t = _t->getNextSibling();
04035
modifiers(_t);
04036 _t = _retTree;
04037
function_tail(_t);
04038 _t = _retTree;
04039 _t = __t235;
04040 _t = _t->getNextSibling();
04041
break;
04042 }
04043
case ACCESS_TO_OBJECT_DECLARATION:
04044 {
04045
ANTLR_USE_NAMESPACE(antlr)
RefAST __t236 = _t;
04046
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp157_AST_in = _t;
04047 match(_t,ACCESS_TO_OBJECT_DECLARATION);
04048 _t = _t->getFirstChild();
04049
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp158_AST_in = _t;
04050 match(_t,IDENTIFIER);
04051 _t = _t->getNextSibling();
04052
modifiers(_t);
04053 _t = _retTree;
04054
subtype_ind(_t);
04055 _t = _retTree;
04056 _t = __t236;
04057 _t = _t->getNextSibling();
04058
break;
04059 }
04060
default:
04061 {
04062
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04063 }
04064 }
04065 }
04066
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04067 reportError(ex);
04068
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04069 _t = _t->getNextSibling();
04070 }
04071 _retTree = _t;
04072 }
04073
04074 void AdaTreeParserSuper::id_and_discrim(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04075
ANTLR_USE_NAMESPACE(antlr)
RefAST id_and_discrim_AST_in = _t;
04076
04077
try {
04078
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp159_AST_in = _t;
04079 match(_t,IDENTIFIER);
04080 _t = _t->getNextSibling();
04081
discrim_part_opt(_t);
04082 _t = _retTree;
04083 }
04084
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04085 reportError(ex);
04086
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04087 _t = _t->getNextSibling();
04088 }
04089 _retTree = _t;
04090 }
04091
04092 void AdaTreeParserSuper::record_definition(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04093
ANTLR_USE_NAMESPACE(antlr)
RefAST record_definition_AST_in = _t;
04094
04095
try {
04096 {
04097
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04098 _t = ASTNULL;
04099
switch ( _t->getType()) {
04100
case COMPONENT_ITEMS:
04101 {
04102
component_list(_t);
04103 _t = _retTree;
04104
break;
04105 }
04106
case 3:
04107 {
04108
break;
04109 }
04110
default:
04111 {
04112
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04113 }
04114 }
04115 }
04116 }
04117
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04118 reportError(ex);
04119
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04120 _t = _t->getNextSibling();
04121 }
04122 _retTree = _t;
04123 }
04124
04125 void AdaTreeParserSuper::array_type_definition(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04126
ANTLR_USE_NAMESPACE(antlr)
RefAST array_type_definition_AST_in = _t;
04127
04128
try {
04129
index_or_discrete_range_s(_t);
04130 _t = _retTree;
04131
component_subtype_def(_t);
04132 _t = _retTree;
04133 }
04134
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04135 reportError(ex);
04136
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04137 _t = _t->getNextSibling();
04138 }
04139 _retTree = _t;
04140 }
04141
04142 void AdaTreeParserSuper::enumeration_literal_specification(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04143
ANTLR_USE_NAMESPACE(antlr)
RefAST enumeration_literal_specification_AST_in = _t;
04144
04145
try {
04146
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04147 _t = ASTNULL;
04148
switch ( _t->getType()) {
04149
case IDENTIFIER:
04150 {
04151
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp160_AST_in = _t;
04152 match(_t,IDENTIFIER);
04153 _t = _t->getNextSibling();
04154
break;
04155 }
04156
case CHARACTER_LITERAL:
04157 {
04158
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp161_AST_in = _t;
04159 match(_t,CHARACTER_LITERAL);
04160 _t = _t->getNextSibling();
04161
break;
04162 }
04163
default:
04164 {
04165
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04166 }
04167 }
04168 }
04169
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04170 reportError(ex);
04171
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04172 _t = _t->getNextSibling();
04173 }
04174 _retTree = _t;
04175 }
04176
04177 void AdaTreeParserSuper::index_or_discrete_range_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04178
ANTLR_USE_NAMESPACE(antlr)
RefAST index_or_discrete_range_s_AST_in = _t;
04179
04180
try {
04181
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04182 _t = ASTNULL;
04183
switch ( _t->getType()) {
04184
case IDENTIFIER:
04185
case DOT:
04186
case TIC:
04187
case RANGE:
04188
case DOT_DOT:
04189
case CHARACTER_LITERAL:
04190
case CHAR_STRING:
04191
case NuLL:
04192
case MOD:
04193
case NOT:
04194
case PLUS:
04195
case MINUS:
04196
case CONCAT:
04197
case STAR:
04198
case DIV:
04199
case REM:
04200
case ABS:
04201
case EXPON:
04202
case NUMERIC_LIT:
04203
case ALLOCATOR:
04204
case INDEXED_COMPONENT:
04205
case OPERATOR_SYMBOL:
04206
case PARENTHESIZED_PRIMARY:
04207
case UNARY_MINUS:
04208
case UNARY_PLUS:
04209 {
04210
index_or_discrete_range(_t);
04211 _t = _retTree;
04212
break;
04213 }
04214
case COMMA:
04215 {
04216
ANTLR_USE_NAMESPACE(antlr)
RefAST __t203 = _t;
04217
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp162_AST_in = _t;
04218 match(_t,COMMA);
04219 _t = _t->getFirstChild();
04220
index_or_discrete_range_s(_t);
04221 _t = _retTree;
04222
index_or_discrete_range(_t);
04223 _t = _retTree;
04224 _t = __t203;
04225 _t = _t->getNextSibling();
04226
break;
04227 }
04228
default:
04229 {
04230
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04231 }
04232 }
04233 }
04234
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04235 reportError(ex);
04236
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04237 _t = _t->getNextSibling();
04238 }
04239 _retTree = _t;
04240 }
04241
04242 void AdaTreeParserSuper::index_or_discrete_range(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04243
ANTLR_USE_NAMESPACE(antlr)
RefAST index_or_discrete_range_AST_in = _t;
04244
04245
try {
04246
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04247 _t = ASTNULL;
04248
switch ( _t->getType()) {
04249
case DOT_DOT:
04250 {
04251
ANTLR_USE_NAMESPACE(antlr)
RefAST __t205 = _t;
04252
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp163_AST_in = _t;
04253 match(_t,DOT_DOT);
04254 _t = _t->getFirstChild();
04255
simple_expression(_t);
04256 _t = _retTree;
04257
simple_expression(_t);
04258 _t = _retTree;
04259 _t = __t205;
04260 _t = _t->getNextSibling();
04261
break;
04262 }
04263
case RANGE:
04264 {
04265
ANTLR_USE_NAMESPACE(antlr)
RefAST __t206 = _t;
04266
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp164_AST_in = _t;
04267 match(_t,RANGE);
04268 _t = _t->getFirstChild();
04269
simple_expression(_t);
04270 _t = _retTree;
04271 {
04272
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04273 _t = ASTNULL;
04274
switch ( _t->getType()) {
04275
case BOX:
04276 {
04277
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp165_AST_in = _t;
04278 match(_t,BOX);
04279 _t = _t->getNextSibling();
04280
break;
04281 }
04282
case DOT_DOT:
04283
case RANGE_ATTRIBUTE_REFERENCE:
04284 {
04285
range(_t);
04286 _t = _retTree;
04287
break;
04288 }
04289
default:
04290 {
04291
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04292 }
04293 }
04294 }
04295 _t = __t206;
04296 _t = _t->getNextSibling();
04297
break;
04298 }
04299
case IDENTIFIER:
04300
case DOT:
04301
case TIC:
04302
case CHARACTER_LITERAL:
04303
case CHAR_STRING:
04304
case NuLL:
04305
case MOD:
04306
case NOT:
04307
case PLUS:
04308
case MINUS:
04309
case CONCAT:
04310
case STAR:
04311
case DIV:
04312
case REM:
04313
case ABS:
04314
case EXPON:
04315
case NUMERIC_LIT:
04316
case ALLOCATOR:
04317
case INDEXED_COMPONENT:
04318
case OPERATOR_SYMBOL:
04319
case PARENTHESIZED_PRIMARY:
04320
case UNARY_MINUS:
04321
case UNARY_PLUS:
04322 {
04323
simple_expression(_t);
04324 _t = _retTree;
04325
break;
04326 }
04327
default:
04328 {
04329
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04330 }
04331 }
04332 }
04333
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04334 reportError(ex);
04335
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04336 _t = _t->getNextSibling();
04337 }
04338 _retTree = _t;
04339 }
04340
04341 void AdaTreeParserSuper::constraint_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04342
ANTLR_USE_NAMESPACE(antlr)
RefAST constraint_opt_AST_in = _t;
04343
04344
try {
04345 {
04346
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04347 _t = ASTNULL;
04348
switch ( _t->getType()) {
04349
case DOT_DOT:
04350
case RANGE_ATTRIBUTE_REFERENCE:
04351 {
04352
range_constraint(_t);
04353 _t = _retTree;
04354
break;
04355 }
04356
case DIGITS_CONSTRAINT:
04357 {
04358
digits_constraint(_t);
04359 _t = _retTree;
04360
break;
04361 }
04362
case DELTA_CONSTRAINT:
04363 {
04364
delta_constraint(_t);
04365 _t = _retTree;
04366
break;
04367 }
04368
case INDEX_CONSTRAINT:
04369 {
04370
index_constraint(_t);
04371 _t = _retTree;
04372
break;
04373 }
04374
case DISCRIMINANT_CONSTRAINT:
04375 {
04376
discriminant_constraint(_t);
04377 _t = _retTree;
04378
break;
04379 }
04380
case 3:
04381 {
04382
break;
04383 }
04384
default:
04385 {
04386
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04387 }
04388 }
04389 }
04390 }
04391
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04392 reportError(ex);
04393
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04394 _t = _t->getNextSibling();
04395 }
04396 _retTree = _t;
04397 }
04398
04399 void AdaTreeParserSuper::digits_constraint(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04400
ANTLR_USE_NAMESPACE(antlr)
RefAST digits_constraint_AST_in = _t;
04401
04402
try {
04403
ANTLR_USE_NAMESPACE(antlr)
RefAST __t214 = _t;
04404
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp166_AST_in = _t;
04405 match(_t,DIGITS_CONSTRAINT);
04406 _t = _t->getFirstChild();
04407
expression(_t);
04408 _t = _retTree;
04409
range_constraint_opt(_t);
04410 _t = _retTree;
04411 _t = __t214;
04412 _t = _t->getNextSibling();
04413 }
04414
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04415 reportError(ex);
04416
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04417 _t = _t->getNextSibling();
04418 }
04419 _retTree = _t;
04420 }
04421
04422 void AdaTreeParserSuper::delta_constraint(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04423
ANTLR_USE_NAMESPACE(antlr)
RefAST delta_constraint_AST_in = _t;
04424
04425
try {
04426
ANTLR_USE_NAMESPACE(antlr)
RefAST __t216 = _t;
04427
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp167_AST_in = _t;
04428 match(_t,DELTA_CONSTRAINT);
04429 _t = _t->getFirstChild();
04430
expression(_t);
04431 _t = _retTree;
04432
range_constraint_opt(_t);
04433 _t = _retTree;
04434 _t = __t216;
04435 _t = _t->getNextSibling();
04436 }
04437
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04438 reportError(ex);
04439
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04440 _t = _t->getNextSibling();
04441 }
04442 _retTree = _t;
04443 }
04444
04445 void AdaTreeParserSuper::index_constraint(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04446
ANTLR_USE_NAMESPACE(antlr)
RefAST index_constraint_AST_in = _t;
04447
04448
try {
04449
ANTLR_USE_NAMESPACE(antlr)
RefAST __t218 = _t;
04450
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp168_AST_in = _t;
04451 match(_t,INDEX_CONSTRAINT);
04452 _t = _t->getFirstChild();
04453 {
04454
int _cnt220=0;
04455
for (;;) {
04456
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04457 _t = ASTNULL;
04458
if ((_t->getType() == DOT_DOT || _t->getType() == RANGE_ATTRIBUTE_REFERENCE || _t->getType() == SUBTYPE_INDICATION)) {
04459
discrete_range(_t);
04460 _t = _retTree;
04461 }
04462
else {
04463
if ( _cnt220>=1 ) {
goto _loop220; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
04464 }
04465
04466 _cnt220++;
04467 }
04468 _loop220:;
04469 }
04470 _t = __t218;
04471 _t = _t->getNextSibling();
04472 }
04473
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04474 reportError(ex);
04475
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04476 _t = _t->getNextSibling();
04477 }
04478 _retTree = _t;
04479 }
04480
04481 void AdaTreeParserSuper::discriminant_constraint(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04482
ANTLR_USE_NAMESPACE(antlr)
RefAST discriminant_constraint_AST_in = _t;
04483
04484
try {
04485
ANTLR_USE_NAMESPACE(antlr)
RefAST __t223 = _t;
04486
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp169_AST_in = _t;
04487 match(_t,DISCRIMINANT_CONSTRAINT);
04488 _t = _t->getFirstChild();
04489 {
04490
int _cnt225=0;
04491
for (;;) {
04492
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04493 _t = ASTNULL;
04494
if ((_t->getType() == DISCRIMINANT_ASSOCIATION)) {
04495
discriminant_association(_t);
04496 _t = _retTree;
04497 }
04498
else {
04499
if ( _cnt225>=1 ) {
goto _loop225; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
04500 }
04501
04502 _cnt225++;
04503 }
04504 _loop225:;
04505 }
04506 _t = __t223;
04507 _t = _t->getNextSibling();
04508 }
04509
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04510 reportError(ex);
04511
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04512 _t = _t->getNextSibling();
04513 }
04514 _retTree = _t;
04515 }
04516
04517 void AdaTreeParserSuper::discrete_range(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04518
ANTLR_USE_NAMESPACE(antlr)
RefAST discrete_range_AST_in = _t;
04519
04520
try {
04521
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04522 _t = ASTNULL;
04523
switch ( _t->getType()) {
04524
case DOT_DOT:
04525
case RANGE_ATTRIBUTE_REFERENCE:
04526 {
04527
range(_t);
04528 _t = _retTree;
04529
break;
04530 }
04531
case SUBTYPE_INDICATION:
04532 {
04533
subtype_ind(_t);
04534 _t = _retTree;
04535
break;
04536 }
04537
default:
04538 {
04539
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04540 }
04541 }
04542 }
04543
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04544 reportError(ex);
04545
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04546 _t = _t->getNextSibling();
04547 }
04548 _retTree = _t;
04549 }
04550
04551 void AdaTreeParserSuper::discriminant_association(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04552
ANTLR_USE_NAMESPACE(antlr)
RefAST discriminant_association_AST_in = _t;
04553
04554
try {
04555
ANTLR_USE_NAMESPACE(antlr)
RefAST __t227 = _t;
04556
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp170_AST_in = _t;
04557 match(_t,DISCRIMINANT_ASSOCIATION);
04558 _t = _t->getFirstChild();
04559
selector_names_opt(_t);
04560 _t = _retTree;
04561
expression(_t);
04562 _t = _retTree;
04563 _t = __t227;
04564 _t = _t->getNextSibling();
04565 }
04566
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04567 reportError(ex);
04568
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04569 _t = _t->getNextSibling();
04570 }
04571 _retTree = _t;
04572 }
04573
04574 void AdaTreeParserSuper::selector_names_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04575
ANTLR_USE_NAMESPACE(antlr)
RefAST selector_names_opt_AST_in = _t;
04576
04577
try {
04578
ANTLR_USE_NAMESPACE(antlr)
RefAST __t229 = _t;
04579
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp171_AST_in = _t;
04580 match(_t,SELECTOR_NAMES_OPT);
04581 _t = _t->getFirstChild();
04582 {
04583
for (;;) {
04584
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04585 _t = ASTNULL;
04586
if ((_t->getType() == IDENTIFIER)) {
04587
selector_name(_t);
04588 _t = _retTree;
04589 }
04590
else {
04591
goto _loop231;
04592 }
04593
04594 }
04595 _loop231:;
04596 }
04597 _t = __t229;
04598 _t = _t->getNextSibling();
04599 }
04600
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04601 reportError(ex);
04602
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04603 _t = _t->getNextSibling();
04604 }
04605 _retTree = _t;
04606 }
04607
04608 void AdaTreeParserSuper::selector_name(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04609
ANTLR_USE_NAMESPACE(antlr)
RefAST selector_name_AST_in = _t;
04610
04611
try {
04612
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp172_AST_in = _t;
04613 match(_t,IDENTIFIER);
04614 _t = _t->getNextSibling();
04615 }
04616
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04617 reportError(ex);
04618
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04619 _t = _t->getNextSibling();
04620 }
04621 _retTree = _t;
04622 }
04623
04624 void AdaTreeParserSuper::component_list(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04625
ANTLR_USE_NAMESPACE(antlr)
RefAST component_list_AST_in = _t;
04626
04627
try {
04628
component_items(_t);
04629 _t = _retTree;
04630 {
04631
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04632 _t = ASTNULL;
04633
switch ( _t->getType()) {
04634
case VARIANT_PART:
04635 {
04636
variant_part(_t);
04637 _t = _retTree;
04638
break;
04639 }
04640
case 3:
04641 {
04642
break;
04643 }
04644
default:
04645 {
04646
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04647 }
04648 }
04649 }
04650 }
04651
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04652 reportError(ex);
04653
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04654 _t = _t->getNextSibling();
04655 }
04656 _retTree = _t;
04657 }
04658
04659 void AdaTreeParserSuper::component_items(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04660
ANTLR_USE_NAMESPACE(antlr)
RefAST component_items_AST_in = _t;
04661
04662
try {
04663
ANTLR_USE_NAMESPACE(antlr)
RefAST __t242 = _t;
04664
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp173_AST_in = _t;
04665 match(_t,COMPONENT_ITEMS);
04666 _t = _t->getFirstChild();
04667 {
04668
for (;;) {
04669
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04670 _t = ASTNULL;
04671
switch ( _t->getType()) {
04672
case PRAGMA:
04673 {
04674
pragma(_t);
04675 _t = _retTree;
04676
break;
04677 }
04678
case COMPONENT_DECLARATION:
04679 {
04680
comp_decl(_t);
04681 _t = _retTree;
04682
break;
04683 }
04684
default:
04685 {
04686
goto _loop244;
04687 }
04688 }
04689 }
04690 _loop244:;
04691 }
04692 _t = __t242;
04693 _t = _t->getNextSibling();
04694 }
04695
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04696 reportError(ex);
04697
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04698 _t = _t->getNextSibling();
04699 }
04700 _retTree = _t;
04701 }
04702
04703 void AdaTreeParserSuper::variant_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04704
ANTLR_USE_NAMESPACE(antlr)
RefAST variant_part_AST_in = _t;
04705
04706
try {
04707
ANTLR_USE_NAMESPACE(antlr)
RefAST __t246 = _t;
04708
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp174_AST_in = _t;
04709 match(_t,VARIANT_PART);
04710 _t = _t->getFirstChild();
04711
discriminant_direct_name(_t);
04712 _t = _retTree;
04713
variant_s(_t);
04714 _t = _retTree;
04715 _t = __t246;
04716 _t = _t->getNextSibling();
04717 }
04718
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04719 reportError(ex);
04720
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04721 _t = _t->getNextSibling();
04722 }
04723 _retTree = _t;
04724 }
04725
04726 void AdaTreeParserSuper::discriminant_direct_name(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04727
ANTLR_USE_NAMESPACE(antlr)
RefAST discriminant_direct_name_AST_in = _t;
04728
04729
try {
04730
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp175_AST_in = _t;
04731 match(_t,IDENTIFIER);
04732 _t = _t->getNextSibling();
04733 }
04734
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04735 reportError(ex);
04736
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04737 _t = _t->getNextSibling();
04738 }
04739 _retTree = _t;
04740 }
04741
04742 void AdaTreeParserSuper::variant_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04743
ANTLR_USE_NAMESPACE(antlr)
RefAST variant_s_AST_in = _t;
04744
04745
try {
04746
ANTLR_USE_NAMESPACE(antlr)
RefAST __t249 = _t;
04747
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp176_AST_in = _t;
04748 match(_t,VARIANTS);
04749 _t = _t->getFirstChild();
04750 {
04751
int _cnt251=0;
04752
for (;;) {
04753
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04754 _t = ASTNULL;
04755
if ((_t->getType() == VARIANT)) {
04756
variant(_t);
04757 _t = _retTree;
04758 }
04759
else {
04760
if ( _cnt251>=1 ) {
goto _loop251; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
04761 }
04762
04763 _cnt251++;
04764 }
04765 _loop251:;
04766 }
04767 _t = __t249;
04768 _t = _t->getNextSibling();
04769 }
04770
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04771 reportError(ex);
04772
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04773 _t = _t->getNextSibling();
04774 }
04775 _retTree = _t;
04776 }
04777
04778 void AdaTreeParserSuper::variant(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04779
ANTLR_USE_NAMESPACE(antlr)
RefAST variant_AST_in = _t;
04780
04781
try {
04782
ANTLR_USE_NAMESPACE(antlr)
RefAST __t253 = _t;
04783
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp177_AST_in = _t;
04784 match(_t,VARIANT);
04785 _t = _t->getFirstChild();
04786
choice_s(_t);
04787 _t = _retTree;
04788 {
04789
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04790 _t = ASTNULL;
04791
switch ( _t->getType()) {
04792
case COMPONENT_ITEMS:
04793 {
04794
component_list(_t);
04795 _t = _retTree;
04796
break;
04797 }
04798
case 3:
04799 {
04800
break;
04801 }
04802
default:
04803 {
04804
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04805 }
04806 }
04807 }
04808 _t = __t253;
04809 _t = _t->getNextSibling();
04810 }
04811
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04812 reportError(ex);
04813
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04814 _t = _t->getNextSibling();
04815 }
04816 _retTree = _t;
04817 }
04818
04819 void AdaTreeParserSuper::choice_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04820
ANTLR_USE_NAMESPACE(antlr)
RefAST choice_s_AST_in = _t;
04821
04822
try {
04823
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04824 _t = ASTNULL;
04825
switch ( _t->getType()) {
04826
case PIPE:
04827 {
04828
ANTLR_USE_NAMESPACE(antlr)
RefAST __t256 = _t;
04829
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp178_AST_in = _t;
04830 match(_t,PIPE);
04831 _t = _t->getFirstChild();
04832
choice_s(_t);
04833 _t = _retTree;
04834
choice(_t);
04835 _t = _retTree;
04836 _t = __t256;
04837 _t = _t->getNextSibling();
04838
break;
04839 }
04840
case IDENTIFIER:
04841
case DOT:
04842
case TIC:
04843
case OTHERS:
04844
case DOT_DOT:
04845
case IN:
04846
case CHARACTER_LITERAL:
04847
case CHAR_STRING:
04848
case NuLL:
04849
case MOD:
04850
case OR:
04851
case AND:
04852
case XOR:
04853
case NOT:
04854
case EQ:
04855
case NE:
04856
case LT_:
04857
case LE:
04858
case GT:
04859
case GE:
04860
case PLUS:
04861
case MINUS:
04862
case CONCAT:
04863
case STAR:
04864
case DIV:
04865
case REM:
04866
case ABS:
04867
case EXPON:
04868
case NUMERIC_LIT:
04869
case ALLOCATOR:
04870
case INDEXED_COMPONENT:
04871
case OPERATOR_SYMBOL:
04872
case RANGE_ATTRIBUTE_REFERENCE:
04873
case AND_THEN:
04874
case MARK_WITH_CONSTRAINT:
04875
case NOT_IN:
04876
case OR_ELSE:
04877
case PARENTHESIZED_PRIMARY:
04878
case UNARY_MINUS:
04879
case UNARY_PLUS:
04880 {
04881
choice(_t);
04882 _t = _retTree;
04883
break;
04884 }
04885
default:
04886 {
04887
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04888 }
04889 }
04890 }
04891
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04892 reportError(ex);
04893
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04894 _t = _t->getNextSibling();
04895 }
04896 _retTree = _t;
04897 }
04898
04899 void AdaTreeParserSuper::choice(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04900
ANTLR_USE_NAMESPACE(antlr)
RefAST choice_AST_in = _t;
04901
04902
try {
04903
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04904 _t = ASTNULL;
04905
switch ( _t->getType()) {
04906
case OTHERS:
04907 {
04908
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp179_AST_in = _t;
04909 match(_t,OTHERS);
04910 _t = _t->getNextSibling();
04911
break;
04912 }
04913
case DOT_DOT:
04914
case RANGE_ATTRIBUTE_REFERENCE:
04915
case MARK_WITH_CONSTRAINT:
04916 {
04917
discrete_with_range(_t);
04918 _t = _retTree;
04919
break;
04920 }
04921
case IDENTIFIER:
04922
case DOT:
04923
case TIC:
04924
case IN:
04925
case CHARACTER_LITERAL:
04926
case CHAR_STRING:
04927
case NuLL:
04928
case MOD:
04929
case OR:
04930
case AND:
04931
case XOR:
04932
case NOT:
04933
case EQ:
04934
case NE:
04935
case LT_:
04936
case LE:
04937
case GT:
04938
case GE:
04939
case PLUS:
04940
case MINUS:
04941
case CONCAT:
04942
case STAR:
04943
case DIV:
04944
case REM:
04945
case ABS:
04946
case EXPON:
04947
case NUMERIC_LIT:
04948
case ALLOCATOR:
04949
case INDEXED_COMPONENT:
04950
case OPERATOR_SYMBOL:
04951
case AND_THEN:
04952
case NOT_IN:
04953
case OR_ELSE:
04954
case PARENTHESIZED_PRIMARY:
04955
case UNARY_MINUS:
04956
case UNARY_PLUS:
04957 {
04958
expression(_t);
04959 _t = _retTree;
04960
break;
04961 }
04962
default:
04963 {
04964
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04965 }
04966 }
04967 }
04968
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
04969 reportError(ex);
04970
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04971 _t = _t->getNextSibling();
04972 }
04973 _retTree = _t;
04974 }
04975
04976 void AdaTreeParserSuper::discrete_with_range(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
04977
ANTLR_USE_NAMESPACE(antlr)
RefAST discrete_with_range_AST_in = _t;
04978
04979
try {
04980
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
04981 _t = ASTNULL;
04982
switch ( _t->getType()) {
04983
case MARK_WITH_CONSTRAINT:
04984 {
04985
mark_with_constraint(_t);
04986 _t = _retTree;
04987
break;
04988 }
04989
case DOT_DOT:
04990
case RANGE_ATTRIBUTE_REFERENCE:
04991 {
04992
range(_t);
04993 _t = _retTree;
04994
break;
04995 }
04996
default:
04997 {
04998
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
04999 }
05000 }
05001 }
05002
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05003 reportError(ex);
05004
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05005 _t = _t->getNextSibling();
05006 }
05007 _retTree = _t;
05008 }
05009
05010 void AdaTreeParserSuper::mark_with_constraint(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05011
ANTLR_USE_NAMESPACE(antlr)
RefAST mark_with_constraint_AST_in = _t;
05012
05013
try {
05014
ANTLR_USE_NAMESPACE(antlr)
RefAST __t260 = _t;
05015
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp180_AST_in = _t;
05016 match(_t,MARK_WITH_CONSTRAINT);
05017 _t = _t->getFirstChild();
05018
subtype_mark(_t);
05019 _t = _retTree;
05020
range_constraint(_t);
05021 _t = _retTree;
05022 _t = __t260;
05023 _t = _t->getNextSibling();
05024 }
05025
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05026 reportError(ex);
05027
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05028 _t = _t->getNextSibling();
05029 }
05030 _retTree = _t;
05031 }
05032
05033 void AdaTreeParserSuper::generic_formal_part_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05034
ANTLR_USE_NAMESPACE(antlr)
RefAST generic_formal_part_opt_AST_in = _t;
05035
05036
try {
05037
ANTLR_USE_NAMESPACE(antlr)
RefAST __t273 = _t;
05038
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp181_AST_in = _t;
05039 match(_t,GENERIC_FORMAL_PART);
05040 _t = _t->getFirstChild();
05041 {
05042
for (;;) {
05043
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05044 _t = ASTNULL;
05045
switch ( _t->getType()) {
05046
case PRAGMA:
05047 {
05048
pragma(_t);
05049 _t = _retTree;
05050
break;
05051 }
05052
case USE_CLAUSE:
05053
case USE_TYPE_CLAUSE:
05054 {
05055
use_clause(_t);
05056 _t = _retTree;
05057
break;
05058 }
05059
case FORMAL_PACKAGE_DECLARATION:
05060
case PARAMETER_SPECIFICATION:
05061
case ACCESS_TO_FUNCTION_DECLARATION:
05062
case ACCESS_TO_OBJECT_DECLARATION:
05063
case ACCESS_TO_PROCEDURE_DECLARATION:
05064
case ARRAY_TYPE_DECLARATION:
05065
case FORMAL_DECIMAL_FIXED_POINT_DECLARATION:
05066
case FORMAL_DISCRETE_TYPE_DECLARATION:
05067
case FORMAL_FLOATING_POINT_DECLARATION:
05068
case FORMAL_FUNCTION_DECLARATION:
05069
case FORMAL_MODULAR_TYPE_DECLARATION:
05070
case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION:
05071
case FORMAL_ORDINARY_FIXED_POINT_DECLARATION:
05072
case FORMAL_PRIVATE_EXTENSION_DECLARATION:
05073
case FORMAL_PRIVATE_TYPE_DECLARATION:
05074
case FORMAL_PROCEDURE_DECLARATION:
05075
case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION:
05076 {
05077
generic_formal_parameter(_t);
05078 _t = _retTree;
05079
break;
05080 }
05081
default:
05082 {
05083
goto _loop275;
05084 }
05085 }
05086 }
05087 _loop275:;
05088 }
05089 _t = __t273;
05090 _t = _t->getNextSibling();
05091 }
05092
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05093 reportError(ex);
05094
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05095 _t = _t->getNextSibling();
05096 }
05097 _retTree = _t;
05098 }
05099
05100 void AdaTreeParserSuper::generic_formal_parameter(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05101
ANTLR_USE_NAMESPACE(antlr)
RefAST generic_formal_parameter_AST_in = _t;
05102
05103
try {
05104
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05105 _t = ASTNULL;
05106
switch ( _t->getType()) {
05107
case FORMAL_DISCRETE_TYPE_DECLARATION:
05108 {
05109
ANTLR_USE_NAMESPACE(antlr)
RefAST __t277 = _t;
05110
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp182_AST_in = _t;
05111 match(_t,FORMAL_DISCRETE_TYPE_DECLARATION);
05112 _t = _t->getFirstChild();
05113
def_id(_t);
05114 _t = _retTree;
05115 _t = __t277;
05116 _t = _t->getNextSibling();
05117
break;
05118 }
05119
case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION:
05120 {
05121
ANTLR_USE_NAMESPACE(antlr)
RefAST __t278 = _t;
05122
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp183_AST_in = _t;
05123 match(_t,FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
05124 _t = _t->getFirstChild();
05125
def_id(_t);
05126 _t = _retTree;
05127 _t = __t278;
05128 _t = _t->getNextSibling();
05129
break;
05130 }
05131
case FORMAL_MODULAR_TYPE_DECLARATION:
05132 {
05133
ANTLR_USE_NAMESPACE(antlr)
RefAST __t279 = _t;
05134
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp184_AST_in = _t;
05135 match(_t,FORMAL_MODULAR_TYPE_DECLARATION);
05136 _t = _t->getFirstChild();
05137
def_id(_t);
05138 _t = _retTree;
05139 _t = __t279;
05140 _t = _t->getNextSibling();
05141
break;
05142 }
05143
case FORMAL_DECIMAL_FIXED_POINT_DECLARATION:
05144 {
05145
ANTLR_USE_NAMESPACE(antlr)
RefAST __t280 = _t;
05146
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp185_AST_in = _t;
05147 match(_t,FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
05148 _t = _t->getFirstChild();
05149
def_id(_t);
05150 _t = _retTree;
05151 _t = __t280;
05152 _t = _t->getNextSibling();
05153
break;
05154 }
05155
case FORMAL_ORDINARY_FIXED_POINT_DECLARATION:
05156 {
05157
ANTLR_USE_NAMESPACE(antlr)
RefAST __t281 = _t;
05158
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp186_AST_in = _t;
05159 match(_t,FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
05160 _t = _t->getFirstChild();
05161
def_id(_t);
05162 _t = _retTree;
05163 _t = __t281;
05164 _t = _t->getNextSibling();
05165
break;
05166 }
05167
case FORMAL_FLOATING_POINT_DECLARATION:
05168 {
05169
ANTLR_USE_NAMESPACE(antlr)
RefAST __t282 = _t;
05170
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp187_AST_in = _t;
05171 match(_t,FORMAL_FLOATING_POINT_DECLARATION);
05172 _t = _t->getFirstChild();
05173
def_id(_t);
05174 _t = _retTree;
05175 _t = __t282;
05176 _t = _t->getNextSibling();
05177
break;
05178 }
05179
case ARRAY_TYPE_DECLARATION:
05180 {
05181
formal_array_type_declaration(_t);
05182 _t = _retTree;
05183
break;
05184 }
05185
case ACCESS_TO_FUNCTION_DECLARATION:
05186
case ACCESS_TO_OBJECT_DECLARATION:
05187
case ACCESS_TO_PROCEDURE_DECLARATION:
05188 {
05189
formal_access_type_declaration(_t);
05190 _t = _retTree;
05191
break;
05192 }
05193
case FORMAL_PRIVATE_TYPE_DECLARATION:
05194 {
05195
ANTLR_USE_NAMESPACE(antlr)
RefAST __t283 = _t;
05196
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp188_AST_in = _t;
05197 match(_t,FORMAL_PRIVATE_TYPE_DECLARATION);
05198 _t = _t->getFirstChild();
05199
id_part(_t);
05200 _t = _retTree;
05201
modifiers(_t);
05202 _t = _retTree;
05203 _t = __t283;
05204 _t = _t->getNextSibling();
05205
break;
05206 }
05207
case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION:
05208 {
05209
ANTLR_USE_NAMESPACE(antlr)
RefAST __t284 = _t;
05210
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp189_AST_in = _t;
05211 match(_t,FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
05212 _t = _t->getFirstChild();
05213
id_part(_t);
05214 _t = _retTree;
05215
subtype_ind(_t);
05216 _t = _retTree;
05217 _t = __t284;
05218 _t = _t->getNextSibling();
05219
break;
05220 }
05221
case FORMAL_PRIVATE_EXTENSION_DECLARATION:
05222 {
05223
ANTLR_USE_NAMESPACE(antlr)
RefAST __t285 = _t;
05224
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp190_AST_in = _t;
05225 match(_t,FORMAL_PRIVATE_EXTENSION_DECLARATION);
05226 _t = _t->getFirstChild();
05227
id_part(_t);
05228 _t = _retTree;
05229
modifiers(_t);
05230 _t = _retTree;
05231
subtype_ind(_t);
05232 _t = _retTree;
05233 _t = __t285;
05234 _t = _t->getNextSibling();
05235
break;
05236 }
05237
case FORMAL_PROCEDURE_DECLARATION:
05238 {
05239
ANTLR_USE_NAMESPACE(antlr)
RefAST __t286 = _t;
05240
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp191_AST_in = _t;
05241 match(_t,FORMAL_PROCEDURE_DECLARATION);
05242 _t = _t->getFirstChild();
05243
def_id(_t);
05244 _t = _retTree;
05245
formal_part_opt(_t);
05246 _t = _retTree;
05247
subprogram_default_opt(_t);
05248 _t = _retTree;
05249 _t = __t286;
05250 _t = _t->getNextSibling();
05251
break;
05252 }
05253
case FORMAL_FUNCTION_DECLARATION:
05254 {
05255
ANTLR_USE_NAMESPACE(antlr)
RefAST __t287 = _t;
05256
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp192_AST_in = _t;
05257 match(_t,FORMAL_FUNCTION_DECLARATION);
05258 _t = _t->getFirstChild();
05259
def_designator(_t);
05260 _t = _retTree;
05261
function_tail(_t);
05262 _t = _retTree;
05263
subprogram_default_opt(_t);
05264 _t = _retTree;
05265 _t = __t287;
05266 _t = _t->getNextSibling();
05267
break;
05268 }
05269
case FORMAL_PACKAGE_DECLARATION:
05270 {
05271
ANTLR_USE_NAMESPACE(antlr)
RefAST __t288 = _t;
05272
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp193_AST_in = _t;
05273 match(_t,FORMAL_PACKAGE_DECLARATION);
05274 _t = _t->getFirstChild();
05275
def_id(_t);
05276 _t = _retTree;
05277
compound_name(_t);
05278 _t = _retTree;
05279
formal_package_actual_part_opt(_t);
05280 _t = _retTree;
05281 _t = __t288;
05282 _t = _t->getNextSibling();
05283
break;
05284 }
05285
case PARAMETER_SPECIFICATION:
05286 {
05287
parameter_specification(_t);
05288 _t = _retTree;
05289
break;
05290 }
05291
default:
05292 {
05293
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
05294 }
05295 }
05296 }
05297
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05298 reportError(ex);
05299
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05300 _t = _t->getNextSibling();
05301 }
05302 _retTree = _t;
05303 }
05304
05305 void AdaTreeParserSuper::formal_array_type_declaration(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05306
ANTLR_USE_NAMESPACE(antlr)
RefAST formal_array_type_declaration_AST_in = _t;
05307
05308
try {
05309
array_type_declaration(_t);
05310 _t = _retTree;
05311 }
05312
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05313 reportError(ex);
05314
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05315 _t = _t->getNextSibling();
05316 }
05317 _retTree = _t;
05318 }
05319
05320 void AdaTreeParserSuper::formal_access_type_declaration(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05321
ANTLR_USE_NAMESPACE(antlr)
RefAST formal_access_type_declaration_AST_in = _t;
05322
05323
try {
05324
access_type_declaration(_t);
05325 _t = _retTree;
05326 }
05327
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05328 reportError(ex);
05329
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05330 _t = _t->getNextSibling();
05331 }
05332 _retTree = _t;
05333 }
05334
05335 void AdaTreeParserSuper::id_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05336
ANTLR_USE_NAMESPACE(antlr)
RefAST id_part_AST_in = _t;
05337
05338
try {
05339
def_id(_t);
05340 _t = _retTree;
05341
discrim_part_opt(_t);
05342 _t = _retTree;
05343 }
05344
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05345 reportError(ex);
05346
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05347 _t = _t->getNextSibling();
05348 }
05349 _retTree = _t;
05350 }
05351
05352 void AdaTreeParserSuper::subprogram_default_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05353
ANTLR_USE_NAMESPACE(antlr)
RefAST subprogram_default_opt_AST_in = _t;
05354
05355
try {
05356 {
05357
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05358 _t = ASTNULL;
05359
switch ( _t->getType()) {
05360
case BOX:
05361 {
05362
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp194_AST_in = _t;
05363 match(_t,BOX);
05364 _t = _t->getNextSibling();
05365
break;
05366 }
05367
case IDENTIFIER:
05368
case DOT:
05369
case TIC:
05370
case INDEXED_COMPONENT:
05371 {
05372
name(_t);
05373 _t = _retTree;
05374
break;
05375 }
05376
case 3:
05377 {
05378
break;
05379 }
05380
default:
05381 {
05382
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
05383 }
05384 }
05385 }
05386 }
05387
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05388 reportError(ex);
05389
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05390 _t = _t->getNextSibling();
05391 }
05392 _retTree = _t;
05393 }
05394
05395 void AdaTreeParserSuper::formal_package_actual_part_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05396
ANTLR_USE_NAMESPACE(antlr)
RefAST formal_package_actual_part_opt_AST_in = _t;
05397
05398
try {
05399 {
05400
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05401 _t = ASTNULL;
05402
switch ( _t->getType()) {
05403
case BOX:
05404 {
05405
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp195_AST_in = _t;
05406 match(_t,BOX);
05407 _t = _t->getNextSibling();
05408
break;
05409 }
05410
case DEFINING_IDENTIFIER_LIST:
05411 {
05412
defining_identifier_list(_t);
05413 _t = _retTree;
05414
break;
05415 }
05416
case 3:
05417 {
05418
break;
05419 }
05420
default:
05421 {
05422
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
05423 }
05424 }
05425 }
05426 }
05427
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05428 reportError(ex);
05429
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05430 _t = _t->getNextSibling();
05431 }
05432 _retTree = _t;
05433 }
05434
05435 void AdaTreeParserSuper::procedure_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05436
ANTLR_USE_NAMESPACE(antlr)
RefAST procedure_body_AST_in = _t;
05437
05438
try {
05439
ANTLR_USE_NAMESPACE(antlr)
RefAST __t298 = _t;
05440
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp196_AST_in = _t;
05441 match(_t,PROCEDURE_BODY);
05442 _t = _t->getFirstChild();
05443
def_id(_t);
05444 _t = _retTree;
05445
formal_part_opt(_t);
05446 _t = _retTree;
05447
body_part(_t);
05448 _t = _retTree;
05449 _t = __t298;
05450 _t = _t->getNextSibling();
05451 }
05452
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05453 reportError(ex);
05454
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05455 _t = _t->getNextSibling();
05456 }
05457 _retTree = _t;
05458 }
05459
05460 void AdaTreeParserSuper::function_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05461
ANTLR_USE_NAMESPACE(antlr)
RefAST function_body_AST_in = _t;
05462
05463
try {
05464
ANTLR_USE_NAMESPACE(antlr)
RefAST __t300 = _t;
05465
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp197_AST_in = _t;
05466 match(_t,FUNCTION_BODY);
05467 _t = _t->getFirstChild();
05468
def_designator(_t);
05469 _t = _retTree;
05470
function_tail(_t);
05471 _t = _retTree;
05472
body_part(_t);
05473 _t = _retTree;
05474 _t = __t300;
05475 _t = _t->getNextSibling();
05476 }
05477
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05478 reportError(ex);
05479
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05480 _t = _t->getNextSibling();
05481 }
05482 _retTree = _t;
05483 }
05484
05485 void AdaTreeParserSuper::body_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05486
ANTLR_USE_NAMESPACE(antlr)
RefAST body_part_AST_in = _t;
05487
05488
try {
05489
declarative_part(_t);
05490 _t = _retTree;
05491
block_body(_t);
05492 _t = _retTree;
05493 }
05494
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05495 reportError(ex);
05496
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05497 _t = _t->getNextSibling();
05498 }
05499 _retTree = _t;
05500 }
05501
05502 void AdaTreeParserSuper::declarative_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05503
ANTLR_USE_NAMESPACE(antlr)
RefAST declarative_part_AST_in = _t;
05504
05505
try {
05506
ANTLR_USE_NAMESPACE(antlr)
RefAST __t303 = _t;
05507
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp198_AST_in = _t;
05508 match(_t,DECLARATIVE_PART);
05509 _t = _t->getFirstChild();
05510 {
05511
for (;;) {
05512
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05513 _t = ASTNULL;
05514
switch ( _t->getType()) {
05515
case PRAGMA:
05516 {
05517
pragma(_t);
05518 _t = _retTree;
05519
break;
05520 }
05521
case ATTRIBUTE_DEFINITION_CLAUSE:
05522
case AT_CLAUSE:
05523
case ENUMERATION_REPESENTATION_CLAUSE:
05524
case EXCEPTION_DECLARATION:
05525
case EXCEPTION_RENAMING_DECLARATION:
05526
case GENERIC_PACKAGE_DECLARATION:
05527
case INCOMPLETE_TYPE_DECLARATION:
05528
case NUMBER_DECLARATION:
05529
case OBJECT_DECLARATION:
05530
case OBJECT_RENAMING_DECLARATION:
05531
case PACKAGE_BODY:
05532
case PACKAGE_BODY_STUB:
05533
case PACKAGE_RENAMING_DECLARATION:
05534
case PACKAGE_SPECIFICATION:
05535
case PRIVATE_EXTENSION_DECLARATION:
05536
case PRIVATE_TYPE_DECLARATION:
05537
case PROTECTED_BODY:
05538
case PROTECTED_BODY_STUB:
05539
case PROTECTED_TYPE_DECLARATION:
05540
case RECORD_REPRESENTATION_CLAUSE:
05541
case SINGLE_PROTECTED_DECLARATION:
05542
case SINGLE_TASK_DECLARATION:
05543
case SUBTYPE_DECLARATION:
05544
case TASK_BODY:
05545
case TASK_BODY_STUB:
05546
case TASK_TYPE_DECLARATION:
05547
case USE_CLAUSE:
05548
case USE_TYPE_CLAUSE:
05549
case ABSTRACT_FUNCTION_DECLARATION:
05550
case ABSTRACT_PROCEDURE_DECLARATION:
05551
case ACCESS_TO_FUNCTION_DECLARATION:
05552
case ACCESS_TO_OBJECT_DECLARATION:
05553
case ACCESS_TO_PROCEDURE_DECLARATION:
05554
case ARRAY_OBJECT_DECLARATION:
05555
case ARRAY_TYPE_DECLARATION:
05556
case DECIMAL_FIXED_POINT_DECLARATION:
05557
case DERIVED_RECORD_EXTENSION:
05558
case ENUMERATION_TYPE_DECLARATION:
05559
case FLOATING_POINT_DECLARATION:
05560
case FUNCTION_BODY:
05561
case FUNCTION_BODY_STUB:
05562
case FUNCTION_DECLARATION:
05563
case FUNCTION_RENAMING_DECLARATION:
05564
case GENERIC_FUNCTION_DECLARATION:
05565
case GENERIC_FUNCTION_INSTANTIATION:
05566
case GENERIC_FUNCTION_RENAMING:
05567
case GENERIC_PACKAGE_INSTANTIATION:
05568
case GENERIC_PACKAGE_RENAMING:
05569
case GENERIC_PROCEDURE_DECLARATION:
05570
case GENERIC_PROCEDURE_INSTANTIATION:
05571
case GENERIC_PROCEDURE_RENAMING:
05572
case MODULAR_TYPE_DECLARATION:
05573
case ORDINARY_DERIVED_TYPE_DECLARATION:
05574
case ORDINARY_FIXED_POINT_DECLARATION:
05575
case PROCEDURE_BODY:
05576
case PROCEDURE_BODY_STUB:
05577
case PROCEDURE_DECLARATION:
05578
case PROCEDURE_RENAMING_DECLARATION:
05579
case RECORD_TYPE_DECLARATION:
05580
case SIGNED_INTEGER_TYPE_DECLARATION:
05581 {
05582
declarative_item(_t);
05583 _t = _retTree;
05584
break;
05585 }
05586
default:
05587 {
05588
goto _loop305;
05589 }
05590 }
05591 }
05592 _loop305:;
05593 }
05594 _t = __t303;
05595 _t = _t->getNextSibling();
05596 }
05597
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05598 reportError(ex);
05599
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05600 _t = _t->getNextSibling();
05601 }
05602 _retTree = _t;
05603 }
05604
05605 void AdaTreeParserSuper::block_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05606
ANTLR_USE_NAMESPACE(antlr)
RefAST block_body_AST_in = _t;
05607
05608
try {
05609
ANTLR_USE_NAMESPACE(antlr)
RefAST __t325 = _t;
05610
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp199_AST_in = _t;
05611 match(_t,BLOCK_BODY);
05612 _t = _t->getFirstChild();
05613
handled_stmt_s(_t);
05614 _t = _retTree;
05615 _t = __t325;
05616 _t = _t->getNextSibling();
05617 }
05618
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05619 reportError(ex);
05620
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05621 _t = _t->getNextSibling();
05622 }
05623 _retTree = _t;
05624 }
05625
05626 void AdaTreeParserSuper::declarative_item(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05627
ANTLR_USE_NAMESPACE(antlr)
RefAST declarative_item_AST_in = _t;
05628
05629
try {
05630
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05631 _t = ASTNULL;
05632
switch ( _t->getType()) {
05633
case PACKAGE_BODY_STUB:
05634 {
05635
ANTLR_USE_NAMESPACE(antlr)
RefAST __t307 = _t;
05636
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp200_AST_in = _t;
05637 match(_t,PACKAGE_BODY_STUB);
05638 _t = _t->getFirstChild();
05639
def_id(_t);
05640 _t = _retTree;
05641 _t = __t307;
05642 _t = _t->getNextSibling();
05643
break;
05644 }
05645
case PACKAGE_BODY:
05646 {
05647
ANTLR_USE_NAMESPACE(antlr)
RefAST __t308 = _t;
05648
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp201_AST_in = _t;
05649 match(_t,PACKAGE_BODY);
05650 _t = _t->getFirstChild();
05651
def_id(_t);
05652 _t = _retTree;
05653
pkg_body_part(_t);
05654 _t = _retTree;
05655 _t = __t308;
05656 _t = _t->getNextSibling();
05657
break;
05658 }
05659
case PACKAGE_RENAMING_DECLARATION:
05660
case PACKAGE_SPECIFICATION:
05661
case GENERIC_PACKAGE_INSTANTIATION:
05662 {
05663
spec_decl_part(_t);
05664 _t = _retTree;
05665
break;
05666 }
05667
case TASK_BODY_STUB:
05668 {
05669
ANTLR_USE_NAMESPACE(antlr)
RefAST __t309 = _t;
05670
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp202_AST_in = _t;
05671 match(_t,TASK_BODY_STUB);
05672 _t = _t->getFirstChild();
05673
def_id(_t);
05674 _t = _retTree;
05675 _t = __t309;
05676 _t = _t->getNextSibling();
05677
break;
05678 }
05679
case TASK_BODY:
05680 {
05681
ANTLR_USE_NAMESPACE(antlr)
RefAST __t310 = _t;
05682
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp203_AST_in = _t;
05683 match(_t,TASK_BODY);
05684 _t = _t->getFirstChild();
05685
def_id(_t);
05686 _t = _retTree;
05687
body_part(_t);
05688 _t = _retTree;
05689 _t = __t310;
05690 _t = _t->getNextSibling();
05691
break;
05692 }
05693
case SINGLE_TASK_DECLARATION:
05694
case TASK_TYPE_DECLARATION:
05695 {
05696
task_type_or_single_decl(_t);
05697 _t = _retTree;
05698
break;
05699 }
05700
case PROTECTED_BODY_STUB:
05701 {
05702
ANTLR_USE_NAMESPACE(antlr)
RefAST __t311 = _t;
05703
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp204_AST_in = _t;
05704 match(_t,PROTECTED_BODY_STUB);
05705 _t = _t->getFirstChild();
05706
def_id(_t);
05707 _t = _retTree;
05708 _t = __t311;
05709 _t = _t->getNextSibling();
05710
break;
05711 }
05712
case PROTECTED_BODY:
05713 {
05714
ANTLR_USE_NAMESPACE(antlr)
RefAST __t312 = _t;
05715
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp205_AST_in = _t;
05716 match(_t,PROTECTED_BODY);
05717 _t = _t->getFirstChild();
05718
def_id(_t);
05719 _t = _retTree;
05720
prot_op_bodies_opt(_t);
05721 _t = _retTree;
05722 _t = __t312;
05723 _t = _t->getNextSibling();
05724
break;
05725 }
05726
case PROTECTED_TYPE_DECLARATION:
05727
case SINGLE_PROTECTED_DECLARATION:
05728 {
05729
prot_type_or_single_decl(_t);
05730 _t = _retTree;
05731
break;
05732 }
05733
case ABSTRACT_FUNCTION_DECLARATION:
05734
case ABSTRACT_PROCEDURE_DECLARATION:
05735
case FUNCTION_BODY:
05736
case FUNCTION_BODY_STUB:
05737
case FUNCTION_DECLARATION:
05738
case FUNCTION_RENAMING_DECLARATION:
05739
case GENERIC_FUNCTION_INSTANTIATION:
05740
case GENERIC_PROCEDURE_INSTANTIATION:
05741
case PROCEDURE_BODY:
05742
case PROCEDURE_BODY_STUB:
05743
case PROCEDURE_DECLARATION:
05744
case PROCEDURE_RENAMING_DECLARATION:
05745 {
05746
subprog_decl_or_rename_or_inst_or_body(_t);
05747 _t = _retTree;
05748
break;
05749 }
05750
case ATTRIBUTE_DEFINITION_CLAUSE:
05751
case AT_CLAUSE:
05752
case ENUMERATION_REPESENTATION_CLAUSE:
05753
case EXCEPTION_DECLARATION:
05754
case EXCEPTION_RENAMING_DECLARATION:
05755
case GENERIC_PACKAGE_DECLARATION:
05756
case INCOMPLETE_TYPE_DECLARATION:
05757
case NUMBER_DECLARATION:
05758
case OBJECT_DECLARATION:
05759
case OBJECT_RENAMING_DECLARATION:
05760
case PRIVATE_EXTENSION_DECLARATION:
05761
case PRIVATE_TYPE_DECLARATION:
05762
case RECORD_REPRESENTATION_CLAUSE:
05763
case SUBTYPE_DECLARATION:
05764
case USE_CLAUSE:
05765
case USE_TYPE_CLAUSE:
05766
case ACCESS_TO_FUNCTION_DECLARATION:
05767
case ACCESS_TO_OBJECT_DECLARATION:
05768
case ACCESS_TO_PROCEDURE_DECLARATION:
05769
case ARRAY_OBJECT_DECLARATION:
05770
case ARRAY_TYPE_DECLARATION:
05771
case DECIMAL_FIXED_POINT_DECLARATION:
05772
case DERIVED_RECORD_EXTENSION:
05773
case ENUMERATION_TYPE_DECLARATION:
05774
case FLOATING_POINT_DECLARATION:
05775
case GENERIC_FUNCTION_DECLARATION:
05776
case GENERIC_FUNCTION_RENAMING:
05777
case GENERIC_PACKAGE_RENAMING:
05778
case GENERIC_PROCEDURE_DECLARATION:
05779
case GENERIC_PROCEDURE_RENAMING:
05780
case MODULAR_TYPE_DECLARATION:
05781
case ORDINARY_DERIVED_TYPE_DECLARATION:
05782
case ORDINARY_FIXED_POINT_DECLARATION:
05783
case RECORD_TYPE_DECLARATION:
05784
case SIGNED_INTEGER_TYPE_DECLARATION:
05785 {
05786
decl_common(_t);
05787 _t = _retTree;
05788
break;
05789 }
05790
default:
05791 {
05792
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
05793 }
05794 }
05795 }
05796
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05797 reportError(ex);
05798
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05799 _t = _t->getNextSibling();
05800 }
05801 _retTree = _t;
05802 }
05803
05804 void AdaTreeParserSuper::prot_op_bodies_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05805
ANTLR_USE_NAMESPACE(antlr)
RefAST prot_op_bodies_opt_AST_in = _t;
05806
05807
try {
05808
ANTLR_USE_NAMESPACE(antlr)
RefAST __t318 = _t;
05809
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp206_AST_in = _t;
05810 match(_t,PROT_OP_BODIES_OPT);
05811 _t = _t->getFirstChild();
05812 {
05813
for (;;) {
05814
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05815 _t = ASTNULL;
05816
switch ( _t->getType()) {
05817
case PRAGMA:
05818 {
05819
pragma(_t);
05820 _t = _retTree;
05821
break;
05822 }
05823
case ENTRY_BODY:
05824 {
05825
entry_body(_t);
05826 _t = _retTree;
05827
break;
05828 }
05829
case FUNCTION_BODY:
05830
case FUNCTION_DECLARATION:
05831
case PROCEDURE_BODY:
05832
case PROCEDURE_DECLARATION:
05833 {
05834
subprog_decl_or_body(_t);
05835 _t = _retTree;
05836
break;
05837 }
05838
default:
05839 {
05840
goto _loop320;
05841 }
05842 }
05843 }
05844 _loop320:;
05845 }
05846 _t = __t318;
05847 _t = _t->getNextSibling();
05848 }
05849
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05850 reportError(ex);
05851
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05852 _t = _t->getNextSibling();
05853 }
05854 _retTree = _t;
05855 }
05856
05857 void AdaTreeParserSuper::block_body_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05858
ANTLR_USE_NAMESPACE(antlr)
RefAST block_body_opt_AST_in = _t;
05859
05860
try {
05861
ANTLR_USE_NAMESPACE(antlr)
RefAST __t315 = _t;
05862
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp207_AST_in = _t;
05863 match(_t,BLOCK_BODY_OPT);
05864 _t = _t->getFirstChild();
05865 {
05866
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05867 _t = ASTNULL;
05868
switch ( _t->getType()) {
05869
case HANDLED_SEQUENCE_OF_STATEMENTS:
05870 {
05871
handled_stmt_s(_t);
05872 _t = _retTree;
05873
break;
05874 }
05875
case 3:
05876 {
05877
break;
05878 }
05879
default:
05880 {
05881
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
05882 }
05883 }
05884 }
05885 _t = __t315;
05886 _t = _t->getNextSibling();
05887 }
05888
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05889 reportError(ex);
05890
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05891 _t = _t->getNextSibling();
05892 }
05893 _retTree = _t;
05894 }
05895
05896 void AdaTreeParserSuper::handled_stmt_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05897
ANTLR_USE_NAMESPACE(antlr)
RefAST handled_stmt_s_AST_in = _t;
05898
05899
try {
05900
ANTLR_USE_NAMESPACE(antlr)
RefAST __t327 = _t;
05901
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp208_AST_in = _t;
05902 match(_t,HANDLED_SEQUENCE_OF_STATEMENTS);
05903 _t = _t->getFirstChild();
05904
statements(_t);
05905 _t = _retTree;
05906
except_handler_part_opt(_t);
05907 _t = _retTree;
05908 _t = __t327;
05909 _t = _t->getNextSibling();
05910 }
05911
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05912 reportError(ex);
05913
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05914 _t = _t->getNextSibling();
05915 }
05916 _retTree = _t;
05917 }
05918
05919 void AdaTreeParserSuper::entry_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05920
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_body_AST_in = _t;
05921
05922
try {
05923
ANTLR_USE_NAMESPACE(antlr)
RefAST __t384 = _t;
05924
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp209_AST_in = _t;
05925 match(_t,ENTRY_BODY);
05926 _t = _t->getFirstChild();
05927
def_id(_t);
05928 _t = _retTree;
05929
entry_body_formal_part(_t);
05930 _t = _retTree;
05931
entry_barrier(_t);
05932 _t = _retTree;
05933
body_part(_t);
05934 _t = _retTree;
05935 _t = __t384;
05936 _t = _t->getNextSibling();
05937 }
05938
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
05939 reportError(ex);
05940
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05941 _t = _t->getNextSibling();
05942 }
05943 _retTree = _t;
05944 }
05945
05946 void AdaTreeParserSuper::subprog_decl_or_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
05947
ANTLR_USE_NAMESPACE(antlr)
RefAST subprog_decl_or_body_AST_in = _t;
05948
05949
try {
05950
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
05951 _t = ASTNULL;
05952
switch ( _t->getType()) {
05953
case PROCEDURE_BODY:
05954 {
05955
procedure_body(_t);
05956 _t = _retTree;
05957
break;
05958 }
05959
case PROCEDURE_DECLARATION:
05960 {
05961
ANTLR_USE_NAMESPACE(antlr)
RefAST __t322 = _t;
05962
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp210_AST_in = _t;
05963 match(_t,PROCEDURE_DECLARATION);
05964 _t = _t->getFirstChild();
05965
def_id(_t);
05966 _t = _retTree;
05967
formal_part_opt(_t);
05968 _t = _retTree;
05969 _t = __t322;
05970 _t = _t->getNextSibling();
05971
break;
05972 }
05973
case FUNCTION_BODY:
05974 {
05975
function_body(_t);
05976 _t = _retTree;
05977
break;
05978 }
05979
case FUNCTION_DECLARATION:
05980 {
05981
ANTLR_USE_NAMESPACE(antlr)
RefAST __t323 = _t;
05982
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp211_AST_in = _t;
05983 match(_t,FUNCTION_DECLARATION);
05984 _t = _t->getFirstChild();
05985
def_designator(_t);
05986 _t = _retTree;
05987
function_tail(_t);
05988 _t = _retTree;
05989 _t = __t323;
05990 _t = _t->getNextSibling();
05991
break;
05992 }
05993
default:
05994 {
05995
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
05996 }
05997 }
05998 }
05999
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06000 reportError(ex);
06001
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06002 _t = _t->getNextSibling();
06003 }
06004 _retTree = _t;
06005 }
06006
06007 void AdaTreeParserSuper::statements(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06008
ANTLR_USE_NAMESPACE(antlr)
RefAST statements_AST_in = _t;
06009
06010
try {
06011
ANTLR_USE_NAMESPACE(antlr)
RefAST __t329 = _t;
06012
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp212_AST_in = _t;
06013 match(_t,SEQUENCE_OF_STATEMENTS);
06014 _t = _t->getFirstChild();
06015 {
06016
int _cnt331=0;
06017
for (;;) {
06018
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06019 _t = ASTNULL;
06020
switch ( _t->getType()) {
06021
case PRAGMA:
06022 {
06023
pragma(_t);
06024 _t = _retTree;
06025
break;
06026 }
06027
case STATEMENT:
06028 {
06029
statement(_t);
06030 _t = _retTree;
06031
break;
06032 }
06033
default:
06034 {
06035
if ( _cnt331>=1 ) {
goto _loop331; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
06036 }
06037 }
06038 _cnt331++;
06039 }
06040 _loop331:;
06041 }
06042 _t = __t329;
06043 _t = _t->getNextSibling();
06044 }
06045
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06046 reportError(ex);
06047
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06048 _t = _t->getNextSibling();
06049 }
06050 _retTree = _t;
06051 }
06052
06053 void AdaTreeParserSuper::except_handler_part_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06054
ANTLR_USE_NAMESPACE(antlr)
RefAST except_handler_part_opt_AST_in = _t;
06055
06056
try {
06057
ANTLR_USE_NAMESPACE(antlr)
RefAST __t435 = _t;
06058
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp213_AST_in = _t;
06059 match(_t,EXCEPT_HANDLER_PART_OPT);
06060 _t = _t->getFirstChild();
06061 {
06062
for (;;) {
06063
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06064 _t = ASTNULL;
06065
if ((_t->getType() == EXCEPTION_HANDLER)) {
06066
exception_handler(_t);
06067 _t = _retTree;
06068 }
06069
else {
06070
goto _loop437;
06071 }
06072
06073 }
06074 _loop437:;
06075 }
06076 _t = __t435;
06077 _t = _t->getNextSibling();
06078 }
06079
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06080 reportError(ex);
06081
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06082 _t = _t->getNextSibling();
06083 }
06084 _retTree = _t;
06085 }
06086
06087 void AdaTreeParserSuper::statement(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06088
ANTLR_USE_NAMESPACE(antlr)
RefAST statement_AST_in = _t;
06089
06090
try {
06091
ANTLR_USE_NAMESPACE(antlr)
RefAST __t333 = _t;
06092
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp214_AST_in = _t;
06093 match(_t,STATEMENT);
06094 _t = _t->getFirstChild();
06095
def_label_opt(_t);
06096 _t = _retTree;
06097 {
06098
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06099 _t = ASTNULL;
06100
switch ( _t->getType()) {
06101
case NULL_STATEMENT:
06102 {
06103
null_stmt(_t);
06104 _t = _retTree;
06105
break;
06106 }
06107
case EXIT_STATEMENT:
06108 {
06109
exit_stmt(_t);
06110 _t = _retTree;
06111
break;
06112 }
06113
case RETURN_STATEMENT:
06114 {
06115
return_stmt(_t);
06116 _t = _retTree;
06117
break;
06118 }
06119
case GOTO_STATEMENT:
06120 {
06121
goto_stmt(_t);
06122 _t = _retTree;
06123
break;
06124 }
06125
case DELAY_STATEMENT:
06126 {
06127
delay_stmt(_t);
06128 _t = _retTree;
06129
break;
06130 }
06131
case ABORT_STATEMENT:
06132 {
06133
abort_stmt(_t);
06134 _t = _retTree;
06135
break;
06136 }
06137
case RAISE_STATEMENT:
06138 {
06139
raise_stmt(_t);
06140 _t = _retTree;
06141
break;
06142 }
06143
case REQUEUE_STATEMENT:
06144 {
06145
requeue_stmt(_t);
06146 _t = _retTree;
06147
break;
06148 }
06149
case ACCEPT_STATEMENT:
06150 {
06151
accept_stmt(_t);
06152 _t = _retTree;
06153
break;
06154 }
06155
case ASYNCHRONOUS_SELECT:
06156
case CONDITIONAL_ENTRY_CALL:
06157
case SELECTIVE_ACCEPT:
06158
case TIMED_ENTRY_CALL:
06159 {
06160
select_stmt(_t);
06161 _t = _retTree;
06162
break;
06163 }
06164
case IF_STATEMENT:
06165 {
06166
if_stmt(_t);
06167 _t = _retTree;
06168
break;
06169 }
06170
case CASE_STATEMENT:
06171 {
06172
case_stmt(_t);
06173 _t = _retTree;
06174
break;
06175 }
06176
case LOOP_STATEMENT:
06177 {
06178
loop_stmt(_t);
06179 _t = _retTree;
06180
break;
06181 }
06182
case BLOCK_STATEMENT:
06183 {
06184
block(_t);
06185 _t = _retTree;
06186
break;
06187 }
06188
case ASSIGNMENT_STATEMENT:
06189
case CALL_STATEMENT:
06190 {
06191
call_or_assignment(_t);
06192 _t = _retTree;
06193
break;
06194 }
06195
default:
06196 {
06197
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06198 }
06199 }
06200 }
06201 _t = __t333;
06202 _t = _t->getNextSibling();
06203 }
06204
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06205 reportError(ex);
06206
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06207 _t = _t->getNextSibling();
06208 }
06209 _retTree = _t;
06210 }
06211
06212 void AdaTreeParserSuper::def_label_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06213
ANTLR_USE_NAMESPACE(antlr)
RefAST def_label_opt_AST_in = _t;
06214
06215
try {
06216
ANTLR_USE_NAMESPACE(antlr)
RefAST __t336 = _t;
06217
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp215_AST_in = _t;
06218 match(_t,LABEL_OPT);
06219 _t = _t->getFirstChild();
06220 {
06221
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06222 _t = ASTNULL;
06223
switch ( _t->getType()) {
06224
case IDENTIFIER:
06225 {
06226
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp216_AST_in = _t;
06227 match(_t,IDENTIFIER);
06228 _t = _t->getNextSibling();
06229
break;
06230 }
06231
case 3:
06232 {
06233
break;
06234 }
06235
default:
06236 {
06237
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06238 }
06239 }
06240 }
06241 _t = __t336;
06242 _t = _t->getNextSibling();
06243 }
06244
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06245 reportError(ex);
06246
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06247 _t = _t->getNextSibling();
06248 }
06249 _retTree = _t;
06250 }
06251
06252 void AdaTreeParserSuper::null_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06253
ANTLR_USE_NAMESPACE(antlr)
RefAST null_stmt_AST_in = _t;
06254
06255
try {
06256
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp217_AST_in = _t;
06257 match(_t,NULL_STATEMENT);
06258 _t = _t->getNextSibling();
06259 }
06260
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06261 reportError(ex);
06262
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06263 _t = _t->getNextSibling();
06264 }
06265 _retTree = _t;
06266 }
06267
06268 void AdaTreeParserSuper::exit_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06269
ANTLR_USE_NAMESPACE(antlr)
RefAST exit_stmt_AST_in = _t;
06270
06271
try {
06272
ANTLR_USE_NAMESPACE(antlr)
RefAST __t371 = _t;
06273
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp218_AST_in = _t;
06274 match(_t,EXIT_STATEMENT);
06275 _t = _t->getFirstChild();
06276 {
06277
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06278 _t = ASTNULL;
06279
switch ( _t->getType()) {
06280
case IDENTIFIER:
06281 {
06282
label_name(_t);
06283 _t = _retTree;
06284
break;
06285 }
06286
case 3:
06287
case WHEN:
06288 {
06289
break;
06290 }
06291
default:
06292 {
06293
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06294 }
06295 }
06296 }
06297 {
06298
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06299 _t = ASTNULL;
06300
switch ( _t->getType()) {
06301
case WHEN:
06302 {
06303
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp219_AST_in = _t;
06304 match(_t,WHEN);
06305 _t = _t->getNextSibling();
06306
condition(_t);
06307 _t = _retTree;
06308
break;
06309 }
06310
case 3:
06311 {
06312
break;
06313 }
06314
default:
06315 {
06316
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06317 }
06318 }
06319 }
06320 _t = __t371;
06321 _t = _t->getNextSibling();
06322 }
06323
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06324 reportError(ex);
06325
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06326 _t = _t->getNextSibling();
06327 }
06328 _retTree = _t;
06329 }
06330
06331 void AdaTreeParserSuper::return_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06332
ANTLR_USE_NAMESPACE(antlr)
RefAST return_stmt_AST_in = _t;
06333
06334
try {
06335
ANTLR_USE_NAMESPACE(antlr)
RefAST __t376 = _t;
06336
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp220_AST_in = _t;
06337 match(_t,RETURN_STATEMENT);
06338 _t = _t->getFirstChild();
06339 {
06340
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06341 _t = ASTNULL;
06342
switch ( _t->getType()) {
06343
case IDENTIFIER:
06344
case DOT:
06345
case TIC:
06346
case IN:
06347
case CHARACTER_LITERAL:
06348
case CHAR_STRING:
06349
case NuLL:
06350
case MOD:
06351
case OR:
06352
case AND:
06353
case XOR:
06354
case NOT:
06355
case EQ:
06356
case NE:
06357
case LT_:
06358
case LE:
06359
case GT:
06360
case GE:
06361
case PLUS:
06362
case MINUS:
06363
case CONCAT:
06364
case STAR:
06365
case DIV:
06366
case REM:
06367
case ABS:
06368
case EXPON:
06369
case NUMERIC_LIT:
06370
case ALLOCATOR:
06371
case INDEXED_COMPONENT:
06372
case OPERATOR_SYMBOL:
06373
case AND_THEN:
06374
case NOT_IN:
06375
case OR_ELSE:
06376
case PARENTHESIZED_PRIMARY:
06377
case UNARY_MINUS:
06378
case UNARY_PLUS:
06379 {
06380
expression(_t);
06381 _t = _retTree;
06382
break;
06383 }
06384
case 3:
06385 {
06386
break;
06387 }
06388
default:
06389 {
06390
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06391 }
06392 }
06393 }
06394 _t = __t376;
06395 _t = _t->getNextSibling();
06396 }
06397
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06398 reportError(ex);
06399
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06400 _t = _t->getNextSibling();
06401 }
06402 _retTree = _t;
06403 }
06404
06405 void AdaTreeParserSuper::goto_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06406
ANTLR_USE_NAMESPACE(antlr)
RefAST goto_stmt_AST_in = _t;
06407
06408
try {
06409
ANTLR_USE_NAMESPACE(antlr)
RefAST __t379 = _t;
06410
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp221_AST_in = _t;
06411 match(_t,GOTO_STATEMENT);
06412 _t = _t->getFirstChild();
06413
label_name(_t);
06414 _t = _retTree;
06415 _t = __t379;
06416 _t = _t->getNextSibling();
06417 }
06418
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06419 reportError(ex);
06420
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06421 _t = _t->getNextSibling();
06422 }
06423 _retTree = _t;
06424 }
06425
06426 void AdaTreeParserSuper::delay_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06427
ANTLR_USE_NAMESPACE(antlr)
RefAST delay_stmt_AST_in = _t;
06428
06429
try {
06430
ANTLR_USE_NAMESPACE(antlr)
RefAST __t399 = _t;
06431
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp222_AST_in = _t;
06432 match(_t,DELAY_STATEMENT);
06433 _t = _t->getFirstChild();
06434
modifiers(_t);
06435 _t = _retTree;
06436
expression(_t);
06437 _t = _retTree;
06438 _t = __t399;
06439 _t = _t->getNextSibling();
06440 }
06441
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06442 reportError(ex);
06443
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06444 _t = _t->getNextSibling();
06445 }
06446 _retTree = _t;
06447 }
06448
06449 void AdaTreeParserSuper::abort_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06450
ANTLR_USE_NAMESPACE(antlr)
RefAST abort_stmt_AST_in = _t;
06451
06452
try {
06453
ANTLR_USE_NAMESPACE(antlr)
RefAST __t431 = _t;
06454
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp223_AST_in = _t;
06455 match(_t,ABORT_STATEMENT);
06456 _t = _t->getFirstChild();
06457 {
06458
int _cnt433=0;
06459
for (;;) {
06460
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06461 _t = ASTNULL;
06462
if ((
_tokenSet_4.member(_t->getType()))) {
06463
name(_t);
06464 _t = _retTree;
06465 }
06466
else {
06467
if ( _cnt433>=1 ) {
goto _loop433; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
06468 }
06469
06470 _cnt433++;
06471 }
06472 _loop433:;
06473 }
06474 _t = __t431;
06475 _t = _t->getNextSibling();
06476 }
06477
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06478 reportError(ex);
06479
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06480 _t = _t->getNextSibling();
06481 }
06482 _retTree = _t;
06483 }
06484
06485 void AdaTreeParserSuper::raise_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06486
ANTLR_USE_NAMESPACE(antlr)
RefAST raise_stmt_AST_in = _t;
06487
06488
try {
06489
ANTLR_USE_NAMESPACE(antlr)
RefAST __t447 = _t;
06490
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp224_AST_in = _t;
06491 match(_t,RAISE_STATEMENT);
06492 _t = _t->getFirstChild();
06493 {
06494
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06495 _t = ASTNULL;
06496
switch ( _t->getType()) {
06497
case IDENTIFIER:
06498
case DOT:
06499 {
06500
compound_name(_t);
06501 _t = _retTree;
06502
break;
06503 }
06504
case 3:
06505 {
06506
break;
06507 }
06508
default:
06509 {
06510
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06511 }
06512 }
06513 }
06514 _t = __t447;
06515 _t = _t->getNextSibling();
06516 }
06517
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06518 reportError(ex);
06519
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06520 _t = _t->getNextSibling();
06521 }
06522 _retTree = _t;
06523 }
06524
06525 void AdaTreeParserSuper::requeue_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06526
ANTLR_USE_NAMESPACE(antlr)
RefAST requeue_stmt_AST_in = _t;
06527
06528
try {
06529
ANTLR_USE_NAMESPACE(antlr)
RefAST __t450 = _t;
06530
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp225_AST_in = _t;
06531 match(_t,REQUEUE_STATEMENT);
06532 _t = _t->getFirstChild();
06533
name(_t);
06534 _t = _retTree;
06535 {
06536
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06537 _t = ASTNULL;
06538
switch ( _t->getType()) {
06539
case ABORT:
06540 {
06541
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp226_AST_in = _t;
06542 match(_t,ABORT);
06543 _t = _t->getNextSibling();
06544
break;
06545 }
06546
case 3:
06547 {
06548
break;
06549 }
06550
default:
06551 {
06552
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06553 }
06554 }
06555 }
06556 _t = __t450;
06557 _t = _t->getNextSibling();
06558 }
06559
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06560 reportError(ex);
06561
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06562 _t = _t->getNextSibling();
06563 }
06564 _retTree = _t;
06565 }
06566
06567 void AdaTreeParserSuper::accept_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06568
ANTLR_USE_NAMESPACE(antlr)
RefAST accept_stmt_AST_in = _t;
06569
06570
try {
06571
ANTLR_USE_NAMESPACE(antlr)
RefAST __t393 = _t;
06572
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp227_AST_in = _t;
06573 match(_t,ACCEPT_STATEMENT);
06574 _t = _t->getFirstChild();
06575
def_id(_t);
06576 _t = _retTree;
06577
entry_index_opt(_t);
06578 _t = _retTree;
06579
formal_part_opt(_t);
06580 _t = _retTree;
06581 {
06582
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06583 _t = ASTNULL;
06584
switch ( _t->getType()) {
06585
case HANDLED_SEQUENCE_OF_STATEMENTS:
06586 {
06587
handled_stmt_s(_t);
06588 _t = _retTree;
06589
break;
06590 }
06591
case 3:
06592 {
06593
break;
06594 }
06595
default:
06596 {
06597
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06598 }
06599 }
06600 }
06601 _t = __t393;
06602 _t = _t->getNextSibling();
06603 }
06604
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06605 reportError(ex);
06606
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06607 _t = _t->getNextSibling();
06608 }
06609 _retTree = _t;
06610 }
06611
06612 void AdaTreeParserSuper::select_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06613
ANTLR_USE_NAMESPACE(antlr)
RefAST select_stmt_AST_in = _t;
06614
06615
try {
06616
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06617 _t = ASTNULL;
06618
switch ( _t->getType()) {
06619
case ASYNCHRONOUS_SELECT:
06620 {
06621
ANTLR_USE_NAMESPACE(antlr)
RefAST __t401 = _t;
06622
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp228_AST_in = _t;
06623 match(_t,ASYNCHRONOUS_SELECT);
06624 _t = _t->getFirstChild();
06625
triggering_alternative(_t);
06626 _t = _retTree;
06627
abortable_part(_t);
06628 _t = _retTree;
06629 _t = __t401;
06630 _t = _t->getNextSibling();
06631
break;
06632 }
06633
case SELECTIVE_ACCEPT:
06634 {
06635
ANTLR_USE_NAMESPACE(antlr)
RefAST __t402 = _t;
06636
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp229_AST_in = _t;
06637 match(_t,SELECTIVE_ACCEPT);
06638 _t = _t->getFirstChild();
06639
selective_accept(_t);
06640 _t = _retTree;
06641 _t = __t402;
06642 _t = _t->getNextSibling();
06643
break;
06644 }
06645
case TIMED_ENTRY_CALL:
06646 {
06647
ANTLR_USE_NAMESPACE(antlr)
RefAST __t403 = _t;
06648
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp230_AST_in = _t;
06649 match(_t,TIMED_ENTRY_CALL);
06650 _t = _t->getFirstChild();
06651
entry_call_alternative(_t);
06652 _t = _retTree;
06653
delay_alternative(_t);
06654 _t = _retTree;
06655 _t = __t403;
06656 _t = _t->getNextSibling();
06657
break;
06658 }
06659
case CONDITIONAL_ENTRY_CALL:
06660 {
06661
ANTLR_USE_NAMESPACE(antlr)
RefAST __t404 = _t;
06662
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp231_AST_in = _t;
06663 match(_t,CONDITIONAL_ENTRY_CALL);
06664 _t = _t->getFirstChild();
06665
entry_call_alternative(_t);
06666 _t = _retTree;
06667
statements(_t);
06668 _t = _retTree;
06669 _t = __t404;
06670 _t = _t->getNextSibling();
06671
break;
06672 }
06673
default:
06674 {
06675
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06676 }
06677 }
06678 }
06679
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06680 reportError(ex);
06681
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06682 _t = _t->getNextSibling();
06683 }
06684 _retTree = _t;
06685 }
06686
06687 void AdaTreeParserSuper::if_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06688
ANTLR_USE_NAMESPACE(antlr)
RefAST if_stmt_AST_in = _t;
06689
06690
try {
06691
ANTLR_USE_NAMESPACE(antlr)
RefAST __t340 = _t;
06692
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp232_AST_in = _t;
06693 match(_t,IF_STATEMENT);
06694 _t = _t->getFirstChild();
06695
cond_clause(_t);
06696 _t = _retTree;
06697
elsifs_opt(_t);
06698 _t = _retTree;
06699
else_opt(_t);
06700 _t = _retTree;
06701 _t = __t340;
06702 _t = _t->getNextSibling();
06703 }
06704
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06705 reportError(ex);
06706
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06707 _t = _t->getNextSibling();
06708 }
06709 _retTree = _t;
06710 }
06711
06712 void AdaTreeParserSuper::case_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06713
ANTLR_USE_NAMESPACE(antlr)
RefAST case_stmt_AST_in = _t;
06714
06715
try {
06716
ANTLR_USE_NAMESPACE(antlr)
RefAST __t352 = _t;
06717
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp233_AST_in = _t;
06718 match(_t,CASE_STATEMENT);
06719 _t = _t->getFirstChild();
06720
expression(_t);
06721 _t = _retTree;
06722
alternative_s(_t);
06723 _t = _retTree;
06724 _t = __t352;
06725 _t = _t->getNextSibling();
06726 }
06727
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06728 reportError(ex);
06729
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06730 _t = _t->getNextSibling();
06731 }
06732 _retTree = _t;
06733 }
06734
06735 void AdaTreeParserSuper::loop_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06736
ANTLR_USE_NAMESPACE(antlr)
RefAST loop_stmt_AST_in = _t;
06737
06738
try {
06739
ANTLR_USE_NAMESPACE(antlr)
RefAST __t359 = _t;
06740
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp234_AST_in = _t;
06741 match(_t,LOOP_STATEMENT);
06742 _t = _t->getFirstChild();
06743
iteration_scheme_opt(_t);
06744 _t = _retTree;
06745
statements(_t);
06746 _t = _retTree;
06747 _t = __t359;
06748 _t = _t->getNextSibling();
06749 }
06750
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06751 reportError(ex);
06752
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06753 _t = _t->getNextSibling();
06754 }
06755 _retTree = _t;
06756 }
06757
06758 void AdaTreeParserSuper::block(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06759
ANTLR_USE_NAMESPACE(antlr)
RefAST block_AST_in = _t;
06760
06761
try {
06762
ANTLR_USE_NAMESPACE(antlr)
RefAST __t366 = _t;
06763
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp235_AST_in = _t;
06764 match(_t,BLOCK_STATEMENT);
06765 _t = _t->getFirstChild();
06766
declare_opt(_t);
06767 _t = _retTree;
06768
block_body(_t);
06769 _t = _retTree;
06770 _t = __t366;
06771 _t = _t->getNextSibling();
06772 }
06773
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06774 reportError(ex);
06775
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06776 _t = _t->getNextSibling();
06777 }
06778 _retTree = _t;
06779 }
06780
06781 void AdaTreeParserSuper::call_or_assignment(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06782
ANTLR_USE_NAMESPACE(antlr)
RefAST call_or_assignment_AST_in = _t;
06783
06784
try {
06785
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06786 _t = ASTNULL;
06787
switch ( _t->getType()) {
06788
case ASSIGNMENT_STATEMENT:
06789 {
06790
ANTLR_USE_NAMESPACE(antlr)
RefAST __t381 = _t;
06791
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp236_AST_in = _t;
06792 match(_t,ASSIGNMENT_STATEMENT);
06793 _t = _t->getFirstChild();
06794
name(_t);
06795 _t = _retTree;
06796
expression(_t);
06797 _t = _retTree;
06798 _t = __t381;
06799 _t = _t->getNextSibling();
06800
break;
06801 }
06802
case CALL_STATEMENT:
06803 {
06804
ANTLR_USE_NAMESPACE(antlr)
RefAST __t382 = _t;
06805
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp237_AST_in = _t;
06806 match(_t,CALL_STATEMENT);
06807 _t = _t->getFirstChild();
06808
name(_t);
06809 _t = _retTree;
06810 _t = __t382;
06811 _t = _t->getNextSibling();
06812
break;
06813 }
06814
default:
06815 {
06816
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06817 }
06818 }
06819 }
06820
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06821 reportError(ex);
06822
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06823 _t = _t->getNextSibling();
06824 }
06825 _retTree = _t;
06826 }
06827
06828 void AdaTreeParserSuper::cond_clause(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06829
ANTLR_USE_NAMESPACE(antlr)
RefAST cond_clause_AST_in = _t;
06830
06831
try {
06832
ANTLR_USE_NAMESPACE(antlr)
RefAST __t342 = _t;
06833
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp238_AST_in = _t;
06834 match(_t,COND_CLAUSE);
06835 _t = _t->getFirstChild();
06836
condition(_t);
06837 _t = _retTree;
06838
statements(_t);
06839 _t = _retTree;
06840 _t = __t342;
06841 _t = _t->getNextSibling();
06842 }
06843
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06844 reportError(ex);
06845
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06846 _t = _t->getNextSibling();
06847 }
06848 _retTree = _t;
06849 }
06850
06851 void AdaTreeParserSuper::elsifs_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06852
ANTLR_USE_NAMESPACE(antlr)
RefAST elsifs_opt_AST_in = _t;
06853
06854
try {
06855
ANTLR_USE_NAMESPACE(antlr)
RefAST __t345 = _t;
06856
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp239_AST_in = _t;
06857 match(_t,ELSIFS_OPT);
06858 _t = _t->getFirstChild();
06859 {
06860
for (;;) {
06861
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06862 _t = ASTNULL;
06863
if ((_t->getType() == COND_CLAUSE)) {
06864
cond_clause(_t);
06865 _t = _retTree;
06866 }
06867
else {
06868
goto _loop347;
06869 }
06870
06871 }
06872 _loop347:;
06873 }
06874 _t = __t345;
06875 _t = _t->getNextSibling();
06876 }
06877
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06878 reportError(ex);
06879
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06880 _t = _t->getNextSibling();
06881 }
06882 _retTree = _t;
06883 }
06884
06885 void AdaTreeParserSuper::else_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06886
ANTLR_USE_NAMESPACE(antlr)
RefAST else_opt_AST_in = _t;
06887
06888
try {
06889
ANTLR_USE_NAMESPACE(antlr)
RefAST __t349 = _t;
06890
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp240_AST_in = _t;
06891 match(_t,ELSE_OPT);
06892 _t = _t->getFirstChild();
06893 {
06894
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06895 _t = ASTNULL;
06896
switch ( _t->getType()) {
06897
case SEQUENCE_OF_STATEMENTS:
06898 {
06899
statements(_t);
06900 _t = _retTree;
06901
break;
06902 }
06903
case 3:
06904 {
06905
break;
06906 }
06907
default:
06908 {
06909
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
06910 }
06911 }
06912 }
06913 _t = __t349;
06914 _t = _t->getNextSibling();
06915 }
06916
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06917 reportError(ex);
06918
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06919 _t = _t->getNextSibling();
06920 }
06921 _retTree = _t;
06922 }
06923
06924 void AdaTreeParserSuper::condition(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06925
ANTLR_USE_NAMESPACE(antlr)
RefAST condition_AST_in = _t;
06926
06927
try {
06928
expression(_t);
06929 _t = _retTree;
06930 }
06931
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06932 reportError(ex);
06933
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06934 _t = _t->getNextSibling();
06935 }
06936 _retTree = _t;
06937 }
06938
06939 void AdaTreeParserSuper::alternative_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06940
ANTLR_USE_NAMESPACE(antlr)
RefAST alternative_s_AST_in = _t;
06941
06942
try {
06943 {
06944
int _cnt355=0;
06945
for (;;) {
06946
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06947 _t = ASTNULL;
06948
if ((_t->getType() == CASE_STATEMENT_ALTERNATIVE)) {
06949
case_statement_alternative(_t);
06950 _t = _retTree;
06951 }
06952
else {
06953
if ( _cnt355>=1 ) {
goto _loop355; }
else {
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);}
06954 }
06955
06956 _cnt355++;
06957 }
06958 _loop355:;
06959 }
06960 }
06961
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06962 reportError(ex);
06963
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06964 _t = _t->getNextSibling();
06965 }
06966 _retTree = _t;
06967 }
06968
06969 void AdaTreeParserSuper::case_statement_alternative(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06970
ANTLR_USE_NAMESPACE(antlr)
RefAST case_statement_alternative_AST_in = _t;
06971
06972
try {
06973
ANTLR_USE_NAMESPACE(antlr)
RefAST __t357 = _t;
06974
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp241_AST_in = _t;
06975 match(_t,CASE_STATEMENT_ALTERNATIVE);
06976 _t = _t->getFirstChild();
06977
choice_s(_t);
06978 _t = _retTree;
06979
statements(_t);
06980 _t = _retTree;
06981 _t = __t357;
06982 _t = _t->getNextSibling();
06983 }
06984
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
06985 reportError(ex);
06986
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
06987 _t = _t->getNextSibling();
06988 }
06989 _retTree = _t;
06990 }
06991
06992 void AdaTreeParserSuper::iteration_scheme_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
06993
ANTLR_USE_NAMESPACE(antlr)
RefAST iteration_scheme_opt_AST_in = _t;
06994
06995
try {
06996
ANTLR_USE_NAMESPACE(antlr)
RefAST __t361 = _t;
06997
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp242_AST_in = _t;
06998 match(_t,ITERATION_SCHEME_OPT);
06999 _t = _t->getFirstChild();
07000 {
07001
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07002 _t = ASTNULL;
07003
switch ( _t->getType()) {
07004
case WHILE:
07005 {
07006
ANTLR_USE_NAMESPACE(antlr)
RefAST __t363 = _t;
07007
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp243_AST_in = _t;
07008 match(_t,WHILE);
07009 _t = _t->getFirstChild();
07010
condition(_t);
07011 _t = _retTree;
07012 _t = __t363;
07013 _t = _t->getNextSibling();
07014
break;
07015 }
07016
case FOR:
07017 {
07018
ANTLR_USE_NAMESPACE(antlr)
RefAST __t364 = _t;
07019
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp244_AST_in = _t;
07020 match(_t,FOR);
07021 _t = _t->getFirstChild();
07022
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp245_AST_in = _t;
07023 match(_t,IDENTIFIER);
07024 _t = _t->getNextSibling();
07025
modifiers(_t);
07026 _t = _retTree;
07027
discrete_subtype_definition(_t);
07028 _t = _retTree;
07029 _t = __t364;
07030 _t = _t->getNextSibling();
07031
break;
07032 }
07033
case 3:
07034 {
07035
break;
07036 }
07037
default:
07038 {
07039
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07040 }
07041 }
07042 }
07043 _t = __t361;
07044 _t = _t->getNextSibling();
07045 }
07046
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07047 reportError(ex);
07048
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07049 _t = _t->getNextSibling();
07050 }
07051 _retTree = _t;
07052 }
07053
07054 void AdaTreeParserSuper::declare_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07055
ANTLR_USE_NAMESPACE(antlr)
RefAST declare_opt_AST_in = _t;
07056
07057
try {
07058
ANTLR_USE_NAMESPACE(antlr)
RefAST __t368 = _t;
07059
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp246_AST_in = _t;
07060 match(_t,DECLARE_OPT);
07061 _t = _t->getFirstChild();
07062 {
07063
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07064 _t = ASTNULL;
07065
switch ( _t->getType()) {
07066
case DECLARATIVE_PART:
07067 {
07068
declarative_part(_t);
07069 _t = _retTree;
07070
break;
07071 }
07072
case 3:
07073 {
07074
break;
07075 }
07076
default:
07077 {
07078
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07079 }
07080 }
07081 }
07082 _t = __t368;
07083 _t = _t->getNextSibling();
07084 }
07085
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07086 reportError(ex);
07087
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07088 _t = _t->getNextSibling();
07089 }
07090 _retTree = _t;
07091 }
07092
07093 void AdaTreeParserSuper::label_name(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07094
ANTLR_USE_NAMESPACE(antlr)
RefAST label_name_AST_in = _t;
07095
07096
try {
07097
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp247_AST_in = _t;
07098 match(_t,IDENTIFIER);
07099 _t = _t->getNextSibling();
07100 }
07101
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07102 reportError(ex);
07103
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07104 _t = _t->getNextSibling();
07105 }
07106 _retTree = _t;
07107 }
07108
07109 void AdaTreeParserSuper::entry_body_formal_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07110
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_body_formal_part_AST_in = _t;
07111
07112
try {
07113
entry_index_spec_opt(_t);
07114 _t = _retTree;
07115
formal_part_opt(_t);
07116 _t = _retTree;
07117 }
07118
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07119 reportError(ex);
07120
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07121 _t = _t->getNextSibling();
07122 }
07123 _retTree = _t;
07124 }
07125
07126 void AdaTreeParserSuper::entry_barrier(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07127
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_barrier_AST_in = _t;
07128
07129
try {
07130
condition(_t);
07131 _t = _retTree;
07132 }
07133
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07134 reportError(ex);
07135
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07136 _t = _t->getNextSibling();
07137 }
07138 _retTree = _t;
07139 }
07140
07141 void AdaTreeParserSuper::entry_index_spec_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07142
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_index_spec_opt_AST_in = _t;
07143
07144
try {
07145
ANTLR_USE_NAMESPACE(antlr)
RefAST __t387 = _t;
07146
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp248_AST_in = _t;
07147 match(_t,ENTRY_INDEX_SPECIFICATION);
07148 _t = _t->getFirstChild();
07149 {
07150
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07151 _t = ASTNULL;
07152
switch ( _t->getType()) {
07153
case IDENTIFIER:
07154
case DOT:
07155 {
07156
def_id(_t);
07157 _t = _retTree;
07158
discrete_subtype_definition(_t);
07159 _t = _retTree;
07160
break;
07161 }
07162
case 3:
07163 {
07164
break;
07165 }
07166
default:
07167 {
07168
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07169 }
07170 }
07171 }
07172 _t = __t387;
07173 _t = _t->getNextSibling();
07174 }
07175
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07176 reportError(ex);
07177
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07178 _t = _t->getNextSibling();
07179 }
07180 _retTree = _t;
07181 }
07182
07183 void AdaTreeParserSuper::entry_call_stmt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07184
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_call_stmt_AST_in = _t;
07185
07186
try {
07187
ANTLR_USE_NAMESPACE(antlr)
RefAST __t391 = _t;
07188
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp249_AST_in = _t;
07189 match(_t,ENTRY_CALL_STATEMENT);
07190 _t = _t->getFirstChild();
07191
name(_t);
07192 _t = _retTree;
07193 _t = __t391;
07194 _t = _t->getNextSibling();
07195 }
07196
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07197 reportError(ex);
07198
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07199 _t = _t->getNextSibling();
07200 }
07201 _retTree = _t;
07202 }
07203
07204 void AdaTreeParserSuper::entry_index_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07205
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_index_opt_AST_in = _t;
07206
07207
try {
07208
ANTLR_USE_NAMESPACE(antlr)
RefAST __t396 = _t;
07209
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp250_AST_in = _t;
07210 match(_t,ENTRY_INDEX_OPT);
07211 _t = _t->getFirstChild();
07212 {
07213
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07214 _t = ASTNULL;
07215
switch ( _t->getType()) {
07216
case IDENTIFIER:
07217
case DOT:
07218
case TIC:
07219
case IN:
07220
case CHARACTER_LITERAL:
07221
case CHAR_STRING:
07222
case NuLL:
07223
case MOD:
07224
case OR:
07225
case AND:
07226
case XOR:
07227
case NOT:
07228
case EQ:
07229
case NE:
07230
case LT_:
07231
case LE:
07232
case GT:
07233
case GE:
07234
case PLUS:
07235
case MINUS:
07236
case CONCAT:
07237
case STAR:
07238
case DIV:
07239
case REM:
07240
case ABS:
07241
case EXPON:
07242
case NUMERIC_LIT:
07243
case ALLOCATOR:
07244
case INDEXED_COMPONENT:
07245
case OPERATOR_SYMBOL:
07246
case AND_THEN:
07247
case NOT_IN:
07248
case OR_ELSE:
07249
case PARENTHESIZED_PRIMARY:
07250
case UNARY_MINUS:
07251
case UNARY_PLUS:
07252 {
07253
expression(_t);
07254 _t = _retTree;
07255
break;
07256 }
07257
case 3:
07258 {
07259
break;
07260 }
07261
default:
07262 {
07263
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07264 }
07265 }
07266 }
07267 _t = __t396;
07268 _t = _t->getNextSibling();
07269 }
07270
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07271 reportError(ex);
07272
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07273 _t = _t->getNextSibling();
07274 }
07275 _retTree = _t;
07276 }
07277
07278 void AdaTreeParserSuper::triggering_alternative(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07279
ANTLR_USE_NAMESPACE(antlr)
RefAST triggering_alternative_AST_in = _t;
07280
07281
try {
07282
ANTLR_USE_NAMESPACE(antlr)
RefAST __t406 = _t;
07283
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp251_AST_in = _t;
07284 match(_t,TRIGGERING_ALTERNATIVE);
07285 _t = _t->getFirstChild();
07286 {
07287
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07288 _t = ASTNULL;
07289
switch ( _t->getType()) {
07290
case DELAY_STATEMENT:
07291 {
07292
delay_stmt(_t);
07293 _t = _retTree;
07294
break;
07295 }
07296
case ENTRY_CALL_STATEMENT:
07297 {
07298
entry_call_stmt(_t);
07299 _t = _retTree;
07300
break;
07301 }
07302
default:
07303 {
07304
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07305 }
07306 }
07307 }
07308
stmts_opt(_t);
07309 _t = _retTree;
07310 _t = __t406;
07311 _t = _t->getNextSibling();
07312 }
07313
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07314 reportError(ex);
07315
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07316 _t = _t->getNextSibling();
07317 }
07318 _retTree = _t;
07319 }
07320
07321 void AdaTreeParserSuper::abortable_part(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07322
ANTLR_USE_NAMESPACE(antlr)
RefAST abortable_part_AST_in = _t;
07323
07324
try {
07325
ANTLR_USE_NAMESPACE(antlr)
RefAST __t409 = _t;
07326
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp252_AST_in = _t;
07327 match(_t,ABORTABLE_PART);
07328 _t = _t->getFirstChild();
07329
stmts_opt(_t);
07330 _t = _retTree;
07331 _t = __t409;
07332 _t = _t->getNextSibling();
07333 }
07334
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07335 reportError(ex);
07336
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07337 _t = _t->getNextSibling();
07338 }
07339 _retTree = _t;
07340 }
07341
07342 void AdaTreeParserSuper::selective_accept(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07343
ANTLR_USE_NAMESPACE(antlr)
RefAST selective_accept_AST_in = _t;
07344
07345
try {
07346
guard_opt(_t);
07347 _t = _retTree;
07348
select_alternative(_t);
07349 _t = _retTree;
07350
or_select_opt(_t);
07351 _t = _retTree;
07352
else_opt(_t);
07353 _t = _retTree;
07354 }
07355
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07356 reportError(ex);
07357
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07358 _t = _t->getNextSibling();
07359 }
07360 _retTree = _t;
07361 }
07362
07363 void AdaTreeParserSuper::entry_call_alternative(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07364
ANTLR_USE_NAMESPACE(antlr)
RefAST entry_call_alternative_AST_in = _t;
07365
07366
try {
07367
ANTLR_USE_NAMESPACE(antlr)
RefAST __t411 = _t;
07368
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp253_AST_in = _t;
07369 match(_t,ENTRY_CALL_ALTERNATIVE);
07370 _t = _t->getFirstChild();
07371
entry_call_stmt(_t);
07372 _t = _retTree;
07373
stmts_opt(_t);
07374 _t = _retTree;
07375 _t = __t411;
07376 _t = _t->getNextSibling();
07377 }
07378
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07379 reportError(ex);
07380
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07381 _t = _t->getNextSibling();
07382 }
07383 _retTree = _t;
07384 }
07385
07386 void AdaTreeParserSuper::delay_alternative(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07387
ANTLR_USE_NAMESPACE(antlr)
RefAST delay_alternative_AST_in = _t;
07388
07389
try {
07390
ANTLR_USE_NAMESPACE(antlr)
RefAST __t422 = _t;
07391
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp254_AST_in = _t;
07392 match(_t,DELAY_ALTERNATIVE);
07393 _t = _t->getFirstChild();
07394
delay_stmt(_t);
07395 _t = _retTree;
07396
stmts_opt(_t);
07397 _t = _retTree;
07398 _t = __t422;
07399 _t = _t->getNextSibling();
07400 }
07401
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07402 reportError(ex);
07403
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07404 _t = _t->getNextSibling();
07405 }
07406 _retTree = _t;
07407 }
07408
07409 void AdaTreeParserSuper::stmts_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07410
ANTLR_USE_NAMESPACE(antlr)
RefAST stmts_opt_AST_in = _t;
07411
07412
try {
07413 {
07414
for (;;) {
07415
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07416 _t = ASTNULL;
07417
switch ( _t->getType()) {
07418
case PRAGMA:
07419 {
07420
pragma(_t);
07421 _t = _retTree;
07422
break;
07423 }
07424
case STATEMENT:
07425 {
07426
statement(_t);
07427 _t = _retTree;
07428
break;
07429 }
07430
default:
07431 {
07432
goto _loop425;
07433 }
07434 }
07435 }
07436 _loop425:;
07437 }
07438 }
07439
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07440 reportError(ex);
07441
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07442 _t = _t->getNextSibling();
07443 }
07444 _retTree = _t;
07445 }
07446
07447 void AdaTreeParserSuper::guard_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07448
ANTLR_USE_NAMESPACE(antlr)
RefAST guard_opt_AST_in = _t;
07449
07450
try {
07451
ANTLR_USE_NAMESPACE(antlr)
RefAST __t414 = _t;
07452
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp255_AST_in = _t;
07453 match(_t,GUARD_OPT);
07454 _t = _t->getFirstChild();
07455 {
07456
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07457 _t = ASTNULL;
07458
switch ( _t->getType()) {
07459
case IDENTIFIER:
07460
case DOT:
07461
case TIC:
07462
case IN:
07463
case CHARACTER_LITERAL:
07464
case CHAR_STRING:
07465
case NuLL:
07466
case MOD:
07467
case OR:
07468
case AND:
07469
case XOR:
07470
case NOT:
07471
case EQ:
07472
case NE:
07473
case LT_:
07474
case LE:
07475
case GT:
07476
case GE:
07477
case PLUS:
07478
case MINUS:
07479
case CONCAT:
07480
case STAR:
07481
case DIV:
07482
case REM:
07483
case ABS:
07484
case EXPON:
07485
case NUMERIC_LIT:
07486
case ALLOCATOR:
07487
case INDEXED_COMPONENT:
07488
case OPERATOR_SYMBOL:
07489
case AND_THEN:
07490
case NOT_IN:
07491
case OR_ELSE:
07492
case PARENTHESIZED_PRIMARY:
07493
case UNARY_MINUS:
07494
case UNARY_PLUS:
07495 {
07496
condition(_t);
07497 _t = _retTree;
07498 {
07499
for (;;) {
07500
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07501 _t = ASTNULL;
07502
if ((_t->getType() == PRAGMA)) {
07503
pragma(_t);
07504 _t = _retTree;
07505 }
07506
else {
07507
goto _loop417;
07508 }
07509
07510 }
07511 _loop417:;
07512 }
07513
break;
07514 }
07515
case 3:
07516 {
07517
break;
07518 }
07519
default:
07520 {
07521
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07522 }
07523 }
07524 }
07525 _t = __t414;
07526 _t = _t->getNextSibling();
07527 }
07528
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07529 reportError(ex);
07530
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07531 _t = _t->getNextSibling();
07532 }
07533 _retTree = _t;
07534 }
07535
07536 void AdaTreeParserSuper::select_alternative(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07537
ANTLR_USE_NAMESPACE(antlr)
RefAST select_alternative_AST_in = _t;
07538
07539
try {
07540
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07541 _t = ASTNULL;
07542
switch ( _t->getType()) {
07543
case ACCEPT_ALTERNATIVE:
07544 {
07545
accept_alternative(_t);
07546 _t = _retTree;
07547
break;
07548 }
07549
case DELAY_ALTERNATIVE:
07550 {
07551
delay_alternative(_t);
07552 _t = _retTree;
07553
break;
07554 }
07555
case TERMINATE_ALTERNATIVE:
07556 {
07557
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp256_AST_in = _t;
07558 match(_t,TERMINATE_ALTERNATIVE);
07559 _t = _t->getNextSibling();
07560
break;
07561 }
07562
default:
07563 {
07564
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07565 }
07566 }
07567 }
07568
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07569 reportError(ex);
07570
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07571 _t = _t->getNextSibling();
07572 }
07573 _retTree = _t;
07574 }
07575
07576 void AdaTreeParserSuper::or_select_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07577
ANTLR_USE_NAMESPACE(antlr)
RefAST or_select_opt_AST_in = _t;
07578
07579
try {
07580
ANTLR_USE_NAMESPACE(antlr)
RefAST __t427 = _t;
07581
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp257_AST_in = _t;
07582 match(_t,OR_SELECT_OPT);
07583 _t = _t->getFirstChild();
07584 {
07585
for (;;) {
07586
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07587 _t = ASTNULL;
07588
if ((_t->getType() == GUARD_OPT)) {
07589
guard_opt(_t);
07590 _t = _retTree;
07591
select_alternative(_t);
07592 _t = _retTree;
07593 }
07594
else {
07595
goto _loop429;
07596 }
07597
07598 }
07599 _loop429:;
07600 }
07601 _t = __t427;
07602 _t = _t->getNextSibling();
07603 }
07604
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07605 reportError(ex);
07606
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07607 _t = _t->getNextSibling();
07608 }
07609 _retTree = _t;
07610 }
07611
07612 void AdaTreeParserSuper::accept_alternative(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07613
ANTLR_USE_NAMESPACE(antlr)
RefAST accept_alternative_AST_in = _t;
07614
07615
try {
07616
ANTLR_USE_NAMESPACE(antlr)
RefAST __t420 = _t;
07617
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp258_AST_in = _t;
07618 match(_t,ACCEPT_ALTERNATIVE);
07619 _t = _t->getFirstChild();
07620
accept_stmt(_t);
07621 _t = _retTree;
07622
stmts_opt(_t);
07623 _t = _retTree;
07624 _t = __t420;
07625 _t = _t->getNextSibling();
07626 }
07627
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07628 reportError(ex);
07629
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07630 _t = _t->getNextSibling();
07631 }
07632 _retTree = _t;
07633 }
07634
07635 void AdaTreeParserSuper::exception_handler(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07636
ANTLR_USE_NAMESPACE(antlr)
RefAST exception_handler_AST_in = _t;
07637
07638
try {
07639
ANTLR_USE_NAMESPACE(antlr)
RefAST __t439 = _t;
07640
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp259_AST_in = _t;
07641 match(_t,EXCEPTION_HANDLER);
07642 _t = _t->getFirstChild();
07643
identifier_colon_opt(_t);
07644 _t = _retTree;
07645
except_choice_s(_t);
07646 _t = _retTree;
07647
statements(_t);
07648 _t = _retTree;
07649 _t = __t439;
07650 _t = _t->getNextSibling();
07651 }
07652
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07653 reportError(ex);
07654
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07655 _t = _t->getNextSibling();
07656 }
07657 _retTree = _t;
07658 }
07659
07660 void AdaTreeParserSuper::identifier_colon_opt(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07661
ANTLR_USE_NAMESPACE(antlr)
RefAST identifier_colon_opt_AST_in = _t;
07662
07663
try {
07664
ANTLR_USE_NAMESPACE(antlr)
RefAST __t441 = _t;
07665
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp260_AST_in = _t;
07666 match(_t,IDENTIFIER_COLON_OPT);
07667 _t = _t->getFirstChild();
07668 {
07669
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07670 _t = ASTNULL;
07671
switch ( _t->getType()) {
07672
case IDENTIFIER:
07673 {
07674
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp261_AST_in = _t;
07675 match(_t,IDENTIFIER);
07676 _t = _t->getNextSibling();
07677
break;
07678 }
07679
case 3:
07680 {
07681
break;
07682 }
07683
default:
07684 {
07685
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07686 }
07687 }
07688 }
07689 _t = __t441;
07690 _t = _t->getNextSibling();
07691 }
07692
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07693 reportError(ex);
07694
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07695 _t = _t->getNextSibling();
07696 }
07697 _retTree = _t;
07698 }
07699
07700 void AdaTreeParserSuper::except_choice_s(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07701
ANTLR_USE_NAMESPACE(antlr)
RefAST except_choice_s_AST_in = _t;
07702
07703
try {
07704
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07705 _t = ASTNULL;
07706
switch ( _t->getType()) {
07707
case PIPE:
07708 {
07709
ANTLR_USE_NAMESPACE(antlr)
RefAST __t444 = _t;
07710
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp262_AST_in = _t;
07711 match(_t,PIPE);
07712 _t = _t->getFirstChild();
07713
except_choice_s(_t);
07714 _t = _retTree;
07715
exception_choice(_t);
07716 _t = _retTree;
07717 _t = __t444;
07718 _t = _t->getNextSibling();
07719
break;
07720 }
07721
case IDENTIFIER:
07722
case DOT:
07723
case OTHERS:
07724 {
07725
exception_choice(_t);
07726 _t = _retTree;
07727
break;
07728 }
07729
default:
07730 {
07731
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07732 }
07733 }
07734 }
07735
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07736 reportError(ex);
07737
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07738 _t = _t->getNextSibling();
07739 }
07740 _retTree = _t;
07741 }
07742
07743 void AdaTreeParserSuper::exception_choice(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07744
ANTLR_USE_NAMESPACE(antlr)
RefAST exception_choice_AST_in = _t;
07745
07746
try {
07747
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07748 _t = ASTNULL;
07749
switch ( _t->getType()) {
07750
case IDENTIFIER:
07751
case DOT:
07752 {
07753
compound_name(_t);
07754 _t = _retTree;
07755
break;
07756 }
07757
case OTHERS:
07758 {
07759
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp263_AST_in = _t;
07760 match(_t,OTHERS);
07761 _t = _t->getNextSibling();
07762
break;
07763 }
07764
default:
07765 {
07766
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07767 }
07768 }
07769 }
07770
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07771 reportError(ex);
07772
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07773 _t = _t->getNextSibling();
07774 }
07775 _retTree = _t;
07776 }
07777
07778 void AdaTreeParserSuper::operator_call(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07779
ANTLR_USE_NAMESPACE(antlr)
RefAST operator_call_AST_in = _t;
07780
07781
try {
07782
ANTLR_USE_NAMESPACE(antlr)
RefAST __t453 = _t;
07783
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp264_AST_in = _t;
07784 match(_t,OPERATOR_SYMBOL);
07785 _t = _t->getFirstChild();
07786
value_s(_t);
07787 _t = _retTree;
07788 _t = __t453;
07789 _t = _t->getNextSibling();
07790 }
07791
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07792 reportError(ex);
07793
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07794 _t = _t->getNextSibling();
07795 }
07796 _retTree = _t;
07797 }
07798
07799 void AdaTreeParserSuper::relation(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07800
ANTLR_USE_NAMESPACE(antlr)
RefAST relation_AST_in = _t;
07801
07802
try {
07803
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07804 _t = ASTNULL;
07805
switch ( _t->getType()) {
07806
case IN:
07807 {
07808
ANTLR_USE_NAMESPACE(antlr)
RefAST __t465 = _t;
07809
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp265_AST_in = _t;
07810 match(_t,IN);
07811 _t = _t->getFirstChild();
07812
simple_expression(_t);
07813 _t = _retTree;
07814
range_or_mark(_t);
07815 _t = _retTree;
07816 _t = __t465;
07817 _t = _t->getNextSibling();
07818
break;
07819 }
07820
case NOT_IN:
07821 {
07822
ANTLR_USE_NAMESPACE(antlr)
RefAST __t466 = _t;
07823
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp266_AST_in = _t;
07824 match(_t,NOT_IN);
07825 _t = _t->getFirstChild();
07826
simple_expression(_t);
07827 _t = _retTree;
07828
range_or_mark(_t);
07829 _t = _retTree;
07830 _t = __t466;
07831 _t = _t->getNextSibling();
07832
break;
07833 }
07834
case EQ:
07835 {
07836
ANTLR_USE_NAMESPACE(antlr)
RefAST __t467 = _t;
07837
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp267_AST_in = _t;
07838 match(_t,EQ);
07839 _t = _t->getFirstChild();
07840
simple_expression(_t);
07841 _t = _retTree;
07842
simple_expression(_t);
07843 _t = _retTree;
07844 _t = __t467;
07845 _t = _t->getNextSibling();
07846
break;
07847 }
07848
case NE:
07849 {
07850
ANTLR_USE_NAMESPACE(antlr)
RefAST __t468 = _t;
07851
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp268_AST_in = _t;
07852 match(_t,NE);
07853 _t = _t->getFirstChild();
07854
simple_expression(_t);
07855 _t = _retTree;
07856
simple_expression(_t);
07857 _t = _retTree;
07858 _t = __t468;
07859 _t = _t->getNextSibling();
07860
break;
07861 }
07862
case LT_:
07863 {
07864
ANTLR_USE_NAMESPACE(antlr)
RefAST __t469 = _t;
07865
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp269_AST_in = _t;
07866 match(_t,LT_);
07867 _t = _t->getFirstChild();
07868
simple_expression(_t);
07869 _t = _retTree;
07870
simple_expression(_t);
07871 _t = _retTree;
07872 _t = __t469;
07873 _t = _t->getNextSibling();
07874
break;
07875 }
07876
case LE:
07877 {
07878
ANTLR_USE_NAMESPACE(antlr)
RefAST __t470 = _t;
07879
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp270_AST_in = _t;
07880 match(_t,LE);
07881 _t = _t->getFirstChild();
07882
simple_expression(_t);
07883 _t = _retTree;
07884
simple_expression(_t);
07885 _t = _retTree;
07886 _t = __t470;
07887 _t = _t->getNextSibling();
07888
break;
07889 }
07890
case GT:
07891 {
07892
ANTLR_USE_NAMESPACE(antlr)
RefAST __t471 = _t;
07893
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp271_AST_in = _t;
07894 match(_t,GT);
07895 _t = _t->getFirstChild();
07896
simple_expression(_t);
07897 _t = _retTree;
07898
simple_expression(_t);
07899 _t = _retTree;
07900 _t = __t471;
07901 _t = _t->getNextSibling();
07902
break;
07903 }
07904
case GE:
07905 {
07906
ANTLR_USE_NAMESPACE(antlr)
RefAST __t472 = _t;
07907
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp272_AST_in = _t;
07908 match(_t,GE);
07909 _t = _t->getFirstChild();
07910
simple_expression(_t);
07911 _t = _retTree;
07912
simple_expression(_t);
07913 _t = _retTree;
07914 _t = __t472;
07915 _t = _t->getNextSibling();
07916
break;
07917 }
07918
case IDENTIFIER:
07919
case DOT:
07920
case TIC:
07921
case CHARACTER_LITERAL:
07922
case CHAR_STRING:
07923
case NuLL:
07924
case MOD:
07925
case NOT:
07926
case PLUS:
07927
case MINUS:
07928
case CONCAT:
07929
case STAR:
07930
case DIV:
07931
case REM:
07932
case ABS:
07933
case EXPON:
07934
case NUMERIC_LIT:
07935
case ALLOCATOR:
07936
case INDEXED_COMPONENT:
07937
case OPERATOR_SYMBOL:
07938
case PARENTHESIZED_PRIMARY:
07939
case UNARY_MINUS:
07940
case UNARY_PLUS:
07941 {
07942
simple_expression(_t);
07943 _t = _retTree;
07944
break;
07945 }
07946
default:
07947 {
07948
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07949 }
07950 }
07951 }
07952
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07953 reportError(ex);
07954
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07955 _t = _t->getNextSibling();
07956 }
07957 _retTree = _t;
07958 }
07959
07960 void AdaTreeParserSuper::range_or_mark(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07961
ANTLR_USE_NAMESPACE(antlr)
RefAST range_or_mark_AST_in = _t;
07962
07963
try {
07964
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07965 _t = ASTNULL;
07966
switch ( _t->getType()) {
07967
case DOT_DOT:
07968
case RANGE_ATTRIBUTE_REFERENCE:
07969 {
07970
range(_t);
07971 _t = _retTree;
07972
break;
07973 }
07974
case IDENTIFIER:
07975
case DOT:
07976
case TIC:
07977 {
07978
subtype_mark(_t);
07979 _t = _retTree;
07980
break;
07981 }
07982
default:
07983 {
07984
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
07985 }
07986 }
07987 }
07988
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
07989 reportError(ex);
07990
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
07991 _t = _t->getNextSibling();
07992 }
07993 _retTree = _t;
07994 }
07995
07996 void AdaTreeParserSuper::signed_term(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
07997
ANTLR_USE_NAMESPACE(antlr)
RefAST signed_term_AST_in = _t;
07998
07999
try {
08000
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08001 _t = ASTNULL;
08002
switch ( _t->getType()) {
08003
case UNARY_PLUS:
08004 {
08005
ANTLR_USE_NAMESPACE(antlr)
RefAST __t479 = _t;
08006
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp273_AST_in = _t;
08007 match(_t,UNARY_PLUS);
08008 _t = _t->getFirstChild();
08009
term(_t);
08010 _t = _retTree;
08011 _t = __t479;
08012 _t = _t->getNextSibling();
08013
break;
08014 }
08015
case UNARY_MINUS:
08016 {
08017
ANTLR_USE_NAMESPACE(antlr)
RefAST __t480 = _t;
08018
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp274_AST_in = _t;
08019 match(_t,UNARY_MINUS);
08020 _t = _t->getFirstChild();
08021
term(_t);
08022 _t = _retTree;
08023 _t = __t480;
08024 _t = _t->getNextSibling();
08025
break;
08026 }
08027
case IDENTIFIER:
08028
case DOT:
08029
case TIC:
08030
case CHARACTER_LITERAL:
08031
case CHAR_STRING:
08032
case NuLL:
08033
case MOD:
08034
case NOT:
08035
case STAR:
08036
case DIV:
08037
case REM:
08038
case ABS:
08039
case EXPON:
08040
case NUMERIC_LIT:
08041
case ALLOCATOR:
08042
case INDEXED_COMPONENT:
08043
case OPERATOR_SYMBOL:
08044
case PARENTHESIZED_PRIMARY:
08045 {
08046
term(_t);
08047 _t = _retTree;
08048
break;
08049 }
08050
default:
08051 {
08052
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08053 }
08054 }
08055 }
08056
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08057 reportError(ex);
08058
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08059 _t = _t->getNextSibling();
08060 }
08061 _retTree = _t;
08062 }
08063
08064 void AdaTreeParserSuper::term(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08065
ANTLR_USE_NAMESPACE(antlr)
RefAST term_AST_in = _t;
08066
08067
try {
08068
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08069 _t = ASTNULL;
08070
switch ( _t->getType()) {
08071
case STAR:
08072 {
08073
ANTLR_USE_NAMESPACE(antlr)
RefAST __t482 = _t;
08074
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp275_AST_in = _t;
08075 match(_t,STAR);
08076 _t = _t->getFirstChild();
08077
term(_t);
08078 _t = _retTree;
08079
factor(_t);
08080 _t = _retTree;
08081 _t = __t482;
08082 _t = _t->getNextSibling();
08083
break;
08084 }
08085
case DIV:
08086 {
08087
ANTLR_USE_NAMESPACE(antlr)
RefAST __t483 = _t;
08088
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp276_AST_in = _t;
08089 match(_t,DIV);
08090 _t = _t->getFirstChild();
08091
term(_t);
08092 _t = _retTree;
08093
factor(_t);
08094 _t = _retTree;
08095 _t = __t483;
08096 _t = _t->getNextSibling();
08097
break;
08098 }
08099
case MOD:
08100 {
08101
ANTLR_USE_NAMESPACE(antlr)
RefAST __t484 = _t;
08102
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp277_AST_in = _t;
08103 match(_t,MOD);
08104 _t = _t->getFirstChild();
08105
term(_t);
08106 _t = _retTree;
08107
factor(_t);
08108 _t = _retTree;
08109 _t = __t484;
08110 _t = _t->getNextSibling();
08111
break;
08112 }
08113
case REM:
08114 {
08115
ANTLR_USE_NAMESPACE(antlr)
RefAST __t485 = _t;
08116
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp278_AST_in = _t;
08117 match(_t,REM);
08118 _t = _t->getFirstChild();
08119
term(_t);
08120 _t = _retTree;
08121
factor(_t);
08122 _t = _retTree;
08123 _t = __t485;
08124 _t = _t->getNextSibling();
08125
break;
08126 }
08127
case IDENTIFIER:
08128
case DOT:
08129
case TIC:
08130
case CHARACTER_LITERAL:
08131
case CHAR_STRING:
08132
case NuLL:
08133
case NOT:
08134
case ABS:
08135
case EXPON:
08136
case NUMERIC_LIT:
08137
case ALLOCATOR:
08138
case INDEXED_COMPONENT:
08139
case OPERATOR_SYMBOL:
08140
case PARENTHESIZED_PRIMARY:
08141 {
08142
factor(_t);
08143 _t = _retTree;
08144
break;
08145 }
08146
default:
08147 {
08148
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08149 }
08150 }
08151 }
08152
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08153 reportError(ex);
08154
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08155 _t = _t->getNextSibling();
08156 }
08157 _retTree = _t;
08158 }
08159
08160 void AdaTreeParserSuper::factor(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08161
ANTLR_USE_NAMESPACE(antlr)
RefAST factor_AST_in = _t;
08162
08163
try {
08164
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08165 _t = ASTNULL;
08166
switch ( _t->getType()) {
08167
case NOT:
08168 {
08169
ANTLR_USE_NAMESPACE(antlr)
RefAST __t487 = _t;
08170
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp279_AST_in = _t;
08171 match(_t,NOT);
08172 _t = _t->getFirstChild();
08173
primary(_t);
08174 _t = _retTree;
08175 _t = __t487;
08176 _t = _t->getNextSibling();
08177
break;
08178 }
08179
case ABS:
08180 {
08181
ANTLR_USE_NAMESPACE(antlr)
RefAST __t488 = _t;
08182
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp280_AST_in = _t;
08183 match(_t,ABS);
08184 _t = _t->getFirstChild();
08185
primary(_t);
08186 _t = _retTree;
08187 _t = __t488;
08188 _t = _t->getNextSibling();
08189
break;
08190 }
08191
case EXPON:
08192 {
08193
ANTLR_USE_NAMESPACE(antlr)
RefAST __t489 = _t;
08194
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp281_AST_in = _t;
08195 match(_t,EXPON);
08196 _t = _t->getFirstChild();
08197
primary(_t);
08198 _t = _retTree;
08199
primary(_t);
08200 _t = _retTree;
08201 _t = __t489;
08202 _t = _t->getNextSibling();
08203
break;
08204 }
08205
case IDENTIFIER:
08206
case DOT:
08207
case TIC:
08208
case CHARACTER_LITERAL:
08209
case CHAR_STRING:
08210
case NuLL:
08211
case NUMERIC_LIT:
08212
case ALLOCATOR:
08213
case INDEXED_COMPONENT:
08214
case OPERATOR_SYMBOL:
08215
case PARENTHESIZED_PRIMARY:
08216 {
08217
primary(_t);
08218 _t = _retTree;
08219
break;
08220 }
08221
default:
08222 {
08223
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08224 }
08225 }
08226 }
08227
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08228 reportError(ex);
08229
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08230 _t = _t->getNextSibling();
08231 }
08232 _retTree = _t;
08233 }
08234
08235 void AdaTreeParserSuper::primary(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08236
ANTLR_USE_NAMESPACE(antlr)
RefAST primary_AST_in = _t;
08237
08238
try {
08239 {
08240
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08241 _t = ASTNULL;
08242
switch ( _t->getType()) {
08243
case IDENTIFIER:
08244
case DOT:
08245
case TIC:
08246
case INDEXED_COMPONENT:
08247 {
08248
name_or_qualified(_t);
08249 _t = _retTree;
08250
break;
08251 }
08252
case PARENTHESIZED_PRIMARY:
08253 {
08254
parenthesized_primary(_t);
08255 _t = _retTree;
08256
break;
08257 }
08258
case ALLOCATOR:
08259 {
08260
allocator(_t);
08261 _t = _retTree;
08262
break;
08263 }
08264
case NuLL:
08265 {
08266
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp282_AST_in = _t;
08267 match(_t,NuLL);
08268 _t = _t->getNextSibling();
08269
break;
08270 }
08271
case NUMERIC_LIT:
08272 {
08273
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp283_AST_in = _t;
08274 match(_t,NUMERIC_LIT);
08275 _t = _t->getNextSibling();
08276
break;
08277 }
08278
case CHARACTER_LITERAL:
08279 {
08280
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp284_AST_in = _t;
08281 match(_t,CHARACTER_LITERAL);
08282 _t = _t->getNextSibling();
08283
break;
08284 }
08285
case CHAR_STRING:
08286 {
08287
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp285_AST_in = _t;
08288 match(_t,CHAR_STRING);
08289 _t = _t->getNextSibling();
08290
break;
08291 }
08292
case OPERATOR_SYMBOL:
08293 {
08294
operator_call(_t);
08295 _t = _retTree;
08296
break;
08297 }
08298
default:
08299 {
08300
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08301 }
08302 }
08303 }
08304 }
08305
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08306 reportError(ex);
08307
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08308 _t = _t->getNextSibling();
08309 }
08310 _retTree = _t;
08311 }
08312
08313 void AdaTreeParserSuper::name_or_qualified(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08314
ANTLR_USE_NAMESPACE(antlr)
RefAST name_or_qualified_AST_in = _t;
08315
08316
try {
08317
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08318 _t = ASTNULL;
08319
switch ( _t->getType()) {
08320
case IDENTIFIER:
08321 {
08322
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp286_AST_in = _t;
08323 match(_t,IDENTIFIER);
08324 _t = _t->getNextSibling();
08325
break;
08326 }
08327
case DOT:
08328 {
08329
ANTLR_USE_NAMESPACE(antlr)
RefAST __t493 = _t;
08330
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp287_AST_in = _t;
08331 match(_t,DOT);
08332 _t = _t->getFirstChild();
08333
name_or_qualified(_t);
08334 _t = _retTree;
08335 {
08336
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08337 _t = ASTNULL;
08338
switch ( _t->getType()) {
08339
case ALL:
08340 {
08341
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp288_AST_in = _t;
08342 match(_t,ALL);
08343 _t = _t->getNextSibling();
08344
break;
08345 }
08346
case IDENTIFIER:
08347 {
08348
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp289_AST_in = _t;
08349 match(_t,IDENTIFIER);
08350 _t = _t->getNextSibling();
08351
break;
08352 }
08353
case CHARACTER_LITERAL:
08354 {
08355
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp290_AST_in = _t;
08356 match(_t,CHARACTER_LITERAL);
08357 _t = _t->getNextSibling();
08358
break;
08359 }
08360
case OPERATOR_SYMBOL:
08361 {
08362
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp291_AST_in = _t;
08363 match(_t,OPERATOR_SYMBOL);
08364 _t = _t->getNextSibling();
08365
break;
08366 }
08367
default:
08368 {
08369
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08370 }
08371 }
08372 }
08373 _t = __t493;
08374 _t = _t->getNextSibling();
08375
break;
08376 }
08377
case INDEXED_COMPONENT:
08378 {
08379
ANTLR_USE_NAMESPACE(antlr)
RefAST __t495 = _t;
08380
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp292_AST_in = _t;
08381 match(_t,INDEXED_COMPONENT);
08382 _t = _t->getFirstChild();
08383
name_or_qualified(_t);
08384 _t = _retTree;
08385
value_s(_t);
08386 _t = _retTree;
08387 _t = __t495;
08388 _t = _t->getNextSibling();
08389
break;
08390 }
08391
case TIC:
08392 {
08393
ANTLR_USE_NAMESPACE(antlr)
RefAST __t496 = _t;
08394
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp293_AST_in = _t;
08395 match(_t,TIC);
08396 _t = _t->getFirstChild();
08397
name_or_qualified(_t);
08398 _t = _retTree;
08399 {
08400
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08401 _t = ASTNULL;
08402
switch ( _t->getType()) {
08403
case PARENTHESIZED_PRIMARY:
08404 {
08405
parenthesized_primary(_t);
08406 _t = _retTree;
08407
break;
08408 }
08409
case IDENTIFIER:
08410
case RANGE:
08411
case DIGITS:
08412
case DELTA:
08413
case ACCESS:
08414 {
08415
attribute_id(_t);
08416 _t = _retTree;
08417
break;
08418 }
08419
default:
08420 {
08421
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08422 }
08423 }
08424 }
08425 _t = __t496;
08426 _t = _t->getNextSibling();
08427
break;
08428 }
08429
default:
08430 {
08431
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08432 }
08433 }
08434 }
08435
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08436 reportError(ex);
08437
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08438 _t = _t->getNextSibling();
08439 }
08440 _retTree = _t;
08441 }
08442
08443 void AdaTreeParserSuper::allocator(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08444
ANTLR_USE_NAMESPACE(antlr)
RefAST allocator_AST_in = _t;
08445
08446
try {
08447
ANTLR_USE_NAMESPACE(antlr)
RefAST __t499 = _t;
08448
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp294_AST_in = _t;
08449 match(_t,ALLOCATOR);
08450 _t = _t->getFirstChild();
08451
name_or_qualified(_t);
08452 _t = _retTree;
08453 _t = __t499;
08454 _t = _t->getNextSibling();
08455 }
08456
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08457 reportError(ex);
08458
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08459 _t = _t->getNextSibling();
08460 }
08461 _retTree = _t;
08462 }
08463
08464 void AdaTreeParserSuper::subprogram_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08465
ANTLR_USE_NAMESPACE(antlr)
RefAST subprogram_body_AST_in = _t;
08466
08467
try {
08468
if (_t ==
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08469 _t = ASTNULL;
08470
switch ( _t->getType()) {
08471
case PROCEDURE_BODY:
08472 {
08473
procedure_body(_t);
08474 _t = _retTree;
08475
break;
08476 }
08477
case FUNCTION_BODY:
08478 {
08479
function_body(_t);
08480 _t = _retTree;
08481
break;
08482 }
08483
default:
08484 {
08485
throw ANTLR_USE_NAMESPACE(antlr)
NoViableAltException(_t);
08486 }
08487 }
08488 }
08489
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08490 reportError(ex);
08491
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08492 _t = _t->getNextSibling();
08493 }
08494 _retTree = _t;
08495 }
08496
08497 void AdaTreeParserSuper::package_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08498
ANTLR_USE_NAMESPACE(antlr)
RefAST package_body_AST_in = _t;
08499
08500
try {
08501
ANTLR_USE_NAMESPACE(antlr)
RefAST __t505 = _t;
08502
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp295_AST_in = _t;
08503 match(_t,PACKAGE_BODY);
08504 _t = _t->getFirstChild();
08505
def_id(_t);
08506 _t = _retTree;
08507
pkg_body_part(_t);
08508 _t = _retTree;
08509 _t = __t505;
08510 _t = _t->getNextSibling();
08511 }
08512
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08513 reportError(ex);
08514
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08515 _t = _t->getNextSibling();
08516 }
08517 _retTree = _t;
08518 }
08519
08520 void AdaTreeParserSuper::task_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08521
ANTLR_USE_NAMESPACE(antlr)
RefAST task_body_AST_in = _t;
08522
08523
try {
08524
ANTLR_USE_NAMESPACE(antlr)
RefAST __t507 = _t;
08525
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp296_AST_in = _t;
08526 match(_t,TASK_BODY);
08527 _t = _t->getFirstChild();
08528
def_id(_t);
08529 _t = _retTree;
08530
body_part(_t);
08531 _t = _retTree;
08532 _t = __t507;
08533 _t = _t->getNextSibling();
08534 }
08535
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08536 reportError(ex);
08537
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08538 _t = _t->getNextSibling();
08539 }
08540 _retTree = _t;
08541 }
08542
08543 void AdaTreeParserSuper::protected_body(
ANTLR_USE_NAMESPACE(antlr)
RefAST _t) {
08544
ANTLR_USE_NAMESPACE(antlr)
RefAST protected_body_AST_in = _t;
08545
08546
try {
08547
ANTLR_USE_NAMESPACE(antlr)
RefAST __t509 = _t;
08548
ANTLR_USE_NAMESPACE(antlr)
RefAST tmp297_AST_in = _t;
08549 match(_t,PROTECTED_BODY);
08550 _t = _t->getFirstChild();
08551
def_id(_t);
08552 _t = _retTree;
08553
prot_op_bodies_opt(_t);
08554 _t = _retTree;
08555 _t = __t509;
08556 _t = _t->getNextSibling();
08557 }
08558
catch (
ANTLR_USE_NAMESPACE(antlr)
RecognitionException& ex) {
08559 reportError(ex);
08560
if ( _t !=
ANTLR_USE_NAMESPACE(antlr)
nullAST )
08561 _t = _t->getNextSibling();
08562 }
08563 _retTree = _t;
08564 }
08565
08566 void AdaTreeParserSuper::initializeASTFactory(
ANTLR_USE_NAMESPACE(antlr)
ASTFactory& factory )
08567 {
08568 }
08569 const char*
AdaTreeParserSuper::tokenNames[] = {
08570
"<0>",
08571
"EOF",
08572
"<2>",
08573
"NULL_TREE_LOOKAHEAD",
08574
"\"pragma\"",
08575
"IDENTIFIER",
08576
"SEMI",
08577
"LPAREN",
08578
"COMMA",
08579
"RPAREN",
08580
"RIGHT_SHAFT",
08581
"\"with\"",
08582
"DOT",
08583
"\"use\"",
08584
"\"type\"",
08585
"TIC",
08586
"\"range\"",
08587
"\"digits\"",
08588
"\"delta\"",
08589
"\"access\"",
08590
"\"private\"",
08591
"\"package\"",
08592
"\"body\"",
08593
"\"is\"",
08594
"\"procedure\"",
08595
"\"function\"",
08596
"\"new\"",
08597
"\"others\"",
08598
"PIPE",
08599
"DOT_DOT",
08600
"\"all\"",
08601
"COLON",
08602
"\"in\"",
08603
"\"out\"",
08604
"\"renames\"",
08605
"CHARACTER_LITERAL",
08606
"CHAR_STRING",
08607
"\"null\"",
08608
"\"record\"",
08609
"\"separate\"",
08610
"\"abstract\"",
08611
"\"return\"",
08612
"\"task\"",
08613
"\"protected\"",
08614
"BOX",
08615
"ASSIGN",
08616
"\"entry\"",
08617
"\"for\"",
08618
"\"end\"",
08619
"\"at\"",
08620
"\"mod\"",
08621
"\"subtype\"",
08622
"\"exception\"",
08623
"\"constant\"",
08624
"\"array\"",
08625
"\"of\"",
08626
"\"aliased\"",
08627
"\"case\"",
08628
"\"when\"",
08629
"\"tagged\"",
08630
"\"limited\"",
08631
"\"generic\"",
08632
"\"begin\"",
08633
"LT_LT",
08634
"GT_GT",
08635
"\"if\"",
08636
"\"then\"",
08637
"\"elsif\"",
08638
"\"else\"",
08639
"\"loop\"",
08640
"\"while\"",
08641
"\"reverse\"",
08642
"\"declare\"",
08643
"\"exit\"",
08644
"\"goto\"",
08645
"\"accept\"",
08646
"\"do\"",
08647
"\"delay\"",
08648
"\"until\"",
08649
"\"select\"",
08650
"\"abort\"",
08651
"\"or\"",
08652
"\"terminate\"",
08653
"\"raise\"",
08654
"\"requeue\"",
08655
"\"and\"",
08656
"\"xor\"",
08657
"\"not\"",
08658
"EQ",
08659
"NE",
08660
"LT_",
08661
"LE",
08662
"GT",
08663
"GE",
08664
"PLUS",
08665
"MINUS",
08666
"CONCAT",
08667
"STAR",
08668
"DIV",
08669
"\"rem\"",
08670
"\"abs\"",
08671
"EXPON",
08672
"NUMERIC_LIT",
08673
"ABORTABLE_PART",
08674
"ABORT_STATEMENT",
08675
"ABSTRACT_SUBPROGRAM_DECLARATION",
08676
"ACCEPT_ALTERNATIVE",
08677
"ACCEPT_STATEMENT",
08678
"ALLOCATOR",
08679
"ASSIGNMENT_STATEMENT",
08680
"ASYNCHRONOUS_SELECT",
08681
"ATTRIBUTE_DEFINITION_CLAUSE",
08682
"AT_CLAUSE",
08683
"BLOCK_STATEMENT",
08684
"CASE_STATEMENT",
08685
"CASE_STATEMENT_ALTERNATIVE",
08686
"CODE_STATEMENT",
08687
"COMPONENT_DECLARATION",
08688
"COMPONENT_LIST",
08689
"CONDITION",
08690
"CONDITIONAL_ENTRY_CALL",
08691
"CONTEXT_CLAUSE",
08692
"DECLARATIVE_ITEM",
08693
"DECLARATIVE_PART",
08694
"DEFINING_IDENTIFIER_LIST",
08695
"DELAY_ALTERNATIVE",
08696
"DELAY_STATEMENT",
08697
"DELTA_CONSTRAINT",
08698
"DIGITS_CONSTRAINT",
08699
"DISCRETE_RANGE",
08700
"DISCRIMINANT_ASSOCIATION",
08701
"DISCRIMINANT_CONSTRAINT",
08702
"DISCRIMINANT_SPECIFICATION",
08703
"ENTRY_BODY",
08704
"ENTRY_CALL_ALTERNATIVE",
08705
"ENTRY_CALL_STATEMENT",
08706
"ENTRY_DECLARATION",
08707
"ENTRY_INDEX_SPECIFICATION",
08708
"ENUMERATION_REPESENTATION_CLAUSE",
08709
"EXCEPTION_DECLARATION",
08710
"EXCEPTION_HANDLER",
08711
"EXCEPTION_RENAMING_DECLARATION",
08712
"EXIT_STATEMENT",
08713
"FORMAL_PACKAGE_DECLARATION",
08714
"FORMAL_TYPE_DECLARATION",
08715
"FULL_TYPE_DECLARATION",
08716
"GENERIC_FORMAL_PART",
08717
"GENERIC_INSTANTIATION",
08718
"GENERIC_PACKAGE_DECLARATION",
08719
"GENERIC_RENAMING_DECLARATION",
08720
"GENERIC_SUBPROGRAM_DECLARATION",
08721
"GOTO_STATEMENT",
08722
"HANDLED_SEQUENCE_OF_STATEMENTS",
08723
"IF_STATEMENT",
08724
"INCOMPLETE_TYPE_DECLARATION",
08725
"INDEXED_COMPONENT",
08726
"INDEX_CONSTRAINT",
08727
"LIBRARY_ITEM",
08728
"LOOP_STATEMENT",
08729
"NAME",
08730
"NULL_STATEMENT",
08731
"NUMBER_DECLARATION",
08732
"OBJECT_DECLARATION",
08733
"OBJECT_RENAMING_DECLARATION",
08734
"OPERATOR_SYMBOL",
08735
"PACKAGE_BODY",
08736
"PACKAGE_BODY_STUB",
08737
"PACKAGE_RENAMING_DECLARATION",
08738
"PACKAGE_SPECIFICATION",
08739
"PARAMETER_SPECIFICATION",
08740
"PREFIX",
08741
"PRIMARY",
08742
"PRIVATE_EXTENSION_DECLARATION",
08743
"PRIVATE_TYPE_DECLARATION",
08744
"PROCEDURE_CALL_STATEMENT",
08745
"PROTECTED_BODY",
08746
"PROTECTED_BODY_STUB",
08747
"PROTECTED_TYPE_DECLARATION",
08748
"RAISE_STATEMENT",
08749
"RANGE_ATTRIBUTE_REFERENCE",
08750
"RECORD_REPRESENTATION_CLAUSE",
08751
"REQUEUE_STATEMENT",
08752
"RETURN_STATEMENT",
08753
"SELECTIVE_ACCEPT",
08754
"SELECT_ALTERNATIVE",
08755
"SELECT_STATEMENT",
08756
"SEQUENCE_OF_STATEMENTS",
08757
"SINGLE_PROTECTED_DECLARATION",
08758
"SINGLE_TASK_DECLARATION",
08759
"STATEMENT",
08760
"SUBPROGRAM_BODY",
08761
"SUBPROGRAM_BODY_STUB",
08762
"SUBPROGRAM_DECLARATION",
08763
"SUBPROGRAM_RENAMING_DECLARATION",
08764
"SUBTYPE_DECLARATION",
08765
"SUBTYPE_INDICATION",
08766
"SUBTYPE_MARK",
08767
"SUBUNIT",
08768
"TASK_BODY",
08769
"TASK_BODY_STUB",
08770
"TASK_TYPE_DECLARATION",
08771
"TERMINATE_ALTERNATIVE",
08772
"TIMED_ENTRY_CALL",
08773
"TRIGGERING_ALTERNATIVE",
08774
"TYPE_DECLARATION",
08775
"USE_CLAUSE",
08776
"USE_TYPE_CLAUSE",
08777
"VARIANT",
08778
"VARIANT_PART",
08779
"WITH_CLAUSE",
08780
"ABSTRACT_FUNCTION_DECLARATION",
08781
"ABSTRACT_PROCEDURE_DECLARATION",
08782
"ACCESS_TO_FUNCTION_DECLARATION",
08783
"ACCESS_TO_OBJECT_DECLARATION",
08784
"ACCESS_TO_PROCEDURE_DECLARATION",
08785
"ACCESS_TYPE_DECLARATION",
08786
"ARRAY_OBJECT_DECLARATION",
08787
"ARRAY_TYPE_DECLARATION",
08788
"AND_THEN",
08789
"BASIC_DECLARATIVE_ITEMS_OPT",
08790
"BLOCK_BODY",
08791
"BLOCK_BODY_OPT",
08792
"CALL_STATEMENT",
08793
"COMPONENT_CLAUSES_OPT",
08794
"COMPONENT_ITEMS",
08795
"COND_CLAUSE",
08796
"DECIMAL_FIXED_POINT_DECLARATION",
08797
"DECLARE_OPT",
08798
"DERIVED_RECORD_EXTENSION",
08799
"DERIVED_TYPE_DECLARATION",
08800
"DISCRETE_SUBTYPE_DEF_OPT",
08801
"DISCRIMINANT_SPECIFICATIONS",
08802
"DISCRIM_PART_OPT",
08803
"ELSE_OPT",
08804
"ELSIFS_OPT",
08805
"ENTRY_INDEX_OPT",
08806
"ENUMERATION_TYPE_DECLARATION",
08807
"EXCEPT_HANDLER_PART_OPT",
08808
"EXTENSION_OPT",
08809
"FLOATING_POINT_DECLARATION",
08810
"FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
08811
"FORMAL_DISCRETE_TYPE_DECLARATION",
08812
"FORMAL_FLOATING_POINT_DECLARATION",
08813
"FORMAL_FUNCTION_DECLARATION",
08814
"FORMAL_MODULAR_TYPE_DECLARATION",
08815
"FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
08816
"FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
08817
"FORMAL_PART_OPT",
08818
"FORMAL_PRIVATE_EXTENSION_DECLARATION",
08819
"FORMAL_PRIVATE_TYPE_DECLARATION",
08820
"FORMAL_PROCEDURE_DECLARATION",
08821
"FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
08822
"FUNCTION_BODY",
08823
"FUNCTION_BODY_STUB",
08824
"FUNCTION_DECLARATION",
08825
"FUNCTION_RENAMING_DECLARATION",
08826
"GENERIC_FUNCTION_DECLARATION",
08827
"GENERIC_FUNCTION_INSTANTIATION",
08828
"GENERIC_FUNCTION_RENAMING",
08829
"GENERIC_PACKAGE_INSTANTIATION",
08830
"GENERIC_PACKAGE_RENAMING",
08831
"GENERIC_PROCEDURE_DECLARATION",
08832
"GENERIC_PROCEDURE_INSTANTIATION",
08833
"GENERIC_PROCEDURE_RENAMING",
08834
"GUARD_OPT",
08835
"IDENTIFIER_COLON_OPT",
08836
"INIT_OPT",
08837
"ITERATION_SCHEME_OPT",
08838
"LABEL_OPT",
08839
"MARK_WITH_CONSTRAINT",
08840
"MODIFIERS",
08841
"MODULAR_TYPE_DECLARATION",
08842
"MOD_CLAUSE_OPT",
08843
"NOT_IN",
08844
"ORDINARY_DERIVED_TYPE_DECLARATION",
08845
"ORDINARY_FIXED_POINT_DECLARATION",
08846
"OR_ELSE",
08847
"OR_SELECT_OPT",
08848
"PARENTHESIZED_PRIMARY",
08849
"PRIVATE_TASK_ITEMS_OPT",
08850
"PROCEDURE_BODY",
08851
"PROCEDURE_BODY_STUB",
08852
"PROCEDURE_DECLARATION",
08853
"PROCEDURE_RENAMING_DECLARATION",
08854
"PROT_MEMBER_DECLARATIONS",
08855
"PROT_OP_BODIES_OPT",
08856
"PROT_OP_DECLARATIONS",
08857
"RANGED_EXPRS",
08858
"RECORD_TYPE_DECLARATION",
08859
"SELECTOR_NAMES_OPT",
08860
"SIGNED_INTEGER_TYPE_DECLARATION",
08861
"TASK_ITEMS_OPT",
08862
"UNARY_MINUS",
08863
"UNARY_PLUS",
08864
"VALUE",
08865
"VALUES",
08866
"VARIANTS",
08867
"COMMENT_INTRO",
08868
"DIGIT",
08869
"EXPONENT",
08870
"EXTENDED_DIGIT",
08871
"BASED_INTEGER",
08872
"WS_",
08873
"COMMENT",
08874
"CHARACTER_STRING",
08875 0
08876 };
08877
08878 const unsigned long AdaTreeParserSuper::_tokenSet_0_data_[] = { 37920UL, 262201UL, 4293001216UL, 4223UL, 134217728UL, 16UL, 67108864UL, 0UL, 5373952UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
08879
08880
08881
08882
08883
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaTreeParserSuper::_tokenSet_0(_tokenSet_0_data_,20);
08884 const
unsigned long AdaTreeParserSuper::_tokenSet_1_data_[] = { 939627552UL, 262201UL, 4293001216UL, 4223UL, 134217728UL, 16UL, 67108864UL, 0UL, 5373952UL, 48UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
08885
08886
08887
08888
08889
08890
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaTreeParserSuper::_tokenSet_1(_tokenSet_1_data_,20);
08891 const
unsigned long AdaTreeParserSuper::_tokenSet_2_data_[] = { 0UL, 0UL, 0UL, 98304UL, 68168704UL, 403845518UL, 58482948UL, 3758133268UL, 235700479UL, 5UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
08892
08893
08894
08895
08896
08897
08898
08899
08900
08901
08902
08903
08904
08905
08906
08907
08908
08909
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaTreeParserSuper::_tokenSet_2(_tokenSet_2_data_,20);
08910 const
unsigned long AdaTreeParserSuper::_tokenSet_3_data_[] = { 16UL, 0UL, 0UL, 98304UL, 1280UL, 1048576UL, 0UL, 1073741824UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
08911
08912
08913
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaTreeParserSuper::_tokenSet_3(_tokenSet_3_data_,20);
08914 const
unsigned long AdaTreeParserSuper::_tokenSet_4_data_[] = { 36896UL, 0UL, 0UL, 0UL, 134217728UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
08915
08916
const ANTLR_USE_NAMESPACE(antlr)
BitSet AdaTreeParserSuper::_tokenSet_4(_tokenSet_4_data_,12);
08917
08918