From 114a878c64ce6f8223cfd22d76a20eb16d177e5e Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- languages/ada/AdaStoreWalker.cpp | 9439 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 9439 insertions(+) create mode 100644 languages/ada/AdaStoreWalker.cpp (limited to 'languages/ada/AdaStoreWalker.cpp') diff --git a/languages/ada/AdaStoreWalker.cpp b/languages/ada/AdaStoreWalker.cpp new file mode 100644 index 00000000..167d671c --- /dev/null +++ b/languages/ada/AdaStoreWalker.cpp @@ -0,0 +1,9439 @@ +/* $ANTLR 2.7.7 (20070609): "expandedada.store.g" -> "AdaStoreWalker.cpp"$ */ +#include "AdaStoreWalker.hpp" +#include +#include +#include +#include +#include +#include +#line 1 "expandedada.store.g" +#line 11 "AdaStoreWalker.cpp" +AdaStoreWalker::AdaStoreWalker() + : ANTLR_USE_NAMESPACE(antlr)TreeParser() { +} + +void AdaStoreWalker::compilation_unit(RefAdaAST _t) { + RefAdaAST compilation_unit_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling +#line 116 "expandedada.store.g" + init(); +#line 22 "AdaStoreWalker.cpp" + context_items_opt(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case LIBRARY_ITEM: + { + library_item(_t); + _t = _retTree; + break; + } + case SUBUNIT: + { + subunit(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == PRAGMA)) { + pragma(_t); + _t = _retTree; + } + else { + goto _loop4; + } + + } + _loop4:; + } // ( ... )* + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::context_items_opt(RefAdaAST _t) { + RefAdaAST context_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t70 = _t; + RefAdaAST tmp1_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONTEXT_CLAUSE); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case WITH_CLAUSE: + { + with_clause(_t); + _t = _retTree; + break; + } + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + { + use_clause(_t); + _t = _retTree; + break; + } + default: + { + goto _loop72; + } + } + } + _loop72:; + } // ( ... )* + _t = __t70; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::library_item(RefAdaAST _t) { + RefAdaAST library_item_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST pb = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefAdaAST gpi = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefAdaAST ps = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefAdaAST prd = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + RefAdaAST __t17 = _t; + RefAdaAST tmp2_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LIBRARY_ITEM); + _t = _t->getFirstChild(); + RefAdaAST __t18 = _t; + RefAdaAST tmp3_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODIFIERS); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRIVATE: + { + RefAdaAST tmp4_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE); + _t = _t->getNextSibling(); +#line 132 "expandedada.store.g" + m_currentAccess = CodeModelItem::Protected; +#line 149 "AdaStoreWalker.cpp" + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t18; + _t = _t->getNextSibling(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case FUNCTION_BODY: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case PROCEDURE_BODY: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + { + lib_subprog_decl_or_rename_or_inst_or_body(_t); + _t = _retTree; + break; + } + case PACKAGE_BODY: + { + RefAdaAST __t21 = _t; + RefAdaAST tmp5_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY); + _t = _t->getFirstChild(); + pb = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; + pkg_body_part(_t); + _t = _retTree; + _t = __t21; + _t = _t->getNextSibling(); + break; + } + case GENERIC_PACKAGE_INSTANTIATION: + { + RefAdaAST __t22 = _t; + RefAdaAST tmp6_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_INSTANTIATION); + _t = _t->getFirstChild(); + gpi = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; +#line 136 "expandedada.store.g" + + defineScope( gpi ); + +#line 213 "AdaStoreWalker.cpp" + generic_inst(_t); + _t = _retTree; + _t = __t22; + _t = _t->getNextSibling(); + break; + } + case PACKAGE_SPECIFICATION: + { + RefAdaAST __t23 = _t; + RefAdaAST tmp7_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_SPECIFICATION); + _t = _t->getFirstChild(); + ps = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; +#line 142 "expandedada.store.g" + + NamespaceDom psc = defineScope( ps ); + m_currentContainer = psc; + m_scopeStack.append( psc ); + m_addToStore = true; + +#line 236 "AdaStoreWalker.cpp" + pkg_spec_part(_t); + _t = _retTree; +#line 149 "expandedada.store.g" + + m_scopeStack.remove(m_scopeStack.last()); + if (m_scopeStack.count() == 0) { + kdDebug() << "adastore: m_scopeStack is empty!" << endl; + m_scopeStack.append( m_model->globalNamespace() ); + } + m_currentContainer = m_scopeStack.last(); + // m_currentContainer->setEndPosition (endLine, 0); + m_addToStore = false; + +#line 250 "AdaStoreWalker.cpp" + _t = __t23; + _t = _t->getNextSibling(); + break; + } + case PACKAGE_RENAMING_DECLARATION: + { + RefAdaAST __t24 = _t; + RefAdaAST tmp8_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_RENAMING_DECLARATION); + _t = _t->getFirstChild(); + prd = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; +#line 161 "expandedada.store.g" + + defineScope( prd ); + +#line 268 "AdaStoreWalker.cpp" + renames(_t); + _t = _retTree; + _t = __t24; + _t = _t->getNextSibling(); + break; + } + case GENERIC_PACKAGE_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_RENAMING: + { + generic_decl(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t17; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subunit(RefAdaAST _t) { + RefAdaAST subunit_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t521 = _t; + RefAdaAST tmp9_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SUBUNIT); + _t = _t->getFirstChild(); + compound_name(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FUNCTION_BODY: + case PROCEDURE_BODY: + { + subprogram_body(_t); + _t = _retTree; + break; + } + case PACKAGE_BODY: + { + package_body(_t); + _t = _retTree; + break; + } + case TASK_BODY: + { + task_body(_t); + _t = _retTree; + break; + } + case PROTECTED_BODY: + { + protected_body(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t521; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::pragma(RefAdaAST _t) { + RefAdaAST pragma_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t64 = _t; + RefAdaAST tmp10_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRAGMA); + _t = _t->getFirstChild(); + RefAdaAST tmp11_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_0.member(_t->getType()))) { + pragma_arg(_t); + _t = _retTree; + } + else { + goto _loop66; + } + + } + _loop66:; + } // ( ... )* + _t = __t64; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::with_clause(RefAdaAST _t) { + RefAdaAST with_clause_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t6 = _t; + RefAdaAST tmp12_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WITH_CLAUSE); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt8=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) { + compound_name(_t); + _t = _retTree; + } + else { + if ( _cnt8>=1 ) { goto _loop8; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt8++; + } + _loop8:; + } // ( ... )+ + _t = __t6; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::compound_name(RefAdaAST _t) { + RefAdaAST compound_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp13_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case DOT: + { + RefAdaAST __t74 = _t; + RefAdaAST tmp14_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + compound_name(_t); + _t = _retTree; + RefAdaAST tmp15_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + _t = __t74; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::use_clause(RefAdaAST _t) { + RefAdaAST use_clause_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST c = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case USE_TYPE_CLAUSE: + { + RefAdaAST __t10 = _t; + RefAdaAST tmp16_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),USE_TYPE_CLAUSE); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt12=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENTIFIER || _t->getType() == DOT || _t->getType() == TIC)) { + subtype_mark(_t); + _t = _retTree; + } + else { + if ( _cnt12>=1 ) { goto _loop12; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt12++; + } + _loop12:; + } // ( ... )+ + _t = __t10; + _t = _t->getNextSibling(); + break; + } + case USE_CLAUSE: + { + RefAdaAST __t13 = _t; + RefAdaAST tmp17_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),USE_CLAUSE); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt15=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENTIFIER || _t->getType() == DOT)) { + c = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + compound_name(_t); + _t = _retTree; +#line 127 "expandedada.store.g" + m_imports.back ().push_back (qtext (c)); +#line 527 "AdaStoreWalker.cpp" + } + else { + if ( _cnt15>=1 ) { goto _loop15; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt15++; + } + _loop15:; + } // ( ... )+ + _t = __t13; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subtype_mark(RefAdaAST _t) { + RefAdaAST subtype_mark_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + { + compound_name(_t); + _t = _retTree; + break; + } + case TIC: + { + RefAdaAST __t76 = _t; + RefAdaAST tmp18_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIC); + _t = _t->getFirstChild(); + compound_name(_t); + _t = _retTree; + attribute_id(_t); + _t = _retTree; + _t = __t76; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::lib_subprog_decl_or_rename_or_inst_or_body(RefAdaAST _t) { + RefAdaAST lib_subprog_decl_or_rename_or_inst_or_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling +#line 310 "expandedada.store.g" + m_addToStore = true; +#line 603 "AdaStoreWalker.cpp" + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + { + subprog_decl(_t); + _t = _retTree; + break; + } + case PROCEDURE_BODY: + { + procedure_body(_t); + _t = _retTree; + break; + } + case FUNCTION_BODY: + { + function_body(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } +#line 315 "expandedada.store.g" + m_addToStore = false; +#line 643 "AdaStoreWalker.cpp" + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::def_id(RefAdaAST _t) { + RefAdaAST def_id_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST cn = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + cn = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + compound_name(_t); + _t = _retTree; +#line 189 "expandedada.store.g" + + // kdDebug() << "cn:compound_name started " << endl; + if (m_addToStore) { + // kdDebug() << "cn:compound_name m_addToStore " << endl; + if (m_isSubprogram) { + // kdDebug() << "cn:compound_name m_isSubprogram " << endl; + FunctionDom method = m_model->create(); + method->setName (qtext (cn)); + method->setFileName(m_fileName); + // kdDebug() << "cn:compound_name method->setStartPosition(" << endl; + method->setStartPosition(cn->getLine(), cn->getColumn()); + + if (m_currentContainer == m_model->globalNamespace()) + m_file->addFunction(method); + else + m_currentContainer->addFunction(method); + //FIXME: adymo: is this valid for CodeModel + /* ParsedMethod *old = m_currentContainer->getMethod (method); + if (old) { + delete (method); + method = old; + } else { + m_currentContainer->addMethod (method); + }*/ + } else { + // TBC: what about other declarations? + } + } + +#line 691 "AdaStoreWalker.cpp" + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::pkg_body_part(RefAdaAST _t) { + RefAdaAST pkg_body_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + declarative_part(_t); + _t = _retTree; + block_body_opt(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::generic_inst(RefAdaAST _t) { + RefAdaAST generic_inst_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + compound_name(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case VALUES: + { + value_s(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::pkg_spec_part(RefAdaAST _t) { + RefAdaAST pkg_spec_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + basic_declarative_items_opt(_t); + _t = _retTree; + private_declarative_items_opt(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::renames(RefAdaAST _t) { + RefAdaAST renames_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case CHARACTER_STRING: + { + RefAdaAST tmp19_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_STRING); + _t = _t->getNextSibling(); + break; + } + case OPERATOR_SYMBOL: + { + RefAdaAST tmp20_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL); + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case INDEXED_COMPONENT: + { + name(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::generic_decl(RefAdaAST _t) { + RefAdaAST generic_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST gpd = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case GENERIC_PACKAGE_RENAMING: + { + RefAdaAST __t49 = _t; + RefAdaAST tmp21_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_RENAMING); + _t = _t->getFirstChild(); + generic_formal_part_opt(_t); + _t = _retTree; + def_id(_t); + _t = _retTree; + renames(_t); + _t = _retTree; + _t = __t49; + _t = _t->getNextSibling(); + break; + } + case GENERIC_PACKAGE_DECLARATION: + { + RefAdaAST __t50 = _t; + RefAdaAST tmp22_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_DECLARATION); + _t = _t->getFirstChild(); + generic_formal_part_opt(_t); + _t = _retTree; + gpd = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; +#line 284 "expandedada.store.g" + + NamespaceDom psc = defineScope( gpd ); + m_currentContainer = psc; + m_scopeStack.append( psc ); + m_addToStore = true; + +#line 860 "AdaStoreWalker.cpp" + pkg_spec_part(_t); + _t = _retTree; +#line 291 "expandedada.store.g" + + m_scopeStack.remove(m_scopeStack.last()); + if (m_scopeStack.count() == 0) + m_scopeStack.append( m_model->globalNamespace() ); + m_currentContainer = m_scopeStack.last(); + // m_currentContainer->setDeclarationEndsOnLine (endLine); + m_addToStore = false; + +#line 872 "AdaStoreWalker.cpp" + _t = __t50; + _t = _t->getNextSibling(); + break; + } + case GENERIC_PROCEDURE_RENAMING: + { + RefAdaAST __t51 = _t; + RefAdaAST tmp23_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PROCEDURE_RENAMING); + _t = _t->getFirstChild(); + generic_formal_part_opt(_t); + _t = _retTree; + def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + renames(_t); + _t = _retTree; + _t = __t51; + _t = _t->getNextSibling(); + break; + } + case GENERIC_PROCEDURE_DECLARATION: + { + RefAdaAST __t52 = _t; + RefAdaAST tmp24_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + generic_formal_part_opt(_t); + _t = _retTree; + subprog_def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t52; + _t = _t->getNextSibling(); + break; + } + case GENERIC_FUNCTION_RENAMING: + { + RefAdaAST __t53 = _t; + RefAdaAST tmp25_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FUNCTION_RENAMING); + _t = _t->getFirstChild(); + generic_formal_part_opt(_t); + _t = _retTree; + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + renames(_t); + _t = _retTree; + _t = __t53; + _t = _t->getNextSibling(); + break; + } + case GENERIC_FUNCTION_DECLARATION: + { + RefAdaAST __t54 = _t; + RefAdaAST tmp26_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + generic_formal_part_opt(_t); + _t = _retTree; + subprog_def_id(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t54; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subprog_def_id(RefAdaAST _t) { + RefAdaAST subprog_def_id_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling +#line 171 "expandedada.store.g" + m_isSubprogram = true; +#line 965 "AdaStoreWalker.cpp" + def_id(_t); + _t = _retTree; +#line 173 "expandedada.store.g" + m_isSubprogram = false; +#line 970 "AdaStoreWalker.cpp" + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subprog_decl(RefAdaAST _t) { + RefAdaAST subprog_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case GENERIC_PROCEDURE_INSTANTIATION: + { + RefAdaAST __t27 = _t; + RefAdaAST tmp27_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PROCEDURE_INSTANTIATION); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + generic_inst(_t); + _t = _retTree; + _t = __t27; + _t = _t->getNextSibling(); + break; + } + case PROCEDURE_RENAMING_DECLARATION: + { + RefAdaAST __t28 = _t; + RefAdaAST tmp28_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_RENAMING_DECLARATION); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + renames(_t); + _t = _retTree; + _t = __t28; + _t = _t->getNextSibling(); + break; + } + case PROCEDURE_DECLARATION: + { + RefAdaAST __t29 = _t; + RefAdaAST tmp29_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t29; + _t = _t->getNextSibling(); + break; + } + case PROCEDURE_BODY_STUB: + { + RefAdaAST __t30 = _t; + RefAdaAST tmp30_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_BODY_STUB); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t30; + _t = _t->getNextSibling(); + break; + } + case ABSTRACT_PROCEDURE_DECLARATION: + { + RefAdaAST __t31 = _t; + RefAdaAST tmp31_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABSTRACT_PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t31; + _t = _t->getNextSibling(); + break; + } + case GENERIC_FUNCTION_INSTANTIATION: + { + RefAdaAST __t32 = _t; + RefAdaAST tmp32_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FUNCTION_INSTANTIATION); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + generic_inst(_t); + _t = _retTree; + _t = __t32; + _t = _t->getNextSibling(); + break; + } + case FUNCTION_RENAMING_DECLARATION: + { + RefAdaAST __t33 = _t; + RefAdaAST tmp33_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_RENAMING_DECLARATION); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + renames(_t); + _t = _retTree; + _t = __t33; + _t = _t->getNextSibling(); + break; + } + case FUNCTION_DECLARATION: + { + RefAdaAST __t34 = _t; + RefAdaAST tmp34_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t34; + _t = _t->getNextSibling(); + break; + } + case FUNCTION_BODY_STUB: + { + RefAdaAST __t35 = _t; + RefAdaAST tmp35_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_BODY_STUB); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t35; + _t = _t->getNextSibling(); + break; + } + case ABSTRACT_FUNCTION_DECLARATION: + { + RefAdaAST __t36 = _t; + RefAdaAST tmp36_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABSTRACT_FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t36; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::formal_part_opt(RefAdaAST _t) { + RefAdaAST formal_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t112 = _t; + RefAdaAST tmp37_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PART_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == PARAMETER_SPECIFICATION)) { + parameter_specification(_t); + _t = _retTree; + } + else { + goto _loop114; + } + + } + _loop114:; + } // ( ... )* + _t = __t112; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::def_designator(RefAdaAST _t) { + RefAdaAST def_designator_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST cn = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + { + cn = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + compound_name(_t); + _t = _retTree; +#line 221 "expandedada.store.g" + + // kdDebug() << "def_designator cn:compound_name started" << endl; + if (m_addToStore) { + // kdDebug() << "def_designator cn:compound_name m_addToStore" << endl; + FunctionDom method = m_model->create(); + method->setName (qtext (cn)); + method->setFileName(m_fileName); + // kdDebug() << "def_designator cn:compound_name method->setStartPosition(" << endl; + method->setStartPosition(cn->getLine(), cn->getColumn()); + + if (m_currentContainer == m_model->globalNamespace()) + m_file->addFunction(method); + else + m_currentContainer->addFunction(method); + //FIXME: adymo: is this valid for CodeModel + /* ParsedMethod *old = m_currentContainer->getMethod (method); + if (old) { + delete method; + method = old; + } else { + m_currentContainer->addMethod (method); + }*/ + } + +#line 1218 "AdaStoreWalker.cpp" + break; + } + case OPERATOR_SYMBOL: + { + definable_operator_symbol(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::function_tail(RefAdaAST _t) { + RefAdaAST function_tail_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + formal_part_opt(_t); + _t = _retTree; + subtype_mark(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::definable_operator_symbol(RefAdaAST _t) { + RefAdaAST definable_operator_symbol_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp38_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL); + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::spec_decl_part(RefAdaAST _t) { + RefAdaAST spec_decl_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST ps = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case GENERIC_PACKAGE_INSTANTIATION: + { + RefAdaAST __t40 = _t; + RefAdaAST tmp39_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_PACKAGE_INSTANTIATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + generic_inst(_t); + _t = _retTree; + _t = __t40; + _t = _t->getNextSibling(); + break; + } + case PACKAGE_SPECIFICATION: + { + RefAdaAST __t41 = _t; + RefAdaAST tmp40_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_SPECIFICATION); + _t = _t->getFirstChild(); + ps = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; +#line 250 "expandedada.store.g" + + NamespaceDom psc = defineScope( ps ); + m_currentContainer = psc; + m_scopeStack.append( psc ); + m_addToStore = true; + +#line 1312 "AdaStoreWalker.cpp" + pkg_spec_part(_t); + _t = _retTree; +#line 257 "expandedada.store.g" + + m_scopeStack.remove(m_scopeStack.last()); + if (m_scopeStack.count() == 0) { + kdDebug() << "adastore: m_scopeStack is empty!" << endl; + m_scopeStack.append( m_model->globalNamespace() ); + } + m_currentContainer = m_scopeStack.last(); + // m_currentContainer->setDeclarationEndsOnLine (endLine); + m_addToStore = false; + +#line 1326 "AdaStoreWalker.cpp" + _t = __t41; + _t = _t->getNextSibling(); + break; + } + case PACKAGE_RENAMING_DECLARATION: + { + RefAdaAST __t42 = _t; + RefAdaAST tmp41_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_RENAMING_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + renames(_t); + _t = _retTree; + _t = __t42; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::basic_declarative_items_opt(RefAdaAST _t) { + RefAdaAST basic_declarative_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t136 = _t; + RefAdaAST tmp42_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BASIC_DECLARATIVE_ITEMS_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_1.member(_t->getType()))) { + basic_decl_item(_t); + _t = _retTree; + } + else { + goto _loop138; + } + + } + _loop138:; + } // ( ... )* + _t = __t136; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::private_declarative_items_opt(RefAdaAST _t) { + RefAdaAST private_declarative_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case EXCEPTION_DECLARATION: + case EXCEPTION_RENAMING_DECLARATION: + case GENERIC_PACKAGE_DECLARATION: + case INCOMPLETE_TYPE_DECLARATION: + case NUMBER_DECLARATION: + case OBJECT_DECLARATION: + case OBJECT_RENAMING_DECLARATION: + case PACKAGE_RENAMING_DECLARATION: + case PACKAGE_SPECIFICATION: + case PRIVATE_EXTENSION_DECLARATION: + case PRIVATE_TYPE_DECLARATION: + case PROTECTED_TYPE_DECLARATION: + case RECORD_REPRESENTATION_CLAUSE: + case SINGLE_PROTECTED_DECLARATION: + case SINGLE_TASK_DECLARATION: + case SUBTYPE_DECLARATION: + case TASK_TYPE_DECLARATION: + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + case ARRAY_OBJECT_DECLARATION: + case ARRAY_TYPE_DECLARATION: + case DECIMAL_FIXED_POINT_DECLARATION: + case DERIVED_RECORD_EXTENSION: + case ENUMERATION_TYPE_DECLARATION: + case FLOATING_POINT_DECLARATION: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_INSTANTIATION: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case GENERIC_PROCEDURE_RENAMING: + case MODULAR_TYPE_DECLARATION: + case ORDINARY_DERIVED_TYPE_DECLARATION: + case ORDINARY_FIXED_POINT_DECLARATION: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + case RECORD_TYPE_DECLARATION: + case SIGNED_INTEGER_TYPE_DECLARATION: + { +#line 276 "expandedada.store.g" + m_currentAccess = CodeModelItem::Protected; +#line 1457 "AdaStoreWalker.cpp" + { // ( ... )+ + int _cnt47=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case EXCEPTION_DECLARATION: + case EXCEPTION_RENAMING_DECLARATION: + case GENERIC_PACKAGE_DECLARATION: + case INCOMPLETE_TYPE_DECLARATION: + case NUMBER_DECLARATION: + case OBJECT_DECLARATION: + case OBJECT_RENAMING_DECLARATION: + case PACKAGE_RENAMING_DECLARATION: + case PACKAGE_SPECIFICATION: + case PRIVATE_EXTENSION_DECLARATION: + case PRIVATE_TYPE_DECLARATION: + case PROTECTED_TYPE_DECLARATION: + case RECORD_REPRESENTATION_CLAUSE: + case SINGLE_PROTECTED_DECLARATION: + case SINGLE_TASK_DECLARATION: + case SUBTYPE_DECLARATION: + case TASK_TYPE_DECLARATION: + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + case ARRAY_OBJECT_DECLARATION: + case ARRAY_TYPE_DECLARATION: + case DECIMAL_FIXED_POINT_DECLARATION: + case DERIVED_RECORD_EXTENSION: + case ENUMERATION_TYPE_DECLARATION: + case FLOATING_POINT_DECLARATION: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_INSTANTIATION: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case GENERIC_PROCEDURE_RENAMING: + case MODULAR_TYPE_DECLARATION: + case ORDINARY_DERIVED_TYPE_DECLARATION: + case ORDINARY_FIXED_POINT_DECLARATION: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + case RECORD_TYPE_DECLARATION: + case SIGNED_INTEGER_TYPE_DECLARATION: + { + basic_decl_item(_t); + _t = _retTree; + break; + } + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + default: + { + if ( _cnt47>=1 ) { goto _loop47; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + } + _cnt47++; + } + _loop47:; + } // ( ... )+ +#line 278 "expandedada.store.g" + m_currentAccess = CodeModelItem::Public; +#line 1538 "AdaStoreWalker.cpp" + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::end_id_opt(RefAdaAST _t) { + RefAdaAST end_id_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t86 = _t; + RefAdaAST tmp43_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),END); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case OPERATOR_SYMBOL: + { + def_designator(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t86; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::basic_decl_item(RefAdaAST _t) { + RefAdaAST basic_decl_item_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PACKAGE_RENAMING_DECLARATION: + case PACKAGE_SPECIFICATION: + case GENERIC_PACKAGE_INSTANTIATION: + { + spec_decl_part(_t); + _t = _retTree; + break; + } + case SINGLE_TASK_DECLARATION: + case TASK_TYPE_DECLARATION: + { + task_type_or_single_decl(_t); + _t = _retTree; + break; + } + case PROTECTED_TYPE_DECLARATION: + case SINGLE_PROTECTED_DECLARATION: + { + prot_type_or_single_decl(_t); + _t = _retTree; + break; + } + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + { + subprog_decl(_t); + _t = _retTree; + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case EXCEPTION_DECLARATION: + case EXCEPTION_RENAMING_DECLARATION: + case GENERIC_PACKAGE_DECLARATION: + case INCOMPLETE_TYPE_DECLARATION: + case NUMBER_DECLARATION: + case OBJECT_DECLARATION: + case OBJECT_RENAMING_DECLARATION: + case PRIVATE_EXTENSION_DECLARATION: + case PRIVATE_TYPE_DECLARATION: + case RECORD_REPRESENTATION_CLAUSE: + case SUBTYPE_DECLARATION: + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + case ARRAY_OBJECT_DECLARATION: + case ARRAY_TYPE_DECLARATION: + case DECIMAL_FIXED_POINT_DECLARATION: + case DERIVED_RECORD_EXTENSION: + case ENUMERATION_TYPE_DECLARATION: + case FLOATING_POINT_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_RENAMING: + case MODULAR_TYPE_DECLARATION: + case ORDINARY_DERIVED_TYPE_DECLARATION: + case ORDINARY_FIXED_POINT_DECLARATION: + case RECORD_TYPE_DECLARATION: + case SIGNED_INTEGER_TYPE_DECLARATION: + { + decl_common(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::generic_formal_part_opt(RefAdaAST _t) { + RefAdaAST generic_formal_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t295 = _t; + RefAdaAST tmp44_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GENERIC_FORMAL_PART); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + { + use_clause(_t); + _t = _retTree; + break; + } + case FORMAL_PACKAGE_DECLARATION: + case PARAMETER_SPECIFICATION: + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + case ARRAY_TYPE_DECLARATION: + case FORMAL_DECIMAL_FIXED_POINT_DECLARATION: + case FORMAL_DISCRETE_TYPE_DECLARATION: + case FORMAL_FLOATING_POINT_DECLARATION: + case FORMAL_FUNCTION_DECLARATION: + case FORMAL_MODULAR_TYPE_DECLARATION: + case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION: + case FORMAL_ORDINARY_FIXED_POINT_DECLARATION: + case FORMAL_PRIVATE_EXTENSION_DECLARATION: + case FORMAL_PRIVATE_TYPE_DECLARATION: + case FORMAL_PROCEDURE_DECLARATION: + case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION: + { + generic_formal_parameter(_t); + _t = _retTree; + break; + } + default: + { + goto _loop297; + } + } + } + _loop297:; + } // ( ... )* + _t = __t295; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::procedure_body(RefAdaAST _t) { + RefAdaAST procedure_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t319 = _t; + RefAdaAST tmp45_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + body_part(_t); + _t = _retTree; + _t = __t319; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::function_body(RefAdaAST _t) { + RefAdaAST function_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t321 = _t; + RefAdaAST tmp46_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_BODY); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + body_part(_t); + _t = _retTree; + _t = __t321; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subprog_decl_or_rename_or_inst_or_body(RefAdaAST _t) { + RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + { + subprog_decl(_t); + _t = _retTree; + break; + } + case PROCEDURE_BODY: + { + procedure_body(_t); + _t = _retTree; + break; + } + case FUNCTION_BODY: + { + function_body(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subprog_decl_or_body(RefAdaAST _t) { + RefAdaAST subprog_decl_or_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PROCEDURE_BODY: + { + procedure_body(_t); + _t = _retTree; + break; + } + case PROCEDURE_DECLARATION: + { + RefAdaAST __t59 = _t; + RefAdaAST tmp47_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + subprog_def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t59; + _t = _t->getNextSibling(); + break; + } + case FUNCTION_BODY: + { + function_body(_t); + _t = _retTree; + break; + } + case FUNCTION_DECLARATION: + { + RefAdaAST __t60 = _t; + RefAdaAST tmp48_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t60; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::package_body(RefAdaAST _t) { + RefAdaAST package_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + RefAdaAST id = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + try { // for error handling + RefAdaAST __t62 = _t; + RefAdaAST tmp49_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY); + _t = _t->getFirstChild(); + id = (_t == ASTNULL) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + def_id(_t); + _t = _retTree; + pkg_body_part(_t); + _t = _retTree; + _t = __t62; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::pragma_arg(RefAdaAST _t) { + RefAdaAST pragma_arg_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RIGHT_SHAFT: + { + RefAdaAST __t68 = _t; + RefAdaAST tmp50_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RIGHT_SHAFT); + _t = _t->getFirstChild(); + RefAdaAST tmp51_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + expression(_t); + _t = _retTree; + _t = __t68; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::expression(RefAdaAST _t) { + RefAdaAST expression_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case AND: + { + RefAdaAST __t479 = _t; + RefAdaAST tmp52_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + relation(_t); + _t = _retTree; + _t = __t479; + _t = _t->getNextSibling(); + break; + } + case AND_THEN: + { + RefAdaAST __t480 = _t; + RefAdaAST tmp53_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND_THEN); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + relation(_t); + _t = _retTree; + _t = __t480; + _t = _t->getNextSibling(); + break; + } + case OR: + { + RefAdaAST __t481 = _t; + RefAdaAST tmp54_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + relation(_t); + _t = _retTree; + _t = __t481; + _t = _t->getNextSibling(); + break; + } + case OR_ELSE: + { + RefAdaAST __t482 = _t; + RefAdaAST tmp55_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR_ELSE); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + relation(_t); + _t = _retTree; + _t = __t482; + _t = _t->getNextSibling(); + break; + } + case XOR: + { + RefAdaAST __t483 = _t; + RefAdaAST tmp56_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),XOR); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + relation(_t); + _t = _retTree; + _t = __t483; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case NOT_IN: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + relation(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::attribute_id(RefAdaAST _t) { + RefAdaAST attribute_id_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RANGE: + { + RefAdaAST tmp57_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE); + _t = _t->getNextSibling(); + break; + } + case DIGITS: + { + RefAdaAST tmp58_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIGITS); + _t = _t->getNextSibling(); + break; + } + case DELTA: + { + RefAdaAST tmp59_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELTA); + _t = _t->getNextSibling(); + break; + } + case ACCESS: + { + RefAdaAST tmp60_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS); + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp61_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::modifiers(RefAdaAST _t) { + RefAdaAST modifiers_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t79 = _t; + RefAdaAST tmp62_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODIFIERS); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ABSTRACT: + { + RefAdaAST tmp63_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABSTRACT); + _t = _t->getNextSibling(); + break; + } + case ACCESS: + { + RefAdaAST tmp64_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS); + _t = _t->getNextSibling(); + break; + } + case ALIASED: + { + RefAdaAST tmp65_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALIASED); + _t = _t->getNextSibling(); + break; + } + case ALL: + { + RefAdaAST tmp66_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL); + _t = _t->getNextSibling(); + break; + } + case CONSTANT: + { + RefAdaAST tmp67_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONSTANT); + _t = _t->getNextSibling(); + break; + } + case IN: + { + RefAdaAST tmp68_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN); + _t = _t->getNextSibling(); + break; + } + case LIMITED: + { + RefAdaAST tmp69_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LIMITED); + _t = _t->getNextSibling(); + break; + } + case OUT: + { + RefAdaAST tmp70_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OUT); + _t = _t->getNextSibling(); + break; + } + case PRIVATE: + { + RefAdaAST tmp71_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE); + _t = _t->getNextSibling(); + break; + } + case PROTECTED: + { + RefAdaAST tmp72_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED); + _t = _t->getNextSibling(); + break; + } + case REVERSE: + { + RefAdaAST tmp73_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REVERSE); + _t = _t->getNextSibling(); + break; + } + case TAGGED: + { + RefAdaAST tmp74_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TAGGED); + _t = _t->getNextSibling(); + break; + } + default: + { + goto _loop81; + } + } + } + _loop81:; + } // ( ... )* + _t = __t79; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::id_opt(RefAdaAST _t) { + RefAdaAST id_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t83 = _t; + RefAdaAST tmp75_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ID_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case OPERATOR_SYMBOL: + { + def_designator(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t83; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::value_s(RefAdaAST _t) { + RefAdaAST value_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t475 = _t; + RefAdaAST tmp76_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VALUES); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt477=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + value(_t); + _t = _retTree; + } + else { + if ( _cnt477>=1 ) { goto _loop477; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt477++; + } + _loop477:; + } // ( ... )+ + _t = __t475; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::value(RefAdaAST _t) { + RefAdaAST value_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case OTHERS: + { + RefAdaAST __t91 = _t; + RefAdaAST tmp77_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OTHERS); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + _t = __t91; + _t = _t->getNextSibling(); + break; + } + case RIGHT_SHAFT: + { + RefAdaAST __t92 = _t; + RefAdaAST tmp78_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RIGHT_SHAFT); + _t = _t->getFirstChild(); + ranged_expr_s(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t92; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case RANGE: + case PIPE: + case DOT_DOT: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + ranged_expr_s(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::ranged_expr_s(RefAdaAST _t) { + RefAdaAST ranged_expr_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PIPE: + { + RefAdaAST __t94 = _t; + RefAdaAST tmp79_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PIPE); + _t = _t->getFirstChild(); + ranged_expr_s(_t); + _t = _retTree; + ranged_expr(_t); + _t = _retTree; + _t = __t94; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case RANGE: + case DOT_DOT: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + ranged_expr(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::ranged_expr(RefAdaAST _t) { + RefAdaAST ranged_expr_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + { + RefAdaAST __t96 = _t; + RefAdaAST tmp80_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT_DOT); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t96; + _t = _t->getNextSibling(); + break; + } + case RANGE: + { + RefAdaAST __t97 = _t; + RefAdaAST tmp81_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + range(_t); + _t = _retTree; + _t = __t97; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::simple_expression(RefAdaAST _t) { + RefAdaAST simple_expression_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PLUS: + { + RefAdaAST __t495 = _t; + RefAdaAST tmp82_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + signed_term(_t); + _t = _retTree; + _t = __t495; + _t = _t->getNextSibling(); + break; + } + case MINUS: + { + RefAdaAST __t496 = _t; + RefAdaAST tmp83_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MINUS); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + signed_term(_t); + _t = _retTree; + _t = __t496; + _t = _t->getNextSibling(); + break; + } + case CONCAT: + { + RefAdaAST __t497 = _t; + RefAdaAST tmp84_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONCAT); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + signed_term(_t); + _t = _retTree; + _t = __t497; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case NOT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + signed_term(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::range(RefAdaAST _t) { + RefAdaAST range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + { + range_dots(_t); + _t = _retTree; + break; + } + case RANGE_ATTRIBUTE_REFERENCE: + { + range_attrib_ref(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::range_constraint(RefAdaAST _t) { + RefAdaAST range_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t99 = _t; + RefAdaAST tmp85_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE_CONSTRAINT); + _t = _t->getFirstChild(); + range(_t); + _t = _retTree; + _t = __t99; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::range_dots(RefAdaAST _t) { + RefAdaAST range_dots_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t103 = _t; + RefAdaAST tmp86_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT_DOT); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t103; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::range_attrib_ref(RefAdaAST _t) { + RefAdaAST range_attrib_ref_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t105 = _t; + RefAdaAST tmp87_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE_ATTRIBUTE_REFERENCE); + _t = _t->getFirstChild(); + prefix(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t105; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prefix(RefAdaAST _t) { + RefAdaAST prefix_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp88_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case DOT: + { + RefAdaAST __t108 = _t; + RefAdaAST tmp89_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + prefix(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALL: + { + RefAdaAST tmp90_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL); + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp91_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t108; + _t = _t->getNextSibling(); + break; + } + case INDEXED_COMPONENT: + { + RefAdaAST __t110 = _t; + RefAdaAST tmp92_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEXED_COMPONENT); + _t = _t->getFirstChild(); + prefix(_t); + _t = _retTree; + value_s(_t); + _t = _retTree; + _t = __t110; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::parameter_specification(RefAdaAST _t) { + RefAdaAST parameter_specification_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t116 = _t; + RefAdaAST tmp93_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARAMETER_SPECIFICATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + subtype_mark(_t); + _t = _retTree; + init_opt(_t); + _t = _retTree; + _t = __t116; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::defining_identifier_list(RefAdaAST _t) { + RefAdaAST defining_identifier_list_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t118 = _t; + RefAdaAST tmp94_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DEFINING_IDENTIFIER_LIST); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt120=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENTIFIER)) { + RefAdaAST tmp95_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + } + else { + if ( _cnt120>=1 ) { goto _loop120; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt120++; + } + _loop120:; + } // ( ... )+ + _t = __t118; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::init_opt(RefAdaAST _t) { + RefAdaAST init_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t154 = _t; + RefAdaAST tmp96_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INIT_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t154; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::name(RefAdaAST _t) { + RefAdaAST name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp97_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case DOT: + { + RefAdaAST __t123 = _t; + RefAdaAST tmp98_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALL: + { + RefAdaAST tmp99_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL); + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp100_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp101_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL); + _t = _t->getNextSibling(); + break; + } + case OPERATOR_SYMBOL: + { + RefAdaAST tmp102_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t123; + _t = _t->getNextSibling(); + break; + } + case INDEXED_COMPONENT: + { + RefAdaAST __t125 = _t; + RefAdaAST tmp103_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEXED_COMPONENT); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + value_s(_t); + _t = _retTree; + _t = __t125; + _t = _t->getNextSibling(); + break; + } + case TIC: + { + RefAdaAST __t126 = _t; + RefAdaAST tmp104_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIC); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + attribute_id(_t); + _t = _retTree; + _t = __t126; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::parenthesized_primary(RefAdaAST _t) { + RefAdaAST parenthesized_primary_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t129 = _t; + RefAdaAST tmp105_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PARENTHESIZED_PRIMARY); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NuLL: + { + RefAdaAST tmp106_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NuLL); + _t = _t->getNextSibling(); + break; + } + case VALUES: + { + value_s(_t); + _t = _retTree; + extension_opt(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t129; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::extension_opt(RefAdaAST _t) { + RefAdaAST extension_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t132 = _t; + RefAdaAST tmp107_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXTENSION_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NuLL: + { + RefAdaAST tmp108_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NuLL); + _t = _t->getNextSibling(); + break; + } + case VALUES: + { + value_s(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t132; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::task_type_or_single_decl(RefAdaAST _t) { + RefAdaAST task_type_or_single_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case TASK_TYPE_DECLARATION: + { + RefAdaAST __t141 = _t; + RefAdaAST tmp109_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_TYPE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + discrim_part_opt(_t); + _t = _retTree; + task_definition_opt(_t); + _t = _retTree; + _t = __t141; + _t = _t->getNextSibling(); + break; + } + case SINGLE_TASK_DECLARATION: + { + RefAdaAST __t142 = _t; + RefAdaAST tmp110_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SINGLE_TASK_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + task_definition_opt(_t); + _t = _retTree; + _t = __t142; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prot_type_or_single_decl(RefAdaAST _t) { + RefAdaAST prot_type_or_single_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PROTECTED_TYPE_DECLARATION: + { + RefAdaAST __t182 = _t; + RefAdaAST tmp111_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_TYPE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + discrim_part_opt(_t); + _t = _retTree; + protected_definition(_t); + _t = _retTree; + _t = __t182; + _t = _t->getNextSibling(); + break; + } + case SINGLE_PROTECTED_DECLARATION: + { + RefAdaAST __t183 = _t; + RefAdaAST tmp112_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SINGLE_PROTECTED_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + protected_definition(_t); + _t = _retTree; + _t = __t183; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::decl_common(RefAdaAST _t) { + RefAdaAST decl_common_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ENUMERATION_TYPE_DECLARATION: + { + RefAdaAST __t202 = _t; + RefAdaAST tmp113_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION_TYPE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp114_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + enum_id_s(_t); + _t = _retTree; + _t = __t202; + _t = _t->getNextSibling(); + break; + } + case SIGNED_INTEGER_TYPE_DECLARATION: + { + RefAdaAST __t203 = _t; + RefAdaAST tmp115_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SIGNED_INTEGER_TYPE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp116_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + range(_t); + _t = _retTree; + _t = __t203; + _t = _t->getNextSibling(); + break; + } + case MODULAR_TYPE_DECLARATION: + { + RefAdaAST __t204 = _t; + RefAdaAST tmp117_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MODULAR_TYPE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp118_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + expression(_t); + _t = _retTree; + _t = __t204; + _t = _t->getNextSibling(); + break; + } + case FLOATING_POINT_DECLARATION: + { + RefAdaAST __t205 = _t; + RefAdaAST tmp119_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FLOATING_POINT_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp120_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + expression(_t); + _t = _retTree; + range_constraint_opt(_t); + _t = _retTree; + _t = __t205; + _t = _t->getNextSibling(); + break; + } + case ORDINARY_FIXED_POINT_DECLARATION: + { + RefAdaAST __t206 = _t; + RefAdaAST tmp121_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ORDINARY_FIXED_POINT_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp122_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + expression(_t); + _t = _retTree; + range(_t); + _t = _retTree; + _t = __t206; + _t = _t->getNextSibling(); + break; + } + case DECIMAL_FIXED_POINT_DECLARATION: + { + RefAdaAST __t207 = _t; + RefAdaAST tmp123_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECIMAL_FIXED_POINT_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp124_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + expression(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + range_constraint_opt(_t); + _t = _retTree; + _t = __t207; + _t = _t->getNextSibling(); + break; + } + case ARRAY_TYPE_DECLARATION: + { + array_type_declaration(_t); + _t = _retTree; + break; + } + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + { + access_type_declaration(_t); + _t = _retTree; + break; + } + case INCOMPLETE_TYPE_DECLARATION: + { + RefAdaAST __t208 = _t; + RefAdaAST tmp125_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INCOMPLETE_TYPE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp126_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + discrim_part_opt(_t); + _t = _retTree; + _t = __t208; + _t = _t->getNextSibling(); + break; + } + case PRIVATE_EXTENSION_DECLARATION: + { + RefAdaAST __t209 = _t; + RefAdaAST tmp127_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE_EXTENSION_DECLARATION); + _t = _t->getFirstChild(); + id_and_discrim(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + _t = __t209; + _t = _t->getNextSibling(); + break; + } + case DERIVED_RECORD_EXTENSION: + { + RefAdaAST __t210 = _t; + RefAdaAST tmp128_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DERIVED_RECORD_EXTENSION); + _t = _t->getFirstChild(); + id_and_discrim(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + record_definition(_t); + _t = _retTree; + _t = __t210; + _t = _t->getNextSibling(); + break; + } + case ORDINARY_DERIVED_TYPE_DECLARATION: + { + RefAdaAST __t211 = _t; + RefAdaAST tmp129_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ORDINARY_DERIVED_TYPE_DECLARATION); + _t = _t->getFirstChild(); + id_and_discrim(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + _t = __t211; + _t = _t->getNextSibling(); + break; + } + case PRIVATE_TYPE_DECLARATION: + { + RefAdaAST __t212 = _t; + RefAdaAST tmp130_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE_TYPE_DECLARATION); + _t = _t->getFirstChild(); + id_and_discrim(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + _t = __t212; + _t = _t->getNextSibling(); + break; + } + case RECORD_TYPE_DECLARATION: + { + RefAdaAST __t213 = _t; + RefAdaAST tmp131_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD_TYPE_DECLARATION); + _t = _t->getFirstChild(); + id_and_discrim(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + record_definition(_t); + _t = _retTree; + _t = __t213; + _t = _t->getNextSibling(); + break; + } + case SUBTYPE_DECLARATION: + { + RefAdaAST __t214 = _t; + RefAdaAST tmp132_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SUBTYPE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp133_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + subtype_ind(_t); + _t = _retTree; + _t = __t214; + _t = _t->getNextSibling(); + break; + } + case GENERIC_PACKAGE_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_RENAMING: + { + generic_decl(_t); + _t = _retTree; + break; + } + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + { + use_clause(_t); + _t = _retTree; + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case RECORD_REPRESENTATION_CLAUSE: + { + rep_spec(_t); + _t = _retTree; + break; + } + case EXCEPTION_RENAMING_DECLARATION: + { + RefAdaAST __t215 = _t; + RefAdaAST tmp134_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPTION_RENAMING_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + compound_name(_t); + _t = _retTree; + _t = __t215; + _t = _t->getNextSibling(); + break; + } + case OBJECT_RENAMING_DECLARATION: + { + RefAdaAST __t216 = _t; + RefAdaAST tmp135_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OBJECT_RENAMING_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + subtype_mark(_t); + _t = _retTree; + name(_t); + _t = _retTree; + _t = __t216; + _t = _t->getNextSibling(); + break; + } + case EXCEPTION_DECLARATION: + { + RefAdaAST __t217 = _t; + RefAdaAST tmp136_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPTION_DECLARATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + _t = __t217; + _t = _t->getNextSibling(); + break; + } + case NUMBER_DECLARATION: + { + RefAdaAST __t218 = _t; + RefAdaAST tmp137_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUMBER_DECLARATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t218; + _t = _t->getNextSibling(); + break; + } + case ARRAY_OBJECT_DECLARATION: + { + RefAdaAST __t219 = _t; + RefAdaAST tmp138_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARRAY_OBJECT_DECLARATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + array_type_definition(_t); + _t = _retTree; + init_opt(_t); + _t = _retTree; + _t = __t219; + _t = _t->getNextSibling(); + break; + } + case OBJECT_DECLARATION: + { + RefAdaAST __t220 = _t; + RefAdaAST tmp139_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OBJECT_DECLARATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + init_opt(_t); + _t = _retTree; + _t = __t220; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discrim_part_opt(RefAdaAST _t) { + RefAdaAST discrim_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t145 = _t; + RefAdaAST tmp140_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIM_PART_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case BOX: + { + RefAdaAST tmp141_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX); + _t = _t->getNextSibling(); + break; + } + case DISCRIMINANT_SPECIFICATIONS: + { + discriminant_specifications(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t145; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::task_definition_opt(RefAdaAST _t) { + RefAdaAST task_definition_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + task_items_opt(_t); + _t = _retTree; + private_task_items_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::task_items_opt(RefAdaAST _t) { + RefAdaAST task_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t157 = _t; + RefAdaAST tmp142_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_ITEMS_OPT); + _t = _t->getFirstChild(); + entrydecls_repspecs_opt(_t); + _t = _retTree; + _t = __t157; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::private_task_items_opt(RefAdaAST _t) { + RefAdaAST private_task_items_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t180 = _t; + RefAdaAST tmp143_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PRIVATE_TASK_ITEMS_OPT); + _t = _t->getFirstChild(); + entrydecls_repspecs_opt(_t); + _t = _retTree; + _t = __t180; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discriminant_specifications(RefAdaAST _t) { + RefAdaAST discriminant_specifications_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t148 = _t; + RefAdaAST tmp144_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_SPECIFICATIONS); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == DISCRIMINANT_SPECIFICATION)) { + discriminant_specification(_t); + _t = _retTree; + } + else { + goto _loop150; + } + + } + _loop150:; + } // ( ... )* + _t = __t148; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discriminant_specification(RefAdaAST _t) { + RefAdaAST discriminant_specification_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t152 = _t; + RefAdaAST tmp145_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_SPECIFICATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + subtype_mark(_t); + _t = _retTree; + init_opt(_t); + _t = _retTree; + _t = __t152; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entrydecls_repspecs_opt(RefAdaAST _t) { + RefAdaAST entrydecls_repspecs_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ENTRY_DECLARATION: + { + entry_declaration(_t); + _t = _retTree; + break; + } + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case RECORD_REPRESENTATION_CLAUSE: + { + rep_spec(_t); + _t = _retTree; + break; + } + default: + { + goto _loop160; + } + } + } + _loop160:; + } // ( ... )* + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_declaration(RefAdaAST _t) { + RefAdaAST entry_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t162 = _t; + RefAdaAST tmp146_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp147_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + discrete_subtype_def_opt(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t162; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::rep_spec(RefAdaAST _t) { + RefAdaAST rep_spec_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RECORD_REPRESENTATION_CLAUSE: + { + RefAdaAST __t168 = _t; + RefAdaAST tmp148_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD_REPRESENTATION_CLAUSE); + _t = _t->getFirstChild(); + subtype_mark(_t); + _t = _retTree; + align_opt(_t); + _t = _retTree; + comp_loc_s(_t); + _t = _retTree; + _t = __t168; + _t = _t->getNextSibling(); + break; + } + case AT_CLAUSE: + { + RefAdaAST __t169 = _t; + RefAdaAST tmp149_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AT_CLAUSE); + _t = _t->getFirstChild(); + subtype_mark(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t169; + _t = _t->getNextSibling(); + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + { + RefAdaAST __t170 = _t; + RefAdaAST tmp150_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ATTRIBUTE_DEFINITION_CLAUSE); + _t = _t->getFirstChild(); + subtype_mark(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t170; + _t = _t->getNextSibling(); + break; + } + case ENUMERATION_REPESENTATION_CLAUSE: + { + RefAdaAST __t171 = _t; + RefAdaAST tmp151_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENUMERATION_REPESENTATION_CLAUSE); + _t = _t->getFirstChild(); + local_enum_name(_t); + _t = _retTree; + enumeration_aggregate(_t); + _t = _retTree; + _t = __t171; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discrete_subtype_def_opt(RefAdaAST _t) { + RefAdaAST discrete_subtype_def_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t164 = _t; + RefAdaAST tmp152_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRETE_SUBTYPE_DEF_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + case SUBTYPE_INDICATION: + { + discrete_subtype_definition(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t164; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discrete_subtype_definition(RefAdaAST _t) { + RefAdaAST discrete_subtype_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + { + range(_t); + _t = _retTree; + break; + } + case SUBTYPE_INDICATION: + { + subtype_ind(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subtype_ind(RefAdaAST _t) { + RefAdaAST subtype_ind_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t239 = _t; + RefAdaAST tmp153_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SUBTYPE_INDICATION); + _t = _t->getFirstChild(); + subtype_mark(_t); + _t = _retTree; + constraint_opt(_t); + _t = _retTree; + _t = __t239; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::align_opt(RefAdaAST _t) { + RefAdaAST align_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t173 = _t; + RefAdaAST tmp154_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MOD_CLAUSE_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t173; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::comp_loc_s(RefAdaAST _t) { + RefAdaAST comp_loc_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t176 = _t; + RefAdaAST tmp155_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMPONENT_CLAUSES_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case IDENTIFIER: + case DOT: + case TIC: + { + subtype_mark(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + range(_t); + _t = _retTree; + break; + } + default: + { + goto _loop178; + } + } + } + _loop178:; + } // ( ... )* + _t = __t176; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::local_enum_name(RefAdaAST _t) { + RefAdaAST local_enum_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp156_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::enumeration_aggregate(RefAdaAST _t) { + RefAdaAST enumeration_aggregate_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_2.member(_t->getType()))) { + value(_t); + _t = _retTree; + } + else { + goto _loop293; + } + + } + _loop293:; + } // ( ... )* + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::protected_definition(RefAdaAST _t) { + RefAdaAST protected_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + prot_op_decl_s(_t); + _t = _retTree; + prot_private_opt(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prot_private_opt(RefAdaAST _t) { + RefAdaAST prot_private_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t185 = _t; + RefAdaAST tmp157_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_PRIVATE_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PROT_MEMBER_DECLARATIONS: + { + prot_member_decl_s(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t185; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prot_member_decl_s(RefAdaAST _t) { + RefAdaAST prot_member_decl_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t196 = _t; + RefAdaAST tmp158_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_MEMBER_DECLARATIONS); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENTRY_DECLARATION: + case ENUMERATION_REPESENTATION_CLAUSE: + case RECORD_REPRESENTATION_CLAUSE: + case FUNCTION_DECLARATION: + case PROCEDURE_DECLARATION: + { + prot_op_decl(_t); + _t = _retTree; + break; + } + case COMPONENT_DECLARATION: + { + comp_decl(_t); + _t = _retTree; + break; + } + default: + { + goto _loop198; + } + } + } + _loop198:; + } // ( ... )* + _t = __t196; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prot_op_decl_s(RefAdaAST _t) { + RefAdaAST prot_op_decl_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t189 = _t; + RefAdaAST tmp159_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_OP_DECLARATIONS); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_3.member(_t->getType()))) { + prot_op_decl(_t); + _t = _retTree; + } + else { + goto _loop191; + } + + } + _loop191:; + } // ( ... )* + _t = __t189; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prot_op_decl(RefAdaAST _t) { + RefAdaAST prot_op_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ENTRY_DECLARATION: + { + entry_declaration(_t); + _t = _retTree; + break; + } + case PROCEDURE_DECLARATION: + { + RefAdaAST __t193 = _t; + RefAdaAST tmp160_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t193; + _t = _t->getNextSibling(); + break; + } + case FUNCTION_DECLARATION: + { + RefAdaAST __t194 = _t; + RefAdaAST tmp161_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t194; + _t = _t->getNextSibling(); + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case RECORD_REPRESENTATION_CLAUSE: + { + rep_spec(_t); + _t = _retTree; + break; + } + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::comp_decl(RefAdaAST _t) { + RefAdaAST comp_decl_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t200 = _t; + RefAdaAST tmp162_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMPONENT_DECLARATION); + _t = _t->getFirstChild(); + defining_identifier_list(_t); + _t = _retTree; + component_subtype_def(_t); + _t = _retTree; + init_opt(_t); + _t = _retTree; + _t = __t200; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::component_subtype_def(RefAdaAST _t) { + RefAdaAST component_subtype_def_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + modifiers(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::enum_id_s(RefAdaAST _t) { + RefAdaAST enum_id_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { // ( ... )+ + int _cnt224=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENTIFIER || _t->getType() == CHARACTER_LITERAL)) { + enumeration_literal_specification(_t); + _t = _retTree; + } + else { + if ( _cnt224>=1 ) { goto _loop224; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt224++; + } + _loop224:; + } // ( ... )+ + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::range_constraint_opt(RefAdaAST _t) { + RefAdaAST range_constraint_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RANGE_CONSTRAINT: + { + range_constraint(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::array_type_declaration(RefAdaAST _t) { + RefAdaAST array_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t230 = _t; + RefAdaAST tmp163_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARRAY_TYPE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp164_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + array_type_definition(_t); + _t = _retTree; + _t = __t230; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::access_type_declaration(RefAdaAST _t) { + RefAdaAST access_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ACCESS_TO_PROCEDURE_DECLARATION: + { + RefAdaAST __t263 = _t; + RefAdaAST tmp165_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS_TO_PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp166_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + modifiers(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + _t = __t263; + _t = _t->getNextSibling(); + break; + } + case ACCESS_TO_FUNCTION_DECLARATION: + { + RefAdaAST __t264 = _t; + RefAdaAST tmp167_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS_TO_FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp168_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + modifiers(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + _t = __t264; + _t = _t->getNextSibling(); + break; + } + case ACCESS_TO_OBJECT_DECLARATION: + { + RefAdaAST __t265 = _t; + RefAdaAST tmp169_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCESS_TO_OBJECT_DECLARATION); + _t = _t->getFirstChild(); + RefAdaAST tmp170_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + modifiers(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + _t = __t265; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::id_and_discrim(RefAdaAST _t) { + RefAdaAST id_and_discrim_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp171_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + discrim_part_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::record_definition(RefAdaAST _t) { + RefAdaAST record_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMPONENT_ITEMS: + { + component_list(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::array_type_definition(RefAdaAST _t) { + RefAdaAST array_type_definition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + index_or_discrete_range_s(_t); + _t = _retTree; + component_subtype_def(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::enumeration_literal_specification(RefAdaAST _t) { + RefAdaAST enumeration_literal_specification_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp172_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp173_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::index_or_discrete_range_s(RefAdaAST _t) { + RefAdaAST index_or_discrete_range_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case RANGE: + case DOT_DOT: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case NOT: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + index_or_discrete_range(_t); + _t = _retTree; + break; + } + case COMMA: + { + RefAdaAST __t232 = _t; + RefAdaAST tmp174_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMMA); + _t = _t->getFirstChild(); + index_or_discrete_range_s(_t); + _t = _retTree; + index_or_discrete_range(_t); + _t = _retTree; + _t = __t232; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::index_or_discrete_range(RefAdaAST _t) { + RefAdaAST index_or_discrete_range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + { + RefAdaAST __t234 = _t; + RefAdaAST tmp175_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT_DOT); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t234; + _t = _t->getNextSibling(); + break; + } + case RANGE: + { + RefAdaAST __t235 = _t; + RefAdaAST tmp176_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RANGE); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case BOX: + { + RefAdaAST tmp177_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX); + _t = _t->getNextSibling(); + break; + } + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + { + range(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t235; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case NOT: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + simple_expression(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::constraint_opt(RefAdaAST _t) { + RefAdaAST constraint_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case RANGE_CONSTRAINT: + { + range_constraint(_t); + _t = _retTree; + break; + } + case DIGITS_CONSTRAINT: + { + digits_constraint(_t); + _t = _retTree; + break; + } + case DELTA_CONSTRAINT: + { + delta_constraint(_t); + _t = _retTree; + break; + } + case INDEX_CONSTRAINT: + { + index_constraint(_t); + _t = _retTree; + break; + } + case DISCRIMINANT_CONSTRAINT: + { + discriminant_constraint(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::digits_constraint(RefAdaAST _t) { + RefAdaAST digits_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t243 = _t; + RefAdaAST tmp178_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIGITS_CONSTRAINT); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + range_constraint_opt(_t); + _t = _retTree; + _t = __t243; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::delta_constraint(RefAdaAST _t) { + RefAdaAST delta_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t245 = _t; + RefAdaAST tmp179_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELTA_CONSTRAINT); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + range_constraint_opt(_t); + _t = _retTree; + _t = __t245; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::index_constraint(RefAdaAST _t) { + RefAdaAST index_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t247 = _t; + RefAdaAST tmp180_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEX_CONSTRAINT); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt249=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == DOT_DOT || _t->getType() == RANGE_ATTRIBUTE_REFERENCE || _t->getType() == SUBTYPE_INDICATION)) { + discrete_range(_t); + _t = _retTree; + } + else { + if ( _cnt249>=1 ) { goto _loop249; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt249++; + } + _loop249:; + } // ( ... )+ + _t = __t247; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discriminant_constraint(RefAdaAST _t) { + RefAdaAST discriminant_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t252 = _t; + RefAdaAST tmp181_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_CONSTRAINT); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt254=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == DISCRIMINANT_ASSOCIATION)) { + discriminant_association(_t); + _t = _retTree; + } + else { + if ( _cnt254>=1 ) { goto _loop254; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt254++; + } + _loop254:; + } // ( ... )+ + _t = __t252; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discrete_range(RefAdaAST _t) { + RefAdaAST discrete_range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + { + range(_t); + _t = _retTree; + break; + } + case SUBTYPE_INDICATION: + { + subtype_ind(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discriminant_association(RefAdaAST _t) { + RefAdaAST discriminant_association_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t256 = _t; + RefAdaAST tmp182_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DISCRIMINANT_ASSOCIATION); + _t = _t->getFirstChild(); + selector_names_opt(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t256; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::selector_names_opt(RefAdaAST _t) { + RefAdaAST selector_names_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t258 = _t; + RefAdaAST tmp183_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SELECTOR_NAMES_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == IDENTIFIER)) { + selector_name(_t); + _t = _retTree; + } + else { + goto _loop260; + } + + } + _loop260:; + } // ( ... )* + _t = __t258; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::selector_name(RefAdaAST _t) { + RefAdaAST selector_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp184_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::component_list(RefAdaAST _t) { + RefAdaAST component_list_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + component_items(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case VARIANT_PART: + { + variant_part(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::component_items(RefAdaAST _t) { + RefAdaAST component_items_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t271 = _t; + RefAdaAST tmp185_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COMPONENT_ITEMS); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case COMPONENT_DECLARATION: + { + comp_decl(_t); + _t = _retTree; + break; + } + default: + { + goto _loop273; + } + } + } + _loop273:; + } // ( ... )* + _t = __t271; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::variant_part(RefAdaAST _t) { + RefAdaAST variant_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t275 = _t; + RefAdaAST tmp186_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT_PART); + _t = _t->getFirstChild(); + discriminant_direct_name(_t); + _t = _retTree; + variant_s(_t); + _t = _retTree; + _t = __t275; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discriminant_direct_name(RefAdaAST _t) { + RefAdaAST discriminant_direct_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp187_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::variant_s(RefAdaAST _t) { + RefAdaAST variant_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t278 = _t; + RefAdaAST tmp188_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANTS); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt280=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == VARIANT)) { + variant(_t); + _t = _retTree; + } + else { + if ( _cnt280>=1 ) { goto _loop280; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt280++; + } + _loop280:; + } // ( ... )+ + _t = __t278; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::variant(RefAdaAST _t) { + RefAdaAST variant_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t282 = _t; + RefAdaAST tmp189_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT); + _t = _t->getFirstChild(); + choice_s(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case COMPONENT_ITEMS: + { + component_list(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t282; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::choice_s(RefAdaAST _t) { + RefAdaAST choice_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PIPE: + { + RefAdaAST __t285 = _t; + RefAdaAST tmp190_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PIPE); + _t = _t->getFirstChild(); + choice_s(_t); + _t = _retTree; + choice(_t); + _t = _retTree; + _t = __t285; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case OTHERS: + case DOT_DOT: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case RANGE_ATTRIBUTE_REFERENCE: + case AND_THEN: + case MARK_WITH_CONSTRAINT: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + choice(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::choice(RefAdaAST _t) { + RefAdaAST choice_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case OTHERS: + { + RefAdaAST tmp191_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OTHERS); + _t = _t->getNextSibling(); + break; + } + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + case MARK_WITH_CONSTRAINT: + { + discrete_with_range(_t); + _t = _retTree; + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::discrete_with_range(RefAdaAST _t) { + RefAdaAST discrete_with_range_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case MARK_WITH_CONSTRAINT: + { + mark_with_constraint(_t); + _t = _retTree; + break; + } + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + { + range(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::mark_with_constraint(RefAdaAST _t) { + RefAdaAST mark_with_constraint_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t289 = _t; + RefAdaAST tmp192_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MARK_WITH_CONSTRAINT); + _t = _t->getFirstChild(); + subtype_mark(_t); + _t = _retTree; + range_constraint(_t); + _t = _retTree; + _t = __t289; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::generic_formal_parameter(RefAdaAST _t) { + RefAdaAST generic_formal_parameter_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case FORMAL_DISCRETE_TYPE_DECLARATION: + { + RefAdaAST __t299 = _t; + RefAdaAST tmp193_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_DISCRETE_TYPE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t299; + _t = _t->getNextSibling(); + break; + } + case FORMAL_SIGNED_INTEGER_TYPE_DECLARATION: + { + RefAdaAST __t300 = _t; + RefAdaAST tmp194_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_SIGNED_INTEGER_TYPE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t300; + _t = _t->getNextSibling(); + break; + } + case FORMAL_MODULAR_TYPE_DECLARATION: + { + RefAdaAST __t301 = _t; + RefAdaAST tmp195_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_MODULAR_TYPE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t301; + _t = _t->getNextSibling(); + break; + } + case FORMAL_DECIMAL_FIXED_POINT_DECLARATION: + { + RefAdaAST __t302 = _t; + RefAdaAST tmp196_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_DECIMAL_FIXED_POINT_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t302; + _t = _t->getNextSibling(); + break; + } + case FORMAL_ORDINARY_FIXED_POINT_DECLARATION: + { + RefAdaAST __t303 = _t; + RefAdaAST tmp197_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_ORDINARY_FIXED_POINT_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t303; + _t = _t->getNextSibling(); + break; + } + case FORMAL_FLOATING_POINT_DECLARATION: + { + RefAdaAST __t304 = _t; + RefAdaAST tmp198_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_FLOATING_POINT_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t304; + _t = _t->getNextSibling(); + break; + } + case ARRAY_TYPE_DECLARATION: + { + formal_array_type_declaration(_t); + _t = _retTree; + break; + } + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + { + formal_access_type_declaration(_t); + _t = _retTree; + break; + } + case FORMAL_PRIVATE_TYPE_DECLARATION: + { + RefAdaAST __t305 = _t; + RefAdaAST tmp199_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PRIVATE_TYPE_DECLARATION); + _t = _t->getFirstChild(); + id_part(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + _t = __t305; + _t = _t->getNextSibling(); + break; + } + case FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION: + { + RefAdaAST __t306 = _t; + RefAdaAST tmp200_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION); + _t = _t->getFirstChild(); + id_part(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + _t = __t306; + _t = _t->getNextSibling(); + break; + } + case FORMAL_PRIVATE_EXTENSION_DECLARATION: + { + RefAdaAST __t307 = _t; + RefAdaAST tmp201_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PRIVATE_EXTENSION_DECLARATION); + _t = _t->getFirstChild(); + id_part(_t); + _t = _retTree; + modifiers(_t); + _t = _retTree; + subtype_ind(_t); + _t = _retTree; + _t = __t307; + _t = _t->getNextSibling(); + break; + } + case FORMAL_PROCEDURE_DECLARATION: + { + RefAdaAST __t308 = _t; + RefAdaAST tmp202_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PROCEDURE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + subprogram_default_opt(_t); + _t = _retTree; + _t = __t308; + _t = _t->getNextSibling(); + break; + } + case FORMAL_FUNCTION_DECLARATION: + { + RefAdaAST __t309 = _t; + RefAdaAST tmp203_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_FUNCTION_DECLARATION); + _t = _t->getFirstChild(); + def_designator(_t); + _t = _retTree; + function_tail(_t); + _t = _retTree; + subprogram_default_opt(_t); + _t = _retTree; + _t = __t309; + _t = _t->getNextSibling(); + break; + } + case FORMAL_PACKAGE_DECLARATION: + { + RefAdaAST __t310 = _t; + RefAdaAST tmp204_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FORMAL_PACKAGE_DECLARATION); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + compound_name(_t); + _t = _retTree; + formal_package_actual_part_opt(_t); + _t = _retTree; + _t = __t310; + _t = _t->getNextSibling(); + break; + } + case PARAMETER_SPECIFICATION: + { + parameter_specification(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::formal_array_type_declaration(RefAdaAST _t) { + RefAdaAST formal_array_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + array_type_declaration(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::formal_access_type_declaration(RefAdaAST _t) { + RefAdaAST formal_access_type_declaration_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + access_type_declaration(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::id_part(RefAdaAST _t) { + RefAdaAST id_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + def_id(_t); + _t = _retTree; + discrim_part_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subprogram_default_opt(RefAdaAST _t) { + RefAdaAST subprogram_default_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case BOX: + { + RefAdaAST tmp205_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX); + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case INDEXED_COMPONENT: + { + name(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::formal_package_actual_part_opt(RefAdaAST _t) { + RefAdaAST formal_package_actual_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case BOX: + { + RefAdaAST tmp206_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOX); + _t = _t->getNextSibling(); + break; + } + case DEFINING_IDENTIFIER_LIST: + { + defining_identifier_list(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::body_part(RefAdaAST _t) { + RefAdaAST body_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + declarative_part(_t); + _t = _retTree; + block_body(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::declarative_part(RefAdaAST _t) { + RefAdaAST declarative_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t324 = _t; + RefAdaAST tmp207_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECLARATIVE_PART); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case EXCEPTION_DECLARATION: + case EXCEPTION_RENAMING_DECLARATION: + case GENERIC_PACKAGE_DECLARATION: + case INCOMPLETE_TYPE_DECLARATION: + case NUMBER_DECLARATION: + case OBJECT_DECLARATION: + case OBJECT_RENAMING_DECLARATION: + case PACKAGE_BODY: + case PACKAGE_BODY_STUB: + case PACKAGE_RENAMING_DECLARATION: + case PACKAGE_SPECIFICATION: + case PRIVATE_EXTENSION_DECLARATION: + case PRIVATE_TYPE_DECLARATION: + case PROTECTED_BODY: + case PROTECTED_BODY_STUB: + case PROTECTED_TYPE_DECLARATION: + case RECORD_REPRESENTATION_CLAUSE: + case SINGLE_PROTECTED_DECLARATION: + case SINGLE_TASK_DECLARATION: + case SUBTYPE_DECLARATION: + case TASK_BODY: + case TASK_BODY_STUB: + case TASK_TYPE_DECLARATION: + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + case ARRAY_OBJECT_DECLARATION: + case ARRAY_TYPE_DECLARATION: + case DECIMAL_FIXED_POINT_DECLARATION: + case DERIVED_RECORD_EXTENSION: + case ENUMERATION_TYPE_DECLARATION: + case FLOATING_POINT_DECLARATION: + case FUNCTION_BODY: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_INSTANTIATION: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case GENERIC_PROCEDURE_RENAMING: + case MODULAR_TYPE_DECLARATION: + case ORDINARY_DERIVED_TYPE_DECLARATION: + case ORDINARY_FIXED_POINT_DECLARATION: + case PROCEDURE_BODY: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + case RECORD_TYPE_DECLARATION: + case SIGNED_INTEGER_TYPE_DECLARATION: + { + declarative_item(_t); + _t = _retTree; + break; + } + default: + { + goto _loop326; + } + } + } + _loop326:; + } // ( ... )* + _t = __t324; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::block_body(RefAdaAST _t) { + RefAdaAST block_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t343 = _t; + RefAdaAST tmp208_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK_BODY); + _t = _t->getFirstChild(); + handled_stmt_s(_t); + _t = _retTree; + _t = __t343; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::declarative_item(RefAdaAST _t) { + RefAdaAST declarative_item_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PACKAGE_BODY_STUB: + { + RefAdaAST __t328 = _t; + RefAdaAST tmp209_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY_STUB); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t328; + _t = _t->getNextSibling(); + break; + } + case PACKAGE_BODY: + { + RefAdaAST __t329 = _t; + RefAdaAST tmp210_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKAGE_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + pkg_body_part(_t); + _t = _retTree; + _t = __t329; + _t = _t->getNextSibling(); + break; + } + case PACKAGE_RENAMING_DECLARATION: + case PACKAGE_SPECIFICATION: + case GENERIC_PACKAGE_INSTANTIATION: + { + spec_decl_part(_t); + _t = _retTree; + break; + } + case TASK_BODY_STUB: + { + RefAdaAST __t330 = _t; + RefAdaAST tmp211_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_BODY_STUB); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t330; + _t = _t->getNextSibling(); + break; + } + case TASK_BODY: + { + RefAdaAST __t331 = _t; + RefAdaAST tmp212_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + body_part(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + _t = __t331; + _t = _t->getNextSibling(); + break; + } + case SINGLE_TASK_DECLARATION: + case TASK_TYPE_DECLARATION: + { + task_type_or_single_decl(_t); + _t = _retTree; + break; + } + case PROTECTED_BODY_STUB: + { + RefAdaAST __t332 = _t; + RefAdaAST tmp213_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_BODY_STUB); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + _t = __t332; + _t = _t->getNextSibling(); + break; + } + case PROTECTED_BODY: + { + RefAdaAST __t333 = _t; + RefAdaAST tmp214_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + prot_op_bodies_opt(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + _t = __t333; + _t = _t->getNextSibling(); + break; + } + case PROTECTED_TYPE_DECLARATION: + case SINGLE_PROTECTED_DECLARATION: + { + prot_type_or_single_decl(_t); + _t = _retTree; + break; + } + case ABSTRACT_FUNCTION_DECLARATION: + case ABSTRACT_PROCEDURE_DECLARATION: + case FUNCTION_BODY: + case FUNCTION_BODY_STUB: + case FUNCTION_DECLARATION: + case FUNCTION_RENAMING_DECLARATION: + case GENERIC_FUNCTION_INSTANTIATION: + case GENERIC_PROCEDURE_INSTANTIATION: + case PROCEDURE_BODY: + case PROCEDURE_BODY_STUB: + case PROCEDURE_DECLARATION: + case PROCEDURE_RENAMING_DECLARATION: + { + subprog_decl_or_rename_or_inst_or_body(_t); + _t = _retTree; + break; + } + case ATTRIBUTE_DEFINITION_CLAUSE: + case AT_CLAUSE: + case ENUMERATION_REPESENTATION_CLAUSE: + case EXCEPTION_DECLARATION: + case EXCEPTION_RENAMING_DECLARATION: + case GENERIC_PACKAGE_DECLARATION: + case INCOMPLETE_TYPE_DECLARATION: + case NUMBER_DECLARATION: + case OBJECT_DECLARATION: + case OBJECT_RENAMING_DECLARATION: + case PRIVATE_EXTENSION_DECLARATION: + case PRIVATE_TYPE_DECLARATION: + case RECORD_REPRESENTATION_CLAUSE: + case SUBTYPE_DECLARATION: + case USE_CLAUSE: + case USE_TYPE_CLAUSE: + case ACCESS_TO_FUNCTION_DECLARATION: + case ACCESS_TO_OBJECT_DECLARATION: + case ACCESS_TO_PROCEDURE_DECLARATION: + case ARRAY_OBJECT_DECLARATION: + case ARRAY_TYPE_DECLARATION: + case DECIMAL_FIXED_POINT_DECLARATION: + case DERIVED_RECORD_EXTENSION: + case ENUMERATION_TYPE_DECLARATION: + case FLOATING_POINT_DECLARATION: + case GENERIC_FUNCTION_DECLARATION: + case GENERIC_FUNCTION_RENAMING: + case GENERIC_PACKAGE_RENAMING: + case GENERIC_PROCEDURE_DECLARATION: + case GENERIC_PROCEDURE_RENAMING: + case MODULAR_TYPE_DECLARATION: + case ORDINARY_DERIVED_TYPE_DECLARATION: + case ORDINARY_FIXED_POINT_DECLARATION: + case RECORD_TYPE_DECLARATION: + case SIGNED_INTEGER_TYPE_DECLARATION: + { + decl_common(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::prot_op_bodies_opt(RefAdaAST _t) { + RefAdaAST prot_op_bodies_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t339 = _t; + RefAdaAST tmp215_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROT_OP_BODIES_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case ENTRY_BODY: + { + entry_body(_t); + _t = _retTree; + break; + } + case FUNCTION_BODY: + case FUNCTION_DECLARATION: + case PROCEDURE_BODY: + case PROCEDURE_DECLARATION: + { + subprog_decl_or_body(_t); + _t = _retTree; + break; + } + default: + { + goto _loop341; + } + } + } + _loop341:; + } // ( ... )* + _t = __t339; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::block_body_opt(RefAdaAST _t) { + RefAdaAST block_body_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t336 = _t; + RefAdaAST tmp216_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK_BODY_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case HANDLED_SEQUENCE_OF_STATEMENTS: + { + handled_stmt_s(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t336; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::handled_stmt_s(RefAdaAST _t) { + RefAdaAST handled_stmt_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t345 = _t; + RefAdaAST tmp217_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),HANDLED_SEQUENCE_OF_STATEMENTS); + _t = _t->getFirstChild(); + statements(_t); + _t = _retTree; + except_handler_part_opt(_t); + _t = _retTree; + _t = __t345; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_body(RefAdaAST _t) { + RefAdaAST entry_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t405 = _t; + RefAdaAST tmp218_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + entry_body_formal_part(_t); + _t = _retTree; + entry_barrier(_t); + _t = _retTree; + body_part(_t); + _t = _retTree; + _t = __t405; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::statements(RefAdaAST _t) { + RefAdaAST statements_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t350 = _t; + RefAdaAST tmp219_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SEQUENCE_OF_STATEMENTS); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt352=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case STATEMENT: + { + statement(_t); + _t = _retTree; + break; + } + default: + { + if ( _cnt352>=1 ) { goto _loop352; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + } + _cnt352++; + } + _loop352:; + } // ( ... )+ + _t = __t350; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::except_handler_part_opt(RefAdaAST _t) { + RefAdaAST except_handler_part_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t455 = _t; + RefAdaAST tmp220_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPT_HANDLER_PART_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == EXCEPTION_HANDLER)) { + exception_handler(_t); + _t = _retTree; + } + else { + goto _loop457; + } + + } + _loop457:; + } // ( ... )* + _t = __t455; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::handled_stmts_opt(RefAdaAST _t) { + RefAdaAST handled_stmts_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t347 = _t; + RefAdaAST tmp221_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),HANDLED_STMTS_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case SEQUENCE_OF_STATEMENTS: + { + statements(_t); + _t = _retTree; + except_handler_part_opt(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t347; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::statement(RefAdaAST _t) { + RefAdaAST statement_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t354 = _t; + RefAdaAST tmp222_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STATEMENT); + _t = _t->getFirstChild(); + def_label_opt(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NULL_STATEMENT: + { + null_stmt(_t); + _t = _retTree; + break; + } + case EXIT_STATEMENT: + { + exit_stmt(_t); + _t = _retTree; + break; + } + case RETURN_STATEMENT: + { + return_stmt(_t); + _t = _retTree; + break; + } + case GOTO_STATEMENT: + { + goto_stmt(_t); + _t = _retTree; + break; + } + case DELAY_STATEMENT: + { + delay_stmt(_t); + _t = _retTree; + break; + } + case ABORT_STATEMENT: + { + abort_stmt(_t); + _t = _retTree; + break; + } + case RAISE_STATEMENT: + { + raise_stmt(_t); + _t = _retTree; + break; + } + case REQUEUE_STATEMENT: + { + requeue_stmt(_t); + _t = _retTree; + break; + } + case ACCEPT_STATEMENT: + { + accept_stmt(_t); + _t = _retTree; + break; + } + case ASYNCHRONOUS_SELECT: + case CONDITIONAL_ENTRY_CALL: + case SELECTIVE_ACCEPT: + case TIMED_ENTRY_CALL: + { + select_stmt(_t); + _t = _retTree; + break; + } + case IF_STATEMENT: + { + if_stmt(_t); + _t = _retTree; + break; + } + case CASE_STATEMENT: + { + case_stmt(_t); + _t = _retTree; + break; + } + case LOOP_STATEMENT: + { + loop_stmt(_t); + _t = _retTree; + id_opt(_t); + _t = _retTree; + break; + } + case BLOCK_STATEMENT: + { + block(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + break; + } + case ASSIGNMENT_STATEMENT: + case CALL_STATEMENT: + { + call_or_assignment(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t354; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::def_label_opt(RefAdaAST _t) { + RefAdaAST def_label_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t357 = _t; + RefAdaAST tmp223_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LABEL_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp224_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t357; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::null_stmt(RefAdaAST _t) { + RefAdaAST null_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp225_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NULL_STATEMENT); + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::exit_stmt(RefAdaAST _t) { + RefAdaAST exit_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t392 = _t; + RefAdaAST tmp226_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXIT_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + label_name(_t); + _t = _retTree; + break; + } + case 3: + case WHEN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case WHEN: + { + RefAdaAST tmp227_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHEN); + _t = _t->getNextSibling(); + condition(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t392; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::return_stmt(RefAdaAST _t) { + RefAdaAST return_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t397 = _t; + RefAdaAST tmp228_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RETURN_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t397; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::goto_stmt(RefAdaAST _t) { + RefAdaAST goto_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t400 = _t; + RefAdaAST tmp229_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GOTO_STATEMENT); + _t = _t->getFirstChild(); + label_name(_t); + _t = _retTree; + _t = __t400; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::delay_stmt(RefAdaAST _t) { + RefAdaAST delay_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t419 = _t; + RefAdaAST tmp230_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELAY_STATEMENT); + _t = _t->getFirstChild(); + modifiers(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t419; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::abort_stmt(RefAdaAST _t) { + RefAdaAST abort_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t451 = _t; + RefAdaAST tmp231_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABORT_STATEMENT); + _t = _t->getFirstChild(); + { // ( ... )+ + int _cnt453=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_tokenSet_4.member(_t->getType()))) { + name(_t); + _t = _retTree; + } + else { + if ( _cnt453>=1 ) { goto _loop453; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt453++; + } + _loop453:; + } // ( ... )+ + _t = __t451; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::raise_stmt(RefAdaAST _t) { + RefAdaAST raise_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t467 = _t; + RefAdaAST tmp232_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RAISE_STATEMENT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + { + compound_name(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t467; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::requeue_stmt(RefAdaAST _t) { + RefAdaAST requeue_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t470 = _t; + RefAdaAST tmp233_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REQUEUE_STATEMENT); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ABORT: + { + RefAdaAST tmp234_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABORT); + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t470; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::accept_stmt(RefAdaAST _t) { + RefAdaAST accept_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t414 = _t; + RefAdaAST tmp235_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCEPT_STATEMENT); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + entry_index_opt(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + handled_stmts_opt(_t); + _t = _retTree; + end_id_opt(_t); + _t = _retTree; + _t = __t414; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::select_stmt(RefAdaAST _t) { + RefAdaAST select_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ASYNCHRONOUS_SELECT: + { + RefAdaAST __t421 = _t; + RefAdaAST tmp236_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASYNCHRONOUS_SELECT); + _t = _t->getFirstChild(); + triggering_alternative(_t); + _t = _retTree; + abortable_part(_t); + _t = _retTree; + _t = __t421; + _t = _t->getNextSibling(); + break; + } + case SELECTIVE_ACCEPT: + { + RefAdaAST __t422 = _t; + RefAdaAST tmp237_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SELECTIVE_ACCEPT); + _t = _t->getFirstChild(); + selective_accept(_t); + _t = _retTree; + _t = __t422; + _t = _t->getNextSibling(); + break; + } + case TIMED_ENTRY_CALL: + { + RefAdaAST __t423 = _t; + RefAdaAST tmp238_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIMED_ENTRY_CALL); + _t = _t->getFirstChild(); + entry_call_alternative(_t); + _t = _retTree; + delay_alternative(_t); + _t = _retTree; + _t = __t423; + _t = _t->getNextSibling(); + break; + } + case CONDITIONAL_ENTRY_CALL: + { + RefAdaAST __t424 = _t; + RefAdaAST tmp239_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONDITIONAL_ENTRY_CALL); + _t = _t->getFirstChild(); + entry_call_alternative(_t); + _t = _retTree; + statements(_t); + _t = _retTree; + _t = __t424; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::if_stmt(RefAdaAST _t) { + RefAdaAST if_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t361 = _t; + RefAdaAST tmp240_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF_STATEMENT); + _t = _t->getFirstChild(); + cond_clause(_t); + _t = _retTree; + elsifs_opt(_t); + _t = _retTree; + else_opt(_t); + _t = _retTree; + _t = __t361; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::case_stmt(RefAdaAST _t) { + RefAdaAST case_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t373 = _t; + RefAdaAST tmp241_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CASE_STATEMENT); + _t = _t->getFirstChild(); + expression(_t); + _t = _retTree; + alternative_s(_t); + _t = _retTree; + _t = __t373; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::loop_stmt(RefAdaAST _t) { + RefAdaAST loop_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t380 = _t; + RefAdaAST tmp242_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LOOP_STATEMENT); + _t = _t->getFirstChild(); + iteration_scheme_opt(_t); + _t = _retTree; + statements(_t); + _t = _retTree; + _t = __t380; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::block(RefAdaAST _t) { + RefAdaAST block_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t387 = _t; + RefAdaAST tmp243_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK_STATEMENT); + _t = _t->getFirstChild(); + declare_opt(_t); + _t = _retTree; + block_body(_t); + _t = _retTree; + _t = __t387; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::call_or_assignment(RefAdaAST _t) { + RefAdaAST call_or_assignment_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ASSIGNMENT_STATEMENT: + { + RefAdaAST __t402 = _t; + RefAdaAST tmp244_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGNMENT_STATEMENT); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + expression(_t); + _t = _retTree; + _t = __t402; + _t = _t->getNextSibling(); + break; + } + case CALL_STATEMENT: + { + RefAdaAST __t403 = _t; + RefAdaAST tmp245_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CALL_STATEMENT); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + _t = __t403; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::cond_clause(RefAdaAST _t) { + RefAdaAST cond_clause_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t363 = _t; + RefAdaAST tmp246_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COND_CLAUSE); + _t = _t->getFirstChild(); + condition(_t); + _t = _retTree; + statements(_t); + _t = _retTree; + _t = __t363; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::elsifs_opt(RefAdaAST _t) { + RefAdaAST elsifs_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t366 = _t; + RefAdaAST tmp247_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSIFS_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == COND_CLAUSE)) { + cond_clause(_t); + _t = _retTree; + } + else { + goto _loop368; + } + + } + _loop368:; + } // ( ... )* + _t = __t366; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::else_opt(RefAdaAST _t) { + RefAdaAST else_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t370 = _t; + RefAdaAST tmp248_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ELSE_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case SEQUENCE_OF_STATEMENTS: + { + statements(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t370; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::condition(RefAdaAST _t) { + RefAdaAST condition_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + expression(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::alternative_s(RefAdaAST _t) { + RefAdaAST alternative_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { // ( ... )+ + int _cnt376=0; + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == CASE_STATEMENT_ALTERNATIVE)) { + case_statement_alternative(_t); + _t = _retTree; + } + else { + if ( _cnt376>=1 ) { goto _loop376; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));} + } + + _cnt376++; + } + _loop376:; + } // ( ... )+ + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::case_statement_alternative(RefAdaAST _t) { + RefAdaAST case_statement_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t378 = _t; + RefAdaAST tmp249_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CASE_STATEMENT_ALTERNATIVE); + _t = _t->getFirstChild(); + choice_s(_t); + _t = _retTree; + statements(_t); + _t = _retTree; + _t = __t378; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::iteration_scheme_opt(RefAdaAST _t) { + RefAdaAST iteration_scheme_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t382 = _t; + RefAdaAST tmp250_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ITERATION_SCHEME_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case WHILE: + { + RefAdaAST __t384 = _t; + RefAdaAST tmp251_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHILE); + _t = _t->getFirstChild(); + condition(_t); + _t = _retTree; + _t = __t384; + _t = _t->getNextSibling(); + break; + } + case FOR: + { + RefAdaAST __t385 = _t; + RefAdaAST tmp252_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR); + _t = _t->getFirstChild(); + RefAdaAST tmp253_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + modifiers(_t); + _t = _retTree; + discrete_subtype_definition(_t); + _t = _retTree; + _t = __t385; + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t382; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::declare_opt(RefAdaAST _t) { + RefAdaAST declare_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t389 = _t; + RefAdaAST tmp254_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DECLARE_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DECLARATIVE_PART: + { + declarative_part(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t389; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::label_name(RefAdaAST _t) { + RefAdaAST label_name_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST tmp255_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_body_formal_part(RefAdaAST _t) { + RefAdaAST entry_body_formal_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + entry_index_spec_opt(_t); + _t = _retTree; + formal_part_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_barrier(RefAdaAST _t) { + RefAdaAST entry_barrier_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + condition(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_index_spec_opt(RefAdaAST _t) { + RefAdaAST entry_index_spec_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t408 = _t; + RefAdaAST tmp256_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_INDEX_SPECIFICATION); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + { + def_id(_t); + _t = _retTree; + discrete_subtype_definition(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t408; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_call_stmt(RefAdaAST _t) { + RefAdaAST entry_call_stmt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t412 = _t; + RefAdaAST tmp257_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_CALL_STATEMENT); + _t = _t->getFirstChild(); + name(_t); + _t = _retTree; + _t = __t412; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_index_opt(RefAdaAST _t) { + RefAdaAST entry_index_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t416 = _t; + RefAdaAST tmp258_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_INDEX_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + expression(_t); + _t = _retTree; + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t416; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::triggering_alternative(RefAdaAST _t) { + RefAdaAST triggering_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t426 = _t; + RefAdaAST tmp259_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TRIGGERING_ALTERNATIVE); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DELAY_STATEMENT: + { + delay_stmt(_t); + _t = _retTree; + break; + } + case ENTRY_CALL_STATEMENT: + { + entry_call_stmt(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + stmts_opt(_t); + _t = _retTree; + _t = __t426; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::abortable_part(RefAdaAST _t) { + RefAdaAST abortable_part_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t429 = _t; + RefAdaAST tmp260_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABORTABLE_PART); + _t = _t->getFirstChild(); + stmts_opt(_t); + _t = _retTree; + _t = __t429; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::selective_accept(RefAdaAST _t) { + RefAdaAST selective_accept_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + guard_opt(_t); + _t = _retTree; + select_alternative(_t); + _t = _retTree; + or_select_opt(_t); + _t = _retTree; + else_opt(_t); + _t = _retTree; + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::entry_call_alternative(RefAdaAST _t) { + RefAdaAST entry_call_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t431 = _t; + RefAdaAST tmp261_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ENTRY_CALL_ALTERNATIVE); + _t = _t->getFirstChild(); + entry_call_stmt(_t); + _t = _retTree; + stmts_opt(_t); + _t = _retTree; + _t = __t431; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::delay_alternative(RefAdaAST _t) { + RefAdaAST delay_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t442 = _t; + RefAdaAST tmp262_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DELAY_ALTERNATIVE); + _t = _t->getFirstChild(); + delay_stmt(_t); + _t = _retTree; + stmts_opt(_t); + _t = _retTree; + _t = __t442; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::stmts_opt(RefAdaAST _t) { + RefAdaAST stmts_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PRAGMA: + { + pragma(_t); + _t = _retTree; + break; + } + case STATEMENT: + { + statement(_t); + _t = _retTree; + break; + } + default: + { + goto _loop445; + } + } + } + _loop445:; + } // ( ... )* + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::guard_opt(RefAdaAST _t) { + RefAdaAST guard_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t434 = _t; + RefAdaAST tmp263_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GUARD_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case IN: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case OR: + case AND: + case XOR: + case NOT: + case EQ: + case NE: + case LT_: + case LE: + case GT: + case GE: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case AND_THEN: + case NOT_IN: + case OR_ELSE: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + condition(_t); + _t = _retTree; + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == PRAGMA)) { + pragma(_t); + _t = _retTree; + } + else { + goto _loop437; + } + + } + _loop437:; + } // ( ... )* + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t434; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::select_alternative(RefAdaAST _t) { + RefAdaAST select_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ACCEPT_ALTERNATIVE: + { + accept_alternative(_t); + _t = _retTree; + break; + } + case DELAY_ALTERNATIVE: + { + delay_alternative(_t); + _t = _retTree; + break; + } + case TERMINATE_ALTERNATIVE: + { + RefAdaAST tmp264_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TERMINATE_ALTERNATIVE); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::or_select_opt(RefAdaAST _t) { + RefAdaAST or_select_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t447 = _t; + RefAdaAST tmp265_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR_SELECT_OPT); + _t = _t->getFirstChild(); + { // ( ... )* + for (;;) { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + if ((_t->getType() == GUARD_OPT)) { + guard_opt(_t); + _t = _retTree; + select_alternative(_t); + _t = _retTree; + } + else { + goto _loop449; + } + + } + _loop449:; + } // ( ... )* + _t = __t447; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::accept_alternative(RefAdaAST _t) { + RefAdaAST accept_alternative_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t440 = _t; + RefAdaAST tmp266_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ACCEPT_ALTERNATIVE); + _t = _t->getFirstChild(); + accept_stmt(_t); + _t = _retTree; + stmts_opt(_t); + _t = _retTree; + _t = __t440; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::exception_handler(RefAdaAST _t) { + RefAdaAST exception_handler_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t459 = _t; + RefAdaAST tmp267_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXCEPTION_HANDLER); + _t = _t->getFirstChild(); + identifier_colon_opt(_t); + _t = _retTree; + except_choice_s(_t); + _t = _retTree; + statements(_t); + _t = _retTree; + _t = __t459; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::identifier_colon_opt(RefAdaAST _t) { + RefAdaAST identifier_colon_opt_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t461 = _t; + RefAdaAST tmp268_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER_COLON_OPT); + _t = _t->getFirstChild(); + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp269_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case 3: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t461; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::except_choice_s(RefAdaAST _t) { + RefAdaAST except_choice_s_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PIPE: + { + RefAdaAST __t464 = _t; + RefAdaAST tmp270_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PIPE); + _t = _t->getFirstChild(); + except_choice_s(_t); + _t = _retTree; + exception_choice(_t); + _t = _retTree; + _t = __t464; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case OTHERS: + { + exception_choice(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::exception_choice(RefAdaAST _t) { + RefAdaAST exception_choice_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + { + compound_name(_t); + _t = _retTree; + break; + } + case OTHERS: + { + RefAdaAST tmp271_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OTHERS); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::operator_call(RefAdaAST _t) { + RefAdaAST operator_call_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t473 = _t; + RefAdaAST tmp272_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL); + _t = _t->getFirstChild(); + value_s(_t); + _t = _retTree; + _t = __t473; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::relation(RefAdaAST _t) { + RefAdaAST relation_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IN: + { + RefAdaAST __t485 = _t; + RefAdaAST tmp273_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + range_or_mark(_t); + _t = _retTree; + _t = __t485; + _t = _t->getNextSibling(); + break; + } + case NOT_IN: + { + RefAdaAST __t486 = _t; + RefAdaAST tmp274_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT_IN); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + range_or_mark(_t); + _t = _retTree; + _t = __t486; + _t = _t->getNextSibling(); + break; + } + case EQ: + { + RefAdaAST __t487 = _t; + RefAdaAST tmp275_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQ); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t487; + _t = _t->getNextSibling(); + break; + } + case NE: + { + RefAdaAST __t488 = _t; + RefAdaAST tmp276_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NE); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t488; + _t = _t->getNextSibling(); + break; + } + case LT_: + { + RefAdaAST __t489 = _t; + RefAdaAST tmp277_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LT_); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t489; + _t = _t->getNextSibling(); + break; + } + case LE: + { + RefAdaAST __t490 = _t; + RefAdaAST tmp278_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LE); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t490; + _t = _t->getNextSibling(); + break; + } + case GT: + { + RefAdaAST __t491 = _t; + RefAdaAST tmp279_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GT); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t491; + _t = _t->getNextSibling(); + break; + } + case GE: + { + RefAdaAST __t492 = _t; + RefAdaAST tmp280_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GE); + _t = _t->getFirstChild(); + simple_expression(_t); + _t = _retTree; + simple_expression(_t); + _t = _retTree; + _t = __t492; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case NOT: + case PLUS: + case MINUS: + case CONCAT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + case UNARY_MINUS: + case UNARY_PLUS: + { + simple_expression(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::range_or_mark(RefAdaAST _t) { + RefAdaAST range_or_mark_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case DOT_DOT: + case RANGE_ATTRIBUTE_REFERENCE: + { + range(_t); + _t = _retTree; + break; + } + case IDENTIFIER: + case DOT: + case TIC: + { + subtype_mark(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::signed_term(RefAdaAST _t) { + RefAdaAST signed_term_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case UNARY_PLUS: + { + RefAdaAST __t499 = _t; + RefAdaAST tmp281_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_PLUS); + _t = _t->getFirstChild(); + term(_t); + _t = _retTree; + _t = __t499; + _t = _t->getNextSibling(); + break; + } + case UNARY_MINUS: + { + RefAdaAST __t500 = _t; + RefAdaAST tmp282_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNARY_MINUS); + _t = _t->getFirstChild(); + term(_t); + _t = _retTree; + _t = __t500; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case MOD: + case NOT: + case STAR: + case DIV: + case REM: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + { + term(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::term(RefAdaAST _t) { + RefAdaAST term_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case STAR: + { + RefAdaAST __t502 = _t; + RefAdaAST tmp283_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STAR); + _t = _t->getFirstChild(); + term(_t); + _t = _retTree; + factor(_t); + _t = _retTree; + _t = __t502; + _t = _t->getNextSibling(); + break; + } + case DIV: + { + RefAdaAST __t503 = _t; + RefAdaAST tmp284_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIV); + _t = _t->getFirstChild(); + term(_t); + _t = _retTree; + factor(_t); + _t = _retTree; + _t = __t503; + _t = _t->getNextSibling(); + break; + } + case MOD: + { + RefAdaAST __t504 = _t; + RefAdaAST tmp285_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MOD); + _t = _t->getFirstChild(); + term(_t); + _t = _retTree; + factor(_t); + _t = _retTree; + _t = __t504; + _t = _t->getNextSibling(); + break; + } + case REM: + { + RefAdaAST __t505 = _t; + RefAdaAST tmp286_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REM); + _t = _t->getFirstChild(); + term(_t); + _t = _retTree; + factor(_t); + _t = _retTree; + _t = __t505; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case ABS: + case EXPON: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + { + factor(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::factor(RefAdaAST _t) { + RefAdaAST factor_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case NOT: + { + RefAdaAST __t507 = _t; + RefAdaAST tmp287_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT); + _t = _t->getFirstChild(); + primary(_t); + _t = _retTree; + _t = __t507; + _t = _t->getNextSibling(); + break; + } + case ABS: + { + RefAdaAST __t508 = _t; + RefAdaAST tmp288_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ABS); + _t = _t->getFirstChild(); + primary(_t); + _t = _retTree; + _t = __t508; + _t = _t->getNextSibling(); + break; + } + case EXPON: + { + RefAdaAST __t509 = _t; + RefAdaAST tmp289_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EXPON); + _t = _t->getFirstChild(); + primary(_t); + _t = _retTree; + primary(_t); + _t = _retTree; + _t = __t509; + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + case DOT: + case TIC: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NUMERIC_LIT: + case ALLOCATOR: + case INDEXED_COMPONENT: + case OPERATOR_SYMBOL: + case PARENTHESIZED_PRIMARY: + { + primary(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::primary(RefAdaAST _t) { + RefAdaAST primary_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + case DOT: + case TIC: + case INDEXED_COMPONENT: + { + name_or_qualified(_t); + _t = _retTree; + break; + } + case PARENTHESIZED_PRIMARY: + { + parenthesized_primary(_t); + _t = _retTree; + break; + } + case ALLOCATOR: + { + allocator(_t); + _t = _retTree; + break; + } + case NuLL: + { + RefAdaAST tmp290_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NuLL); + _t = _t->getNextSibling(); + break; + } + case NUMERIC_LIT: + { + RefAdaAST tmp291_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUMERIC_LIT); + _t = _t->getNextSibling(); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp292_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL); + _t = _t->getNextSibling(); + break; + } + case CHAR_STRING: + { + RefAdaAST tmp293_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHAR_STRING); + _t = _t->getNextSibling(); + break; + } + case OPERATOR_SYMBOL: + { + operator_call(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::name_or_qualified(RefAdaAST _t) { + RefAdaAST name_or_qualified_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case IDENTIFIER: + { + RefAdaAST tmp294_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case DOT: + { + RefAdaAST __t513 = _t; + RefAdaAST tmp295_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT); + _t = _t->getFirstChild(); + name_or_qualified(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case ALL: + { + RefAdaAST tmp296_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALL); + _t = _t->getNextSibling(); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp297_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENTIFIER); + _t = _t->getNextSibling(); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp298_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHARACTER_LITERAL); + _t = _t->getNextSibling(); + break; + } + case OPERATOR_SYMBOL: + { + RefAdaAST tmp299_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OPERATOR_SYMBOL); + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t513; + _t = _t->getNextSibling(); + break; + } + case INDEXED_COMPONENT: + { + RefAdaAST __t515 = _t; + RefAdaAST tmp300_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INDEXED_COMPONENT); + _t = _t->getFirstChild(); + name_or_qualified(_t); + _t = _retTree; + value_s(_t); + _t = _retTree; + _t = __t515; + _t = _t->getNextSibling(); + break; + } + case TIC: + { + RefAdaAST __t516 = _t; + RefAdaAST tmp301_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TIC); + _t = _t->getFirstChild(); + name_or_qualified(_t); + _t = _retTree; + { + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PARENTHESIZED_PRIMARY: + { + parenthesized_primary(_t); + _t = _retTree; + break; + } + case IDENTIFIER: + case RANGE: + case DIGITS: + case DELTA: + case ACCESS: + { + attribute_id(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + _t = __t516; + _t = _t->getNextSibling(); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::allocator(RefAdaAST _t) { + RefAdaAST allocator_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t519 = _t; + RefAdaAST tmp302_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ALLOCATOR); + _t = _t->getFirstChild(); + name_or_qualified(_t); + _t = _retTree; + _t = __t519; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::subprogram_body(RefAdaAST _t) { + RefAdaAST subprogram_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + if (_t == RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = ASTNULL; + switch ( _t->getType()) { + case PROCEDURE_BODY: + { + procedure_body(_t); + _t = _retTree; + break; + } + case FUNCTION_BODY: + { + function_body(_t); + _t = _retTree; + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t)); + } + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::task_body(RefAdaAST _t) { + RefAdaAST task_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t525 = _t; + RefAdaAST tmp303_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TASK_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + body_part(_t); + _t = _retTree; + _t = __t525; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::protected_body(RefAdaAST _t) { + RefAdaAST protected_body_AST_in = (_t == RefAdaAST(ASTNULL)) ? RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t; + + try { // for error handling + RefAdaAST __t527 = _t; + RefAdaAST tmp304_AST_in = _t; + match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROTECTED_BODY); + _t = _t->getFirstChild(); + def_id(_t); + _t = _retTree; + prot_op_bodies_opt(_t); + _t = _retTree; + _t = __t527; + _t = _t->getNextSibling(); + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { + reportError(ex); + if ( _t != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + _t = _t->getNextSibling(); + } + _retTree = _t; +} + +void AdaStoreWalker::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& ) +{ +} +const char* AdaStoreWalker::tokenNames[] = { + "<0>", + "EOF", + "<2>", + "NULL_TREE_LOOKAHEAD", + "\"pragma\"", + "IDENTIFIER", + "SEMI", + "LPAREN", + "COMMA", + "RPAREN", + "RIGHT_SHAFT", + "\"with\"", + "DOT", + "\"use\"", + "\"type\"", + "TIC", + "\"range\"", + "\"digits\"", + "\"delta\"", + "\"access\"", + "\"private\"", + "\"package\"", + "\"body\"", + "\"is\"", + "\"procedure\"", + "\"function\"", + "\"new\"", + "\"others\"", + "PIPE", + "DOT_DOT", + "\"all\"", + "COLON", + "\"in\"", + "\"out\"", + "\"renames\"", + "CHARACTER_LITERAL", + "CHAR_STRING", + "\"null\"", + "\"record\"", + "\"separate\"", + "\"abstract\"", + "\"return\"", + "\"task\"", + "\"protected\"", + "BOX", + "ASSIGN", + "\"entry\"", + "\"for\"", + "\"end\"", + "\"at\"", + "\"mod\"", + "\"subtype\"", + "\"exception\"", + "\"constant\"", + "\"array\"", + "\"of\"", + "\"aliased\"", + "\"case\"", + "\"when\"", + "\"tagged\"", + "\"limited\"", + "\"generic\"", + "\"begin\"", + "LT_LT", + "GT_GT", + "\"if\"", + "\"then\"", + "\"elsif\"", + "\"else\"", + "\"loop\"", + "\"while\"", + "\"reverse\"", + "\"declare\"", + "\"exit\"", + "\"goto\"", + "\"accept\"", + "\"do\"", + "\"delay\"", + "\"until\"", + "\"select\"", + "\"abort\"", + "\"or\"", + "\"terminate\"", + "\"raise\"", + "\"requeue\"", + "\"and\"", + "\"xor\"", + "\"not\"", + "EQ", + "NE", + "LT_", + "LE", + "GT", + "GE", + "PLUS", + "MINUS", + "CONCAT", + "STAR", + "DIV", + "\"rem\"", + "\"abs\"", + "EXPON", + "NUMERIC_LIT", + "ABORTABLE_PART", + "ABORT_STATEMENT", + "ACCEPT_ALTERNATIVE", + "ACCEPT_STATEMENT", + "ALLOCATOR", + "ASSIGNMENT_STATEMENT", + "ASYNCHRONOUS_SELECT", + "ATTRIBUTE_DEFINITION_CLAUSE", + "AT_CLAUSE", + "BLOCK_STATEMENT", + "CASE_STATEMENT", + "CASE_STATEMENT_ALTERNATIVE", + "CODE_STATEMENT", + "COMPONENT_DECLARATION", + "CONDITIONAL_ENTRY_CALL", + "CONTEXT_CLAUSE", + "DECLARATIVE_PART", + "DEFINING_IDENTIFIER_LIST", + "DELAY_ALTERNATIVE", + "DELAY_STATEMENT", + "DELTA_CONSTRAINT", + "DIGITS_CONSTRAINT", + "DISCRIMINANT_ASSOCIATION", + "DISCRIMINANT_CONSTRAINT", + "DISCRIMINANT_SPECIFICATION", + "ENTRY_BODY", + "ENTRY_CALL_ALTERNATIVE", + "ENTRY_CALL_STATEMENT", + "ENTRY_DECLARATION", + "ENTRY_INDEX_SPECIFICATION", + "ENUMERATION_REPESENTATION_CLAUSE", + "EXCEPTION_DECLARATION", + "EXCEPTION_HANDLER", + "EXCEPTION_RENAMING_DECLARATION", + "EXIT_STATEMENT", + "FORMAL_PACKAGE_DECLARATION", + "GENERIC_FORMAL_PART", + "GENERIC_PACKAGE_DECLARATION", + "GOTO_STATEMENT", + "HANDLED_SEQUENCE_OF_STATEMENTS", + "HANDLED_STMTS_OPT", + "IF_STATEMENT", + "INCOMPLETE_TYPE_DECLARATION", + "INDEXED_COMPONENT", + "INDEX_CONSTRAINT", + "LIBRARY_ITEM", + "LOOP_STATEMENT", + "NAME", + "NULL_STATEMENT", + "NUMBER_DECLARATION", + "OBJECT_DECLARATION", + "OBJECT_RENAMING_DECLARATION", + "OPERATOR_SYMBOL", + "PACKAGE_BODY", + "PACKAGE_BODY_STUB", + "PACKAGE_RENAMING_DECLARATION", + "PACKAGE_SPECIFICATION", + "PARAMETER_SPECIFICATION", + "PRIVATE_EXTENSION_DECLARATION", + "PRIVATE_TYPE_DECLARATION", + "PROTECTED_BODY", + "PROTECTED_BODY_STUB", + "PROTECTED_TYPE_DECLARATION", + "RAISE_STATEMENT", + "RANGE_ATTRIBUTE_REFERENCE", + "RECORD_REPRESENTATION_CLAUSE", + "REQUEUE_STATEMENT", + "RETURN_STATEMENT", + "SELECTIVE_ACCEPT", + "SEQUENCE_OF_STATEMENTS", + "SINGLE_PROTECTED_DECLARATION", + "SINGLE_TASK_DECLARATION", + "STATEMENT", + "SUBTYPE_DECLARATION", + "SUBTYPE_INDICATION", + "SUBTYPE_MARK", + "SUBUNIT", + "TASK_BODY", + "TASK_BODY_STUB", + "TASK_TYPE_DECLARATION", + "TERMINATE_ALTERNATIVE", + "TIMED_ENTRY_CALL", + "TRIGGERING_ALTERNATIVE", + "USE_CLAUSE", + "USE_TYPE_CLAUSE", + "VARIANT", + "VARIANT_PART", + "WITH_CLAUSE", + "ABSTRACT_FUNCTION_DECLARATION", + "ABSTRACT_PROCEDURE_DECLARATION", + "ACCESS_TO_FUNCTION_DECLARATION", + "ACCESS_TO_OBJECT_DECLARATION", + "ACCESS_TO_PROCEDURE_DECLARATION", + "ARRAY_OBJECT_DECLARATION", + "ARRAY_TYPE_DECLARATION", + "AND_THEN", + "BASIC_DECLARATIVE_ITEMS_OPT", + "BLOCK_BODY", + "BLOCK_BODY_OPT", + "CALL_STATEMENT", + "COMPONENT_CLAUSES_OPT", + "COMPONENT_ITEMS", + "COND_CLAUSE", + "DECIMAL_FIXED_POINT_DECLARATION", + "DECLARE_OPT", + "DERIVED_RECORD_EXTENSION", + "DISCRETE_SUBTYPE_DEF_OPT", + "DISCRIMINANT_SPECIFICATIONS", + "DISCRIM_PART_OPT", + "ELSE_OPT", + "ELSIFS_OPT", + "END_ID_OPT", + "ENTRY_INDEX_OPT", + "ENUMERATION_TYPE_DECLARATION", + "EXCEPT_HANDLER_PART_OPT", + "EXTENSION_OPT", + "FLOATING_POINT_DECLARATION", + "FORMAL_DECIMAL_FIXED_POINT_DECLARATION", + "FORMAL_DISCRETE_TYPE_DECLARATION", + "FORMAL_FLOATING_POINT_DECLARATION", + "FORMAL_FUNCTION_DECLARATION", + "FORMAL_MODULAR_TYPE_DECLARATION", + "FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION", + "FORMAL_ORDINARY_FIXED_POINT_DECLARATION", + "FORMAL_PART_OPT", + "FORMAL_PRIVATE_EXTENSION_DECLARATION", + "FORMAL_PRIVATE_TYPE_DECLARATION", + "FORMAL_PROCEDURE_DECLARATION", + "FORMAL_SIGNED_INTEGER_TYPE_DECLARATION", + "FUNCTION_BODY", + "FUNCTION_BODY_STUB", + "FUNCTION_DECLARATION", + "FUNCTION_RENAMING_DECLARATION", + "GENERIC_FUNCTION_DECLARATION", + "GENERIC_FUNCTION_INSTANTIATION", + "GENERIC_FUNCTION_RENAMING", + "GENERIC_PACKAGE_INSTANTIATION", + "GENERIC_PACKAGE_RENAMING", + "GENERIC_PROCEDURE_DECLARATION", + "GENERIC_PROCEDURE_INSTANTIATION", + "GENERIC_PROCEDURE_RENAMING", + "GUARD_OPT", + "IDENTIFIER_COLON_OPT", + "ID_OPT", + "INIT_OPT", + "ITERATION_SCHEME_OPT", + "LABEL_OPT", + "MARK_WITH_CONSTRAINT", + "MODIFIERS", + "MODULAR_TYPE_DECLARATION", + "MOD_CLAUSE_OPT", + "NOT_IN", + "ORDINARY_DERIVED_TYPE_DECLARATION", + "ORDINARY_FIXED_POINT_DECLARATION", + "OR_ELSE", + "OR_SELECT_OPT", + "PARENTHESIZED_PRIMARY", + "PRIVATE_DECLARATIVE_ITEMS_OPT", + "PRIVATE_TASK_ITEMS_OPT", + "PROCEDURE_BODY", + "PROCEDURE_BODY_STUB", + "PROCEDURE_DECLARATION", + "PROCEDURE_RENAMING_DECLARATION", + "PROT_MEMBER_DECLARATIONS", + "PROT_OP_BODIES_OPT", + "PROT_OP_DECLARATIONS", + "PROT_PRIVATE_OPT", + "RANGED_EXPRS", + "RANGE_CONSTRAINT", + "RECORD_TYPE_DECLARATION", + "SELECTOR_NAMES_OPT", + "SIGNED_INTEGER_TYPE_DECLARATION", + "TASK_ITEMS_OPT", + "UNARY_MINUS", + "UNARY_PLUS", + "VALUE", + "VALUES", + "VARIANTS", + "COMMENT_INTRO", + "OX", + "TIC_OR_CHARACTER_LITERAL", + "DIGIT", + "EXPONENT", + "EXTENDED_DIGIT", + "BASED_INTEGER", + "WS_", + "COMMENT", + "CHARACTER_STRING", + 0 +}; + +const unsigned long AdaStoreWalker::_tokenSet_0_data_[] = { 37920UL, 262201UL, 4293001216UL, 2175UL, 134479872UL, 0UL, 64UL, 1073741824UL, 3145738UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER RIGHT_SHAFT DOT TIC "in" CHARACTER_LITERAL CHAR_STRING "null" +// "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR +// DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT OPERATOR_SYMBOL +// AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS UNARY_PLUS +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_0(_tokenSet_0_data_,20); +const unsigned long AdaStoreWalker::_tokenSet_1_data_[] = { 0UL, 0UL, 0UL, 49152UL, 3338801504UL, 2353094950UL, 151076927UL, 2416967168UL, 328577UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENUMERATION_REPESENTATION_CLAUSE +// EXCEPTION_DECLARATION EXCEPTION_RENAMING_DECLARATION GENERIC_PACKAGE_DECLARATION +// INCOMPLETE_TYPE_DECLARATION NUMBER_DECLARATION OBJECT_DECLARATION OBJECT_RENAMING_DECLARATION +// PACKAGE_RENAMING_DECLARATION PACKAGE_SPECIFICATION PRIVATE_EXTENSION_DECLARATION +// PRIVATE_TYPE_DECLARATION PROTECTED_TYPE_DECLARATION RECORD_REPRESENTATION_CLAUSE +// SINGLE_PROTECTED_DECLARATION SINGLE_TASK_DECLARATION SUBTYPE_DECLARATION +// TASK_TYPE_DECLARATION USE_CLAUSE USE_TYPE_CLAUSE ABSTRACT_FUNCTION_DECLARATION +// ABSTRACT_PROCEDURE_DECLARATION ACCESS_TO_FUNCTION_DECLARATION ACCESS_TO_OBJECT_DECLARATION +// ACCESS_TO_PROCEDURE_DECLARATION ARRAY_OBJECT_DECLARATION ARRAY_TYPE_DECLARATION +// DECIMAL_FIXED_POINT_DECLARATION DERIVED_RECORD_EXTENSION ENUMERATION_TYPE_DECLARATION +// FLOATING_POINT_DECLARATION FUNCTION_BODY_STUB FUNCTION_DECLARATION FUNCTION_RENAMING_DECLARATION +// GENERIC_FUNCTION_DECLARATION GENERIC_FUNCTION_INSTANTIATION GENERIC_FUNCTION_RENAMING +// GENERIC_PACKAGE_INSTANTIATION GENERIC_PACKAGE_RENAMING GENERIC_PROCEDURE_DECLARATION +// GENERIC_PROCEDURE_INSTANTIATION GENERIC_PROCEDURE_RENAMING MODULAR_TYPE_DECLARATION +// ORDINARY_DERIVED_TYPE_DECLARATION ORDINARY_FIXED_POINT_DECLARATION PROCEDURE_BODY_STUB +// PROCEDURE_DECLARATION PROCEDURE_RENAMING_DECLARATION RECORD_TYPE_DECLARATION +// SIGNED_INTEGER_TYPE_DECLARATION +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_1(_tokenSet_1_data_,20); +const unsigned long AdaStoreWalker::_tokenSet_2_data_[] = { 939627552UL, 262201UL, 4293001216UL, 2175UL, 134479872UL, 0UL, 64UL, 1073741824UL, 3145738UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER RIGHT_SHAFT DOT TIC "range" "others" PIPE DOT_DOT "in" CHARACTER_LITERAL +// CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS +// MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT ALLOCATOR INDEXED_COMPONENT +// OPERATOR_SYMBOL AND_THEN NOT_IN OR_ELSE PARENTHESIZED_PRIMARY UNARY_MINUS +// UNARY_PLUS +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_2(_tokenSet_2_data_,20); +const unsigned long AdaStoreWalker::_tokenSet_3_data_[] = { 16UL, 0UL, 0UL, 49152UL, 40UL, 256UL, 0UL, 1024UL, 256UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "pragma" ATTRIBUTE_DEFINITION_CLAUSE AT_CLAUSE ENTRY_DECLARATION ENUMERATION_REPESENTATION_CLAUSE +// RECORD_REPRESENTATION_CLAUSE FUNCTION_DECLARATION PROCEDURE_DECLARATION +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_3(_tokenSet_3_data_,20); +const unsigned long AdaStoreWalker::_tokenSet_4_data_[] = { 36896UL, 0UL, 0UL, 0UL, 262144UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER DOT TIC INDEXED_COMPONENT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaStoreWalker::_tokenSet_4(_tokenSet_4_data_,12); + + -- cgit v1.2.1