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