KDevelop API Documentation

AdaStoreWalker.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "expandedada.store.g" -> "AdaStoreWalker.cpp"$ */
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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                            // m_currentContainer->setEndPosition (endLine, 0);
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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         //        kdDebug() << "cn:compound_name started " << endl;
00663                 if (m_addToStore) {
00664         //          kdDebug() << "cn:compound_name m_addToStore " << endl;
00665                   if (m_isSubprogram) {
00666         //            kdDebug() << "cn:compound_name m_isSubprogram " << endl;
00667         FunctionDom method = m_model->create<FunctionModel>();
00668                     method->setName (qtext (cn));
00669         method->setFileName(m_fileName);
00670         //            kdDebug() << "cn:compound_name method->setStartPosition(" << endl;
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         /*          ParsedMethod *old = m_currentContainer->getMethod (method);
00679                     if (old) {
00680                       delete (method);
00681                       method = old;
00682                     } else {
00683                       m_currentContainer->addMethod (method);
00684                     }*/
00685                   } else {
00686                     // TBC: what about other declarations?
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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                            // m_currentContainer->setDeclarationEndsOnLine (endLine);
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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             //        kdDebug() << "def_designator cn:compound_name started" << endl;
01215                     if (m_addToStore) {
01216             //            kdDebug() << "def_designator cn:compound_name m_addToStore" << endl;
01217             FunctionDom method = m_model->create<FunctionModel>();
01218             method->setName (qtext (cn));
01219             method->setFileName(m_fileName);
01220             //            kdDebug() << "def_designator cn:compound_name method->setStartPosition(" << endl;
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             /*        ParsedMethod *old = m_currentContainer->getMethod (method);
01229                       if (old) {
01230                     delete method;
01231                     method = old;
01232                       } else {
01233                     m_currentContainer->addMethod (method);
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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                        // m_currentContainer->setDeclarationEndsOnLine (endLine);
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 // IDENTIFIER RIGHT_SHAFT DOT TIC "in" CHARACTER_LITERAL CHAR_STRING "null" 
09147 // "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR 
09148 // DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT OPERATOR_SYMBOL 
09149 // AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS UNARY_PLUS 
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 // ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENUMERATION_REPESENTATION_CLAUSE 
09153 // EXCEPTION_DECLARATION EXCEPTION_RENAMING_DECLARATION GENERIC_PACKAGE_DECLARATION 
09154 // INCOMPLETE_TYPE_DECLARATION NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION 
09155 // PACKAGE_RENAMING_DECLARATION PACKAGE_SPECIFICATION PRIVATE_EXTENSION_DECLARATION 
09156 // PRIVATE_TYPE_DECLARATION PROTECTED_TYPE_DECLARATION RECORD_REPRESENTATION_CLAUSE 
09157 // SINGLE_PROTECTED_DECLARATION SINGLE_TASK_DECLARATION SUBTYPE_DECLARATION 
09158 // TASK_TYPE_DECLARATION USE_CLAUSE USE_TYPE_CLAUSE ABSTRACT_FUNCTION_DECLARATION 
09159 // ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION 
09160 // ACCESS_TO_PROCEDURE_DECLARATION ARRAY_OBJECT_DECLARATION ARRAY_TYPE_DECLARATION 
09161 // DECIMAL_FIXED_POINT_DECLARATION DERIVED_RECORD_EXTENSION ENUMERATION_TYPE_DECLARATION 
09162 // FLOATING_POINT_DECLARATION FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION 
09163 // GENERIC_FUNCTION_DECLARATION GENERIC_FUNCTION_INSTANTIATION GENERIC_FUNCTION_RENAMING 
09164 // GENERIC_PACKAGE_INSTANTIATION GENERIC_PACKAGE_RENAMING GENERIC_PROCEDURE_DECLARATION 
09165 // GENERIC_PROCEDURE_INSTANTIATION GENERIC_PROCEDURE_RENAMING MODULAR_TYPE_DECLARATION 
09166 // ORDINARY_DERIVED_TYPE_DECLARATION ORDINARY_FIXED_POINT_DECLARATION PROCEDURE_BODY_STUB 
09167 // PROCEDURE_DECLARATION PROCEDURE_RENAMING_DECLARATION RECORD_TYPE_DECLARATION 
09168 // SIGNED_INTEGER_TYPE_DECLARATION 
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 // IDENTIFIER RIGHT_SHAFT DOT TIC "range" "others" PIPE DOT_DOT "in" CHARACTER_LITERAL 
09172 // CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 
09173 // MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT 
09174 // OPERATOR_SYMBOL AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS 
09175 // UNARY_PLUS 
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 // "pragma" ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENTRY_DECLARATION ENUMERATION_REPESENTATION_CLAUSE 
09179 // RECORD_REPRESENTATION_CLAUSE FUNCTION_DECLARATION PROCEDURE_DECLARATION 
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 // IDENTIFIER DOT TIC INDEXED_COMPONENT 
09183 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_4(_tokenSet_4_data_,12);
09184 
09185 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:44 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003