diff options
Diffstat (limited to 'languages/ada/AdaParser.cpp')
| -rw-r--r-- | languages/ada/AdaParser.cpp | 12283 |
1 files changed, 12283 insertions, 0 deletions
diff --git a/languages/ada/AdaParser.cpp b/languages/ada/AdaParser.cpp new file mode 100644 index 00000000..e783595e --- /dev/null +++ b/languages/ada/AdaParser.cpp @@ -0,0 +1,12283 @@ +/* $ANTLR 2.7.7 (20070609): "ada.g" -> "AdaParser.cpp"$ */ +#include "AdaParser.hpp" +#include <antlr/NoViableAltException.hpp> +#include <antlr/SemanticException.hpp> +#include <antlr/ASTFactory.hpp> +#line 1 "ada.g" +#line 8 "AdaParser.cpp" +AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k) +{ +} + +AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2) +{ +} + +AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k) +{ +} + +AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2) +{ +} + +AdaParser::AdaParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state) +: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2) +{ +} + +void AdaParser::compilation_unit() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST compilation_unit_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + context_items_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case PRIVATE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case GENERIC: + { + library_item(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEPARATE: + { + subunit(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { // ( ... )* + for (;;) { + if ((LA(1) == PRAGMA)) { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop4; + } + + } + _loop4:; + } // ( ... )* + compilation_unit_AST = RefAdaAST(currentAST.root); + returnAST = compilation_unit_AST; +} + +void AdaParser::context_items_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST context_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case WITH: + { + with_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case USE: + { + use_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop14; + } + } + } + _loop14:; + } // ( ... )* + if ( inputState->guessing==0 ) { + context_items_opt_AST = RefAdaAST(currentAST.root); +#line 86 "ada.g" + context_items_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CONTEXT_CLAUSE,"CONTEXT_CLAUSE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(context_items_opt_AST)))); +#line 135 "AdaParser.cpp" + currentAST.root = context_items_opt_AST; + if ( context_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + context_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = context_items_opt_AST->getFirstChild(); + else + currentAST.child = context_items_opt_AST; + currentAST.advanceChildToEnd(); + } + context_items_opt_AST = RefAdaAST(currentAST.root); + returnAST = context_items_opt_AST; +} + +void AdaParser::library_item() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST library_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + private_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case PACKAGE: + { + lib_pkg_spec_or_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PROCEDURE: + case FUNCTION: + { + subprog_decl_or_rename_or_inst_or_body(true); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case GENERIC: + { + generic_decl(true); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + library_item_AST = RefAdaAST(currentAST.root); +#line 133 "ada.g" + library_item_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(LIBRARY_ITEM,"LIBRARY_ITEM")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(library_item_AST)))); +#line 194 "AdaParser.cpp" + currentAST.root = library_item_AST; + if ( library_item_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + library_item_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = library_item_AST->getFirstChild(); + else + currentAST.child = library_item_AST; + currentAST.advanceChildToEnd(); + } + library_item_AST = RefAdaAST(currentAST.root); + returnAST = library_item_AST; +} + +void AdaParser::subunit() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subunit_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken sep = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST sep_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + sep = LT(1); + if ( inputState->guessing == 0 ) { + sep_AST = astFactory->create(sep); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(sep_AST)); + } + match(SEPARATE); + match(LPAREN); + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 1497 "ada.g" + Set(sep_AST, SUBUNIT); +#line 229 "AdaParser.cpp" + } + { + switch ( LA(1)) { + case PROCEDURE: + case FUNCTION: + { + subprogram_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PACKAGE: + { + package_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case TASK: + { + task_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PROTECTED: + { + protected_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + subunit_AST = RefAdaAST(currentAST.root); + returnAST = subunit_AST; +} + +void AdaParser::pragma() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST pragma_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp3_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp3_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp3_AST)); + } + match(PRAGMA); + RefAdaAST tmp4_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp4_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp4_AST)); + } + match(IDENTIFIER); + pragma_args_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + pragma_AST = RefAdaAST(currentAST.root); + returnAST = pragma_AST; +} + +void AdaParser::pragma_args_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST pragma_args_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + pragma_arg(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + pragma_arg(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop9; + } + + } + _loop9:; + } // ( ... )* + match(RPAREN); + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + pragma_args_opt_AST = RefAdaAST(currentAST.root); + returnAST = pragma_args_opt_AST; +} + +void AdaParser::pragma_arg() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST pragma_arg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT)) { + RefAdaAST tmp9_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp9_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST)); + } + match(IDENTIFIER); + RefAdaAST tmp10_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp10_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp10_AST)); + } + match(RIGHT_SHAFT); + } + else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + pragma_arg_AST = RefAdaAST(currentAST.root); + returnAST = pragma_arg_AST; +} + +void AdaParser::expression() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST expression_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken o = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST o_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + relation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case AND: + { + a = LT(1); + if ( inputState->guessing == 0 ) { + a_AST = astFactory->create(a); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + } + match(AND); + { + switch ( LA(1)) { + case THEN: + { + match(THEN); + if ( inputState->guessing==0 ) { +#line 1417 "ada.g" + Set (a_AST, AND_THEN); +#line 416 "AdaParser.cpp" + } + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + relation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case OR: + { + o = LT(1); + if ( inputState->guessing == 0 ) { + o_AST = astFactory->create(o); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(o_AST)); + } + match(OR); + { + switch ( LA(1)) { + case ELSE: + { + match(ELSE); + if ( inputState->guessing==0 ) { +#line 1418 "ada.g" + Set (o_AST, OR_ELSE); +#line 462 "AdaParser.cpp" + } + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + relation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case XOR: + { + RefAdaAST tmp13_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp13_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp13_AST)); + } + match(XOR); + relation(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop450; + } + } + } + _loop450:; + } // ( ... )* + expression_AST = RefAdaAST(currentAST.root); + returnAST = expression_AST; +} + +void AdaParser::with_clause() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST with_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + w = LT(1); + if ( inputState->guessing == 0 ) { + w_AST = astFactory->create(w); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + } + match(WITH); + c_name_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 94 "ada.g" + Set(w_AST, WITH_CLAUSE); +#line 539 "AdaParser.cpp" + } + with_clause_AST = RefAdaAST(currentAST.root); + returnAST = with_clause_AST; +} + +void AdaParser::use_clause() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST use_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken u = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST u_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + u = LT(1); + if ( inputState->guessing == 0 ) { + u_AST = astFactory->create(u); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(u_AST)); + } + match(USE); + { + switch ( LA(1)) { + case TYPE: + { + match(TYPE); + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop25; + } + + } + _loop25:; + } // ( ... )* + if ( inputState->guessing==0 ) { +#line 108 "ada.g" + Set(u_AST, USE_TYPE_CLAUSE); +#line 586 "AdaParser.cpp" + } + break; + } + case IDENTIFIER: + { + c_name_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 109 "ada.g" + Set(u_AST, USE_CLAUSE); +#line 599 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + use_clause_AST = RefAdaAST(currentAST.root); + returnAST = use_clause_AST; +} + +void AdaParser::c_name_list() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST c_name_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop18; + } + + } + _loop18:; + } // ( ... )* + c_name_list_AST = RefAdaAST(currentAST.root); + returnAST = c_name_list_AST; +} + +void AdaParser::compound_name() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST compound_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp19_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp19_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST)); + } + match(IDENTIFIER); + { // ( ... )* + for (;;) { + if ((LA(1) == DOT)) { + RefAdaAST tmp20_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp20_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST)); + } + match(DOT); + RefAdaAST tmp21_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp21_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp21_AST)); + } + match(IDENTIFIER); + } + else { + goto _loop21; + } + + } + _loop21:; + } // ( ... )* + compound_name_AST = RefAdaAST(currentAST.root); + returnAST = compound_name_AST; +} + +void AdaParser::subtype_mark() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subtype_mark_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case TIC: + { + RefAdaAST tmp22_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp22_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST)); + } + match(TIC); + attribute_id(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case LPAREN: + case COMMA: + case RPAREN: + case RIGHT_SHAFT: + case WITH: + case USE: + case RANGE: + case DIGITS: + case DELTA: + case IS: + case PIPE: + case DOT_DOT: + case RENAMES: + case ASSIGN: + case AT: + case THEN: + case LOOP: + case OR: + case AND: + case XOR: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + subtype_mark_AST = RefAdaAST(currentAST.root); + returnAST = subtype_mark_AST; +} + +void AdaParser::attribute_id() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST attribute_id_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case RANGE: + { + RefAdaAST tmp23_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp23_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST)); + } + match(RANGE); + attribute_id_AST = RefAdaAST(currentAST.root); + break; + } + case DIGITS: + { + RefAdaAST tmp24_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp24_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST)); + } + match(DIGITS); + attribute_id_AST = RefAdaAST(currentAST.root); + break; + } + case DELTA: + { + RefAdaAST tmp25_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp25_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp25_AST)); + } + match(DELTA); + attribute_id_AST = RefAdaAST(currentAST.root); + break; + } + case ACCESS: + { + RefAdaAST tmp26_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp26_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST)); + } + match(ACCESS); + attribute_id_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp27_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp27_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp27_AST)); + } + match(IDENTIFIER); + attribute_id_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = attribute_id_AST; +} + +void AdaParser::private_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST private_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PRIVATE: + { + RefAdaAST tmp28_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp28_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST)); + } + match(PRIVATE); + break; + } + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case GENERIC: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + private_opt_AST = RefAdaAST(currentAST.root); +#line 137 "ada.g" + private_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_opt_AST)))); +#line 843 "AdaParser.cpp" + currentAST.root = private_opt_AST; + if ( private_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + private_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = private_opt_AST->getFirstChild(); + else + currentAST.child = private_opt_AST; + currentAST.advanceChildToEnd(); + } + private_opt_AST = RefAdaAST(currentAST.root); + returnAST = private_opt_AST; +} + +void AdaParser::lib_pkg_spec_or_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST lib_pkg_spec_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + pkg = LT(1); + if ( inputState->guessing == 0 ) { + pkg_AST = astFactory->create(pkg); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST)); + } + match(PACKAGE); + { + switch ( LA(1)) { + case BODY: + { + match(BODY); + def_id(true); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + pkg_body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 143 "ada.g" + Set(pkg_AST, PACKAGE_BODY); +#line 887 "AdaParser.cpp" + } + break; + } + case IDENTIFIER: + { + def_id(true); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + spec_decl_part(pkg_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + lib_pkg_spec_or_body_AST = RefAdaAST(currentAST.root); + returnAST = lib_pkg_spec_or_body_AST; +} + +void AdaParser::subprog_decl_or_rename_or_inst_or_body( + boolean lib_level +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 944 "ada.g" + RefAdaAST t; +#line 925 "AdaParser.cpp" + + switch ( LA(1)) { + case PROCEDURE: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PROCEDURE); + def_id(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == IS) && (LA(2) == NEW)) { + generic_subp_inst(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 948 "ada.g" + Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION); +#line 949 "AdaParser.cpp" + } + } + else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_3.member(LA(2)))) { + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 950 "ada.g" + Set(p_AST, PROCEDURE_RENAMING_DECLARATION); +#line 968 "AdaParser.cpp" + } + break; + } + case IS: + { + match(IS); + { + switch ( LA(1)) { + case SEPARATE: + case ABSTRACT: + { + separate_or_abstract(p_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + case BEGIN: + { + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 952 "ada.g" + Set(p_AST, PROCEDURE_BODY); +#line 1007 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 954 "ada.g" + pop_def_id(); + Set(p_AST, PROCEDURE_DECLARATION); +#line 1025 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(currentAST.root); + break; + } + case FUNCTION: + { + f = LT(1); + if ( inputState->guessing == 0 ) { + f_AST = astFactory->create(f); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + } + match(FUNCTION); + def_designator(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IS: + { + generic_subp_inst(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 961 "ada.g" + Set(f_AST, GENERIC_FUNCTION_INSTANTIATION); +#line 1068 "AdaParser.cpp" + } + break; + } + case LPAREN: + case RETURN: + { + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 963 "ada.g" + Set(f_AST, FUNCTION_RENAMING_DECLARATION); +#line 1090 "AdaParser.cpp" + } + break; + } + case IS: + { + match(IS); + { + switch ( LA(1)) { + case SEPARATE: + case ABSTRACT: + { + separate_or_abstract(f_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + case BEGIN: + { + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 965 "ada.g" + Set(f_AST, FUNCTION_BODY); +#line 1129 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 967 "ada.g" + pop_def_id(); + Set(f_AST, FUNCTION_DECLARATION); +#line 1147 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + subprog_decl_or_rename_or_inst_or_body_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = subprog_decl_or_rename_or_inst_or_body_AST; +} + +void AdaParser::generic_decl( + boolean lib_level +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST generic_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken g = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST g_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + g = LT(1); + if ( inputState->guessing == 0 ) { + g_AST = astFactory->create(g); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(g_AST)); + } + match(GENERIC); + generic_formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case PACKAGE: + { + match(PACKAGE); + def_id(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 865 "ada.g" + Set(g_AST, GENERIC_PACKAGE_RENAMING); +#line 1216 "AdaParser.cpp" + } + break; + } + case IS: + { + match(IS); + pkg_spec_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 866 "ada.g" + Set(g_AST, GENERIC_PACKAGE_DECLARATION); +#line 1230 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case PROCEDURE: + { + match(PROCEDURE); + def_id(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 869 "ada.g" + Set(g_AST, GENERIC_PROCEDURE_RENAMING); +#line 1264 "AdaParser.cpp" + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 872 "ada.g" + Set(g_AST, GENERIC_PROCEDURE_DECLARATION); pop_def_id(); +#line 1273 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case FUNCTION: + { + match(FUNCTION); + def_designator(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 875 "ada.g" + Set(g_AST, GENERIC_FUNCTION_RENAMING); +#line 1307 "AdaParser.cpp" + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 878 "ada.g" + Set(g_AST, GENERIC_FUNCTION_DECLARATION); pop_def_id(); +#line 1316 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + generic_decl_AST = RefAdaAST(currentAST.root); + returnAST = generic_decl_AST; +} + +void AdaParser::def_id( + boolean lib_level +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST def_id_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefAdaAST cn_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (((LA(1) == IDENTIFIER) && (_tokenSet_4.member(LA(2))))&&( lib_level )) { + compound_name(); + if (inputState->guessing==0) { + cn_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 171 "ada.g" + push_def_id(cn_AST); +#line 1358 "AdaParser.cpp" + } + def_id_AST = RefAdaAST(currentAST.root); + } + else if (((LA(1) == IDENTIFIER) && (_tokenSet_5.member(LA(2))))&&( !lib_level )) { + n = LT(1); + if ( inputState->guessing == 0 ) { + n_AST = astFactory->create(n); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST)); + } + match(IDENTIFIER); + if ( inputState->guessing==0 ) { +#line 172 "ada.g" + push_def_id(n_AST); +#line 1372 "AdaParser.cpp" + } + def_id_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = def_id_AST; +} + +void AdaParser::pkg_body_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST pkg_body_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + declarative_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + block_body_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + pkg_body_part_AST = RefAdaAST(currentAST.root); + returnAST = pkg_body_part_AST; +} + +void AdaParser::spec_decl_part( + RefAdaAST pkg +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST spec_decl_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IS: + { + match(IS); + { + switch ( LA(1)) { + case NEW: + { + generic_inst(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 364 "ada.g" + Set(pkg, GENERIC_PACKAGE_INSTANTIATION); +#line 1427 "AdaParser.cpp" + } + break; + } + case PRAGMA: + case IDENTIFIER: + case USE: + case TYPE: + case PRIVATE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case END: + case SUBTYPE: + case GENERIC: + { + pkg_spec_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 365 "ada.g" + Set(pkg, PACKAGE_SPECIFICATION); +#line 1453 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 367 "ada.g" + Set(pkg, PACKAGE_RENAMING_DECLARATION); +#line 1474 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + spec_decl_part_AST = RefAdaAST(currentAST.root); + returnAST = spec_decl_part_AST; +} + +void AdaParser::subprog_decl( + boolean lib_level +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subprog_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 148 "ada.g" + RefAdaAST t; +#line 1501 "AdaParser.cpp" + + switch ( LA(1)) { + case PROCEDURE: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PROCEDURE); + def_id(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + if ((LA(1) == IS) && (LA(2) == NEW)) { + generic_subp_inst(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 152 "ada.g" + Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION); +#line 1525 "AdaParser.cpp" + } + } + else if ((_tokenSet_2.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 154 "ada.g" + Set(p_AST, PROCEDURE_RENAMING_DECLARATION); +#line 1544 "AdaParser.cpp" + } + break; + } + case SEMI: + case IS: + { + is_separate_or_abstract_or_decl(p_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + subprog_decl_AST = RefAdaAST(currentAST.root); + break; + } + case FUNCTION: + { + f = LT(1); + if ( inputState->guessing == 0 ) { + f_AST = astFactory->create(f); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + } + match(FUNCTION); + def_designator(lib_level); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IS: + { + generic_subp_inst(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 161 "ada.g" + Set(f_AST, GENERIC_FUNCTION_INSTANTIATION); +#line 1596 "AdaParser.cpp" + } + break; + } + case LPAREN: + case RETURN: + { + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RENAMES: + { + renames(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 163 "ada.g" + Set(f_AST, FUNCTION_RENAMING_DECLARATION); +#line 1618 "AdaParser.cpp" + } + break; + } + case SEMI: + case IS: + { + is_separate_or_abstract_or_decl(f_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + subprog_decl_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = subprog_decl_AST; +} + +void AdaParser::generic_subp_inst() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST generic_subp_inst_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(IS); + generic_inst(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + generic_subp_inst_AST = RefAdaAST(currentAST.root); + returnAST = generic_subp_inst_AST; +} + +void AdaParser::formal_part_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + parameter_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == SEMI)) { + match(SEMI); + parameter_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop70; + } + + } + _loop70:; + } // ( ... )* + match(RPAREN); + break; + } + case SEMI: + case IS: + case RENAMES: + case WHEN: + case DO: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + formal_part_opt_AST = RefAdaAST(currentAST.root); +#line 235 "ada.g" + formal_part_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(formal_part_opt_AST)))); +#line 1723 "AdaParser.cpp" + currentAST.root = formal_part_opt_AST; + if ( formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = formal_part_opt_AST->getFirstChild(); + else + currentAST.child = formal_part_opt_AST; + currentAST.advanceChildToEnd(); + } + formal_part_opt_AST = RefAdaAST(currentAST.root); + returnAST = formal_part_opt_AST; +} + +void AdaParser::renames() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST renames_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 258 "ada.g" + RefAdaAST dummy; +#line 1742 "AdaParser.cpp" + + match(RENAMES); + { + switch ( LA(1)) { + case IDENTIFIER: + { + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case CHAR_STRING: + { + dummy=definable_operator_symbol(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 262 "ada.g" + pop_def_id(); +#line 1772 "AdaParser.cpp" + } + renames_AST = RefAdaAST(currentAST.root); + returnAST = renames_AST; +} + +void AdaParser::is_separate_or_abstract_or_decl( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST is_separate_or_abstract_or_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case IS: + { + match(IS); + separate_or_abstract(t); + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 305 "ada.g" + pop_def_id(); + if (t->getType() == AdaTokenTypes::PROCEDURE) + Set(t, PROCEDURE_DECLARATION); + else + Set(t, FUNCTION_DECLARATION); + +#line 1802 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = is_separate_or_abstract_or_decl_AST; +} + +void AdaParser::def_designator( + boolean lib_level +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST def_designator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 330 "ada.g" + RefAdaAST d; +#line 1823 "AdaParser.cpp" + + if (((LA(1) == IDENTIFIER) && (_tokenSet_7.member(LA(2))))&&( lib_level )) { + compound_name(); + if (inputState->guessing==0) { + n_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 332 "ada.g" + push_def_id(n_AST); +#line 1834 "AdaParser.cpp" + } + def_designator_AST = RefAdaAST(currentAST.root); + } + else if (((LA(1) == IDENTIFIER || LA(1) == CHAR_STRING) && (LA(2) == LPAREN || LA(2) == IS || LA(2) == RETURN))&&( !lib_level )) { + d=designator(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 333 "ada.g" + push_def_id(d); +#line 1846 "AdaParser.cpp" + } + def_designator_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = def_designator_AST; +} + +void AdaParser::function_tail() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST function_tail_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + func_formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RETURN); + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_tail_AST = RefAdaAST(currentAST.root); + returnAST = function_tail_AST; +} + +void AdaParser::generic_inst() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST generic_inst_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(NEW); + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 179 "ada.g" + pop_def_id(); +#line 1910 "AdaParser.cpp" + } + generic_inst_AST = RefAdaAST(currentAST.root); + returnAST = generic_inst_AST; +} + +void AdaParser::value_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST value_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + value(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + value(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop445; + } + + } + _loop445:; + } // ( ... )* + if ( inputState->guessing==0 ) { + value_s_AST = RefAdaAST(currentAST.root); +#line 1405 "ada.g" + value_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VALUES,"VALUES")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(value_s_AST)))); +#line 1945 "AdaParser.cpp" + currentAST.root = value_s_AST; + if ( value_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + value_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = value_s_AST->getFirstChild(); + else + currentAST.child = value_s_AST; + currentAST.advanceChildToEnd(); + } + value_s_AST = RefAdaAST(currentAST.root); + returnAST = value_s_AST; +} + +void AdaParser::parenth_values() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST parenth_values_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAREN); + value(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + value(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop46; + } + + } + _loop46:; + } // ( ... )* + match(RPAREN); + parenth_values_AST = RefAdaAST(currentAST.root); + returnAST = parenth_values_AST; +} + +void AdaParser::value() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST value_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case OTHERS: + { + RefAdaAST tmp60_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp60_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp60_AST)); + } + match(OTHERS); + match(RIGHT_SHAFT); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + ranged_expr_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RIGHT_SHAFT: + { + RefAdaAST tmp62_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp62_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp62_AST)); + } + match(RIGHT_SHAFT); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case COMMA: + case RPAREN: + case WITH: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + value_AST = RefAdaAST(currentAST.root); + returnAST = value_AST; +} + +void AdaParser::ranged_expr_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST ranged_expr_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + ranged_expr(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == PIPE)) { + RefAdaAST tmp63_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp63_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp63_AST)); + } + match(PIPE); + ranged_expr(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop52; + } + + } + _loop52:; + } // ( ... )* + ranged_expr_s_AST = RefAdaAST(currentAST.root); + returnAST = ranged_expr_s_AST; +} + +void AdaParser::ranged_expr() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST ranged_expr_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case DOT_DOT: + { + RefAdaAST tmp64_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp64_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp64_AST)); + } + match(DOT_DOT); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case RANGE: + { + RefAdaAST tmp65_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp65_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp65_AST)); + } + match(RANGE); + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case COMMA: + case RPAREN: + case RIGHT_SHAFT: + case WITH: + case PIPE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + ranged_expr_AST = RefAdaAST(currentAST.root); + returnAST = ranged_expr_AST; +} + +void AdaParser::simple_expression() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST simple_expression_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + signed_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PLUS: + { + RefAdaAST tmp66_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp66_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp66_AST)); + } + match(PLUS); + signed_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case MINUS: + { + RefAdaAST tmp67_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp67_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp67_AST)); + } + match(MINUS); + signed_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case CONCAT: + { + RefAdaAST tmp68_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp68_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp68_AST)); + } + match(CONCAT); + signed_term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop458; + } + } + } + _loop458:; + } // ( ... )* + simple_expression_AST = RefAdaAST(currentAST.root); + returnAST = simple_expression_AST; +} + +void AdaParser::range() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + bool synPredMatched59 = false; + if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) { + int _m59 = mark(); + synPredMatched59 = true; + inputState->guessing++; + try { + { + range_dots(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched59 = false; + } + rewind(_m59); + inputState->guessing--; + } + if ( synPredMatched59 ) { + range_dots(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == IDENTIFIER) && (LA(2) == LPAREN || LA(2) == DOT || LA(2) == TIC)) { + range_attrib_ref(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + range_AST = RefAdaAST(currentAST.root); + returnAST = range_AST; +} + +void AdaParser::range_constraint() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST range_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + r = LT(1); + if ( inputState->guessing == 0 ) { + r_AST = astFactory->create(r); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + } + match(RANGE); + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 203 "ada.g" + Set(r_AST, RANGE_CONSTRAINT); +#line 2287 "AdaParser.cpp" + } + range_constraint_AST = RefAdaAST(currentAST.root); + returnAST = range_constraint_AST; +} + +void AdaParser::range_dots() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST range_dots_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + RefAdaAST tmp69_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp69_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp69_AST)); + } + match(DOT_DOT); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_dots_AST = RefAdaAST(currentAST.root); + returnAST = range_dots_AST; +} + +void AdaParser::range_attrib_ref() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST range_attrib_ref_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + prefix(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(TIC); + r = LT(1); + if ( inputState->guessing == 0 ) { + r_AST = astFactory->create(r); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + } + match(RANGE); + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + break; + } + case SEMI: + case COMMA: + case RPAREN: + case RIGHT_SHAFT: + case WITH: + case RANGE: + case DIGITS: + case IS: + case PIPE: + case DOT_DOT: + case ASSIGN: + case THEN: + case LOOP: + case OR: + case AND: + case XOR: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 219 "ada.g" + Set(r_AST, RANGE_ATTRIBUTE_REFERENCE); +#line 2374 "AdaParser.cpp" + } + range_attrib_ref_AST = RefAdaAST(currentAST.root); + returnAST = range_attrib_ref_AST; +} + +void AdaParser::prefix() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prefix_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp73_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp73_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST)); + } + match(IDENTIFIER); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case DOT: + { + RefAdaAST tmp74_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp74_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp74_AST)); + } + match(DOT); + { + switch ( LA(1)) { + case ALL: + { + RefAdaAST tmp75_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp75_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp75_AST)); + } + match(ALL); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp76_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp76_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp76_AST)); + } + match(IDENTIFIER); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case LPAREN: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(LPAREN); + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 228 "ada.g" + Set(p_AST, INDEXED_COMPONENT); +#line 2450 "AdaParser.cpp" + } + break; + } + default: + { + goto _loop66; + } + } + } + _loop66:; + } // ( ... )* + prefix_AST = RefAdaAST(currentAST.root); + returnAST = prefix_AST; +} + +void AdaParser::parameter_specification() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST parameter_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + def_ids_colon(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + mode_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + init_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + parameter_specification_AST = RefAdaAST(currentAST.root); +#line 240 "ada.g" + parameter_specification_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(parameter_specification_AST)))); +#line 2492 "AdaParser.cpp" + currentAST.root = parameter_specification_AST; + if ( parameter_specification_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + parameter_specification_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = parameter_specification_AST->getFirstChild(); + else + currentAST.child = parameter_specification_AST; + currentAST.advanceChildToEnd(); + } + parameter_specification_AST = RefAdaAST(currentAST.root); + returnAST = parameter_specification_AST; +} + +void AdaParser::def_ids_colon() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST def_ids_colon_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + defining_identifier_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(COLON); + def_ids_colon_AST = RefAdaAST(currentAST.root); + returnAST = def_ids_colon_AST; +} + +void AdaParser::mode_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST mode_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IN: + { + RefAdaAST tmp79_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp79_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp79_AST)); + } + match(IN); + { + switch ( LA(1)) { + case OUT: + { + RefAdaAST tmp80_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp80_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp80_AST)); + } + match(OUT); + break; + } + case IDENTIFIER: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case OUT: + { + RefAdaAST tmp81_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp81_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp81_AST)); + } + match(OUT); + break; + } + case ACCESS: + { + RefAdaAST tmp82_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp82_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp82_AST)); + } + match(ACCESS); + break; + } + case IDENTIFIER: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + mode_opt_AST = RefAdaAST(currentAST.root); +#line 255 "ada.g" + mode_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mode_opt_AST)))); +#line 2592 "AdaParser.cpp" + currentAST.root = mode_opt_AST; + if ( mode_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + mode_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = mode_opt_AST->getFirstChild(); + else + currentAST.child = mode_opt_AST; + currentAST.advanceChildToEnd(); + } + mode_opt_AST = RefAdaAST(currentAST.root); + returnAST = mode_opt_AST; +} + +void AdaParser::init_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST init_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ASSIGN: + { + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case RPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + init_opt_AST = RefAdaAST(currentAST.root); +#line 468 "ada.g" + init_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(INIT_OPT,"INIT_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(init_opt_AST)))); +#line 2636 "AdaParser.cpp" + currentAST.root = init_opt_AST; + if ( init_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + init_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = init_opt_AST->getFirstChild(); + else + currentAST.child = init_opt_AST; + currentAST.advanceChildToEnd(); + } + init_opt_AST = RefAdaAST(currentAST.root); + returnAST = init_opt_AST; +} + +void AdaParser::defining_identifier_list() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST defining_identifier_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp84_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp84_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp84_AST)); + } + match(IDENTIFIER); + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + RefAdaAST tmp86_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp86_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp86_AST)); + } + match(IDENTIFIER); + } + else { + goto _loop75; + } + + } + _loop75:; + } // ( ... )* + if ( inputState->guessing==0 ) { + defining_identifier_list_AST = RefAdaAST(currentAST.root); +#line 249 "ada.g" + defining_identifier_list_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DEFINING_IDENTIFIER_LIST,"DEFINING_IDENTIFIER_LIST")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(defining_identifier_list_AST)))); +#line 2683 "AdaParser.cpp" + currentAST.root = defining_identifier_list_AST; + if ( defining_identifier_list_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + defining_identifier_list_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = defining_identifier_list_AST->getFirstChild(); + else + currentAST.child = defining_identifier_list_AST; + currentAST.advanceChildToEnd(); + } + defining_identifier_list_AST = RefAdaAST(currentAST.root); + returnAST = defining_identifier_list_AST; +} + +void AdaParser::name() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 265 "ada.g" + RefAdaAST dummy; +#line 2704 "AdaParser.cpp" + + RefAdaAST tmp87_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp87_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp87_AST)); + } + match(IDENTIFIER); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case DOT: + { + RefAdaAST tmp88_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp88_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp88_AST)); + } + match(DOT); + { + switch ( LA(1)) { + case ALL: + { + RefAdaAST tmp89_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp89_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp89_AST)); + } + match(ALL); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp90_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp90_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp90_AST)); + } + match(IDENTIFIER); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp91_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp91_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp91_AST)); + } + match(CHARACTER_LITERAL); + break; + } + case CHAR_STRING: + { + dummy=is_operator(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case LPAREN: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(LPAREN); + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 273 "ada.g" + Set(p_AST, INDEXED_COMPONENT); +#line 2787 "AdaParser.cpp" + } + break; + } + case TIC: + { + RefAdaAST tmp93_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp93_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp93_AST)); + } + match(TIC); + attribute_id(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop84; + } + } + } + _loop84:; + } // ( ... )* + name_AST = RefAdaAST(currentAST.root); + returnAST = name_AST; +} + +RefAdaAST AdaParser::definable_operator_symbol() { +#line 285 "ada.g" + RefAdaAST d; +#line 2820 "AdaParser.cpp" + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST definable_operator_symbol_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken op = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST op_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( definable_operator(LT(1)->getText().c_str()) )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" definable_operator(LT(1)->getText().c_str()) "); + op = LT(1); + if ( inputState->guessing == 0 ) { + op_AST = astFactory->create(op); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(op_AST)); + } + match(CHAR_STRING); + if ( inputState->guessing==0 ) { +#line 287 "ada.g" + op_AST->setType(OPERATOR_SYMBOL); d=op_AST; +#line 2838 "AdaParser.cpp" + } + definable_operator_symbol_AST = RefAdaAST(currentAST.root); + returnAST = definable_operator_symbol_AST; + return d; +} + +RefAdaAST AdaParser::is_operator() { +#line 280 "ada.g" + RefAdaAST d; +#line 2848 "AdaParser.cpp" + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST is_operator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken op = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST op_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if (!( is_operator_symbol(LT(1)->getText().c_str()) )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(LT(1)->getText().c_str()) "); + op = LT(1); + if ( inputState->guessing == 0 ) { + op_AST = astFactory->create(op); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(op_AST)); + } + match(CHAR_STRING); + if ( inputState->guessing==0 ) { +#line 282 "ada.g" + op_AST->setType(OPERATOR_SYMBOL); d=op_AST; +#line 2866 "AdaParser.cpp" + } + is_operator_AST = RefAdaAST(currentAST.root); + returnAST = is_operator_AST; + return d; +} + +void AdaParser::parenthesized_primary() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST parenthesized_primary_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken pp = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST pp_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + pp = LT(1); + if ( inputState->guessing == 0 ) { + pp_AST = astFactory->create(pp); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pp_AST)); + } + match(LPAREN); + { + if ((LA(1) == NuLL) && (LA(2) == RECORD)) { + RefAdaAST tmp94_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp94_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp94_AST)); + } + match(NuLL); + match(RECORD); + } + else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_10.member(LA(2)))) { + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + extension_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 295 "ada.g" + Set(pp_AST, PARENTHESIZED_PRIMARY); +#line 2915 "AdaParser.cpp" + } + parenthesized_primary_AST = RefAdaAST(currentAST.root); + returnAST = parenthesized_primary_AST; +} + +void AdaParser::extension_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST extension_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case WITH: + { + match(WITH); + { + if ((LA(1) == NuLL) && (LA(2) == RECORD)) { + RefAdaAST tmp98_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp98_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp98_AST)); + } + match(NuLL); + match(RECORD); + } + else if ((_tokenSet_9.member(LA(1))) && (_tokenSet_11.member(LA(2)))) { + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + break; + } + case RPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + extension_opt_AST = RefAdaAST(currentAST.root); +#line 299 "ada.g" + extension_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXTENSION_OPT,"EXTENSION_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(extension_opt_AST)))); +#line 2969 "AdaParser.cpp" + currentAST.root = extension_opt_AST; + if ( extension_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + extension_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = extension_opt_AST->getFirstChild(); + else + currentAST.child = extension_opt_AST; + currentAST.advanceChildToEnd(); + } + extension_opt_AST = RefAdaAST(currentAST.root); + returnAST = extension_opt_AST; +} + +void AdaParser::separate_or_abstract( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST separate_or_abstract_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case SEPARATE: + { + match(SEPARATE); + if ( inputState->guessing==0 ) { +#line 315 "ada.g" + pop_def_id(); + if (t->getType() == AdaTokenTypes::PROCEDURE) + Set(t, PROCEDURE_BODY_STUB); + else + Set(t, FUNCTION_BODY_STUB); + +#line 3001 "AdaParser.cpp" + } + break; + } + case ABSTRACT: + { + match(ABSTRACT); + if ( inputState->guessing==0 ) { +#line 322 "ada.g" + pop_def_id(); + if (t->getType() == AdaTokenTypes::PROCEDURE) + Set(t, ABSTRACT_PROCEDURE_DECLARATION); + else + Set(t, ABSTRACT_FUNCTION_DECLARATION); + +#line 3016 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = separate_or_abstract_AST; +} + +RefAdaAST AdaParser::designator() { +#line 336 "ada.g" + RefAdaAST d; +#line 3031 "AdaParser.cpp" + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST designator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 336 "ada.g" + RefAdaAST op; +#line 3039 "AdaParser.cpp" + + switch ( LA(1)) { + case CHAR_STRING: + { + op=definable_operator_symbol(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 338 "ada.g" + d = op; +#line 3051 "AdaParser.cpp" + } + designator_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + { + n = LT(1); + if ( inputState->guessing == 0 ) { + n_AST = astFactory->create(n); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST)); + } + match(IDENTIFIER); + if ( inputState->guessing==0 ) { +#line 339 "ada.g" + d = n_AST; +#line 3067 "AdaParser.cpp" + } + designator_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = designator_AST; + return d; +} + +void AdaParser::func_formal_part_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST func_formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + func_param(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == SEMI)) { + match(SEMI); + func_param(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop100; + } + + } + _loop100:; + } // ( ... )* + match(RPAREN); + break; + } + case RETURN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + func_formal_part_opt_AST = RefAdaAST(currentAST.root); +#line 348 "ada.g" + func_formal_part_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(func_formal_part_opt_AST)))); +#line 3129 "AdaParser.cpp" + currentAST.root = func_formal_part_opt_AST; + if ( func_formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + func_formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = func_formal_part_opt_AST->getFirstChild(); + else + currentAST.child = func_formal_part_opt_AST; + currentAST.advanceChildToEnd(); + } + func_formal_part_opt_AST = RefAdaAST(currentAST.root); + returnAST = func_formal_part_opt_AST; +} + +void AdaParser::func_param() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST func_param_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + def_ids_colon(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + in_access_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + init_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + func_param_AST = RefAdaAST(currentAST.root); +#line 354 "ada.g" + func_param_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(func_param_AST)))); +#line 3168 "AdaParser.cpp" + currentAST.root = func_param_AST; + if ( func_param_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + func_param_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = func_param_AST->getFirstChild(); + else + currentAST.child = func_param_AST; + currentAST.advanceChildToEnd(); + } + func_param_AST = RefAdaAST(currentAST.root); + returnAST = func_param_AST; +} + +void AdaParser::in_access_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST in_access_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IN: + { + RefAdaAST tmp105_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp105_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp105_AST)); + } + match(IN); + break; + } + case ACCESS: + { + RefAdaAST tmp106_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp106_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp106_AST)); + } + match(ACCESS); + break; + } + case IDENTIFIER: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + in_access_opt_AST = RefAdaAST(currentAST.root); +#line 360 "ada.g" + in_access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(in_access_opt_AST)))); +#line 3222 "AdaParser.cpp" + currentAST.root = in_access_opt_AST; + if ( in_access_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + in_access_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = in_access_opt_AST->getFirstChild(); + else + currentAST.child = in_access_opt_AST; + currentAST.advanceChildToEnd(); + } + in_access_opt_AST = RefAdaAST(currentAST.root); + returnAST = in_access_opt_AST; +} + +void AdaParser::pkg_spec_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST pkg_spec_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + basic_declarative_items_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + private_declarative_items_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + pkg_spec_part_AST = RefAdaAST(currentAST.root); + returnAST = pkg_spec_part_AST; +} + +void AdaParser::basic_declarative_items_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST basic_declarative_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + { + basic_decl_item(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop114; + } + } + } + _loop114:; + } // ( ... )* + if ( inputState->guessing==0 ) { + basic_declarative_items_opt_AST = RefAdaAST(currentAST.root); +#line 385 "ada.g" + basic_declarative_items_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(basic_declarative_items_opt_AST)))); +#line 3303 "AdaParser.cpp" + currentAST.root = basic_declarative_items_opt_AST; + if ( basic_declarative_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + basic_declarative_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = basic_declarative_items_opt_AST->getFirstChild(); + else + currentAST.child = basic_declarative_items_opt_AST; + currentAST.advanceChildToEnd(); + } + basic_declarative_items_opt_AST = RefAdaAST(currentAST.root); + returnAST = basic_declarative_items_opt_AST; +} + +void AdaParser::private_declarative_items_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST private_declarative_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PRIVATE: + { + match(PRIVATE); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + { + basic_decl_item(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop111; + } + } + } + _loop111:; + } // ( ... )* + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + private_declarative_items_opt_AST = RefAdaAST(currentAST.root); +#line 378 "ada.g" + private_declarative_items_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PRIVATE_DECLARATIVE_ITEMS_OPT,"PRIVATE_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_declarative_items_opt_AST)))); +#line 3380 "AdaParser.cpp" + currentAST.root = private_declarative_items_opt_AST; + if ( private_declarative_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + private_declarative_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = private_declarative_items_opt_AST->getFirstChild(); + else + currentAST.child = private_declarative_items_opt_AST; + currentAST.advanceChildToEnd(); + } + private_declarative_items_opt_AST = RefAdaAST(currentAST.root); + returnAST = private_declarative_items_opt_AST; +} + +void AdaParser::end_id_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST end_id_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + e = LT(1); + if ( inputState->guessing == 0 ) { + e_AST = astFactory->create(e); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + } + match(END); + id_opt_aux(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1176 "ada.g" + Set(e_AST, END_ID_OPT); +#line 3413 "AdaParser.cpp" + } + end_id_opt_AST = RefAdaAST(currentAST.root); + returnAST = end_id_opt_AST; +} + +void AdaParser::basic_decl_item() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST basic_decl_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken tsk = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST tsk_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken pro = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST pro_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case PACKAGE: + { + pkg = LT(1); + if ( inputState->guessing == 0 ) { + pkg_AST = astFactory->create(pkg); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST)); + } + match(PACKAGE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + spec_decl_part(pkg_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + basic_decl_item_AST = RefAdaAST(currentAST.root); + break; + } + case TASK: + { + tsk = LT(1); + if ( inputState->guessing == 0 ) { + tsk_AST = astFactory->create(tsk); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tsk_AST)); + } + match(TASK); + task_type_or_single_decl(tsk_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + basic_decl_item_AST = RefAdaAST(currentAST.root); + break; + } + case PROTECTED: + { + pro = LT(1); + if ( inputState->guessing == 0 ) { + pro_AST = astFactory->create(pro); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pro_AST)); + } + match(PROTECTED); + prot_type_or_single_decl(pro_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + basic_decl_item_AST = RefAdaAST(currentAST.root); + break; + } + case PROCEDURE: + case FUNCTION: + { + subprog_decl(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + basic_decl_item_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + case USE: + case TYPE: + case FOR: + case SUBTYPE: + case GENERIC: + { + decl_common(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + basic_decl_item_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = basic_decl_item_AST; +} + +void AdaParser::basic_declarative_items() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST basic_declarative_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )+ + int _cnt117=0; + for (;;) { + switch ( LA(1)) { + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + { + basic_decl_item(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + if ( _cnt117>=1 ) { goto _loop117; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + } + _cnt117++; + } + _loop117:; + } // ( ... )+ + if ( inputState->guessing==0 ) { + basic_declarative_items_AST = RefAdaAST(currentAST.root); +#line 392 "ada.g" + basic_declarative_items_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(basic_declarative_items_AST)))); +#line 3562 "AdaParser.cpp" + currentAST.root = basic_declarative_items_AST; + if ( basic_declarative_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + basic_declarative_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = basic_declarative_items_AST->getFirstChild(); + else + currentAST.child = basic_declarative_items_AST; + currentAST.advanceChildToEnd(); + } + basic_declarative_items_AST = RefAdaAST(currentAST.root); + returnAST = basic_declarative_items_AST; +} + +void AdaParser::task_type_or_single_decl( + RefAdaAST tsk +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST task_type_or_single_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case TYPE: + { + match(TYPE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrim_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + task_definition_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 408 "ada.g" + Set(tsk, TASK_TYPE_DECLARATION); +#line 3601 "AdaParser.cpp" + } + task_type_or_single_decl_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + { + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + task_definition_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 410 "ada.g" + Set(tsk, SINGLE_TASK_DECLARATION); +#line 3619 "AdaParser.cpp" + } + task_type_or_single_decl_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = task_type_or_single_decl_AST; +} + +void AdaParser::prot_type_or_single_decl( + RefAdaAST pro +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prot_type_or_single_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case TYPE: + { + match(TYPE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrim_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + protected_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 539 "ada.g" + Set(pro, PROTECTED_TYPE_DECLARATION); +#line 3658 "AdaParser.cpp" + } + prot_type_or_single_decl_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + { + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + protected_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 541 "ada.g" + Set(pro, SINGLE_PROTECTED_DECLARATION); +#line 3676 "AdaParser.cpp" + } + prot_type_or_single_decl_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = prot_type_or_single_decl_AST; +} + +void AdaParser::decl_common() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST decl_common_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken erd = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST erd_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken ord = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST ord_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken od = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST od_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case TYPE: + { + t = LT(1); + if ( inputState->guessing == 0 ) { + t_AST = astFactory->create(t); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST)); + } + match(TYPE); + RefAdaAST tmp111_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp111_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp111_AST)); + } + match(IDENTIFIER); + { + switch ( LA(1)) { + case IS: + { + match(IS); + type_def(t_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case LPAREN: + { + { + switch ( LA(1)) { + case LPAREN: + { + discrim_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IS: + { + match(IS); + derived_or_private_or_record(t_AST, true); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 587 "ada.g" + Set(t_AST, INCOMPLETE_TYPE_DECLARATION); +#line 3759 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case SEMI: + { + empty_discrim_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 590 "ada.g" + Set(t_AST, INCOMPLETE_TYPE_DECLARATION); +#line 3780 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + decl_common_AST = RefAdaAST(currentAST.root); + break; + } + case SUBTYPE: + { + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(SUBTYPE); + RefAdaAST tmp115_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp115_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp115_AST)); + } + match(IDENTIFIER); + match(IS); + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 604 "ada.g" + Set(s_AST, SUBTYPE_DECLARATION); +#line 3825 "AdaParser.cpp" + } + decl_common_AST = RefAdaAST(currentAST.root); + break; + } + case GENERIC: + { + generic_decl(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + decl_common_AST = RefAdaAST(currentAST.root); + break; + } + case USE: + { + use_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + decl_common_AST = RefAdaAST(currentAST.root); + break; + } + case FOR: + { + r = LT(1); + if ( inputState->guessing == 0 ) { + r_AST = astFactory->create(r); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + } + match(FOR); + { + bool synPredMatched184 = false; + if (((LA(1) == IDENTIFIER) && (LA(2) == USE))) { + int _m184 = mark(); + synPredMatched184 = true; + inputState->guessing++; + try { + { + local_enum_name(); + match(USE); + match(LPAREN); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched184 = false; + } + rewind(_m184); + inputState->guessing--; + } + if ( synPredMatched184 ) { + local_enum_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(USE); + enumeration_aggregate(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 609 "ada.g" + Set(r_AST, ENUMERATION_REPESENTATION_CLAUSE); +#line 3888 "AdaParser.cpp" + } + } + else if ((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == USE || LA(2) == TIC)) { + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(USE); + rep_spec_part(r_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(SEMI); + decl_common_AST = RefAdaAST(currentAST.root); + break; + } + default: + bool synPredMatched186 = false; + if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) { + int _m186 = mark(); + synPredMatched186 = true; + inputState->guessing++; + try { + { + match(IDENTIFIER); + match(COLON); + match(EXCEPTION); + match(RENAMES); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched186 = false; + } + rewind(_m186); + inputState->guessing--; + } + if ( synPredMatched186 ) { + RefAdaAST tmp121_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp121_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp121_AST)); + } + match(IDENTIFIER); + erd = LT(1); + if ( inputState->guessing == 0 ) { + erd_AST = astFactory->create(erd); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(erd_AST)); + } + match(COLON); + match(EXCEPTION); + match(RENAMES); + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 615 "ada.g" + Set(erd_AST, EXCEPTION_RENAMING_DECLARATION); +#line 3954 "AdaParser.cpp" + } + decl_common_AST = RefAdaAST(currentAST.root); + } + else { + bool synPredMatched188 = false; + if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) { + int _m188 = mark(); + synPredMatched188 = true; + inputState->guessing++; + try { + { + match(IDENTIFIER); + match(COLON); + subtype_mark(); + match(RENAMES); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched188 = false; + } + rewind(_m188); + inputState->guessing--; + } + if ( synPredMatched188 ) { + RefAdaAST tmp125_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp125_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp125_AST)); + } + match(IDENTIFIER); + ord = LT(1); + if ( inputState->guessing == 0 ) { + ord_AST = astFactory->create(ord); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(ord_AST)); + } + match(COLON); + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RENAMES); + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 618 "ada.g" + Set(ord_AST, OBJECT_RENAMING_DECLARATION); +#line 4004 "AdaParser.cpp" + } + decl_common_AST = RefAdaAST(currentAST.root); + } + else if ((LA(1) == IDENTIFIER) && (LA(2) == COMMA || LA(2) == COLON)) { + defining_identifier_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + od = LT(1); + if ( inputState->guessing == 0 ) { + od_AST = astFactory->create(od); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(od_AST)); + } + match(COLON); + { + if ((LA(1) == EXCEPTION)) { + match(EXCEPTION); + if ( inputState->guessing==0 ) { +#line 621 "ada.g" + Set(od_AST, EXCEPTION_DECLARATION); +#line 4025 "AdaParser.cpp" + } + } + else { + bool synPredMatched191 = false; + if (((LA(1) == CONSTANT) && (LA(2) == ASSIGN))) { + int _m191 = mark(); + synPredMatched191 = true; + inputState->guessing++; + try { + { + match(CONSTANT); + match(ASSIGN); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched191 = false; + } + rewind(_m191); + inputState->guessing--; + } + if ( synPredMatched191 ) { + match(CONSTANT); + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 623 "ada.g" + Set(od_AST, NUMBER_DECLARATION); +#line 4056 "AdaParser.cpp" + } + } + else if ((_tokenSet_12.member(LA(1))) && (_tokenSet_13.member(LA(2)))) { + aliased_constant_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case ARRAY: + { + array_type_definition(od_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + init_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 626 "ada.g" + Set(od_AST, ARRAY_OBJECT_DECLARATION); +#line 4079 "AdaParser.cpp" + } + break; + } + case IDENTIFIER: + { + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + init_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 630 "ada.g" + Set(od_AST, OBJECT_DECLARATION); +#line 4096 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + decl_common_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + }} + returnAST = decl_common_AST; +} + +void AdaParser::discrim_part_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrim_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAREN: + { + discrim_part_text(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case IS: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + discrim_part_opt_AST = RefAdaAST(currentAST.root); +#line 420 "ada.g" + discrim_part_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrim_part_opt_AST)))); +#line 4153 "AdaParser.cpp" + currentAST.root = discrim_part_opt_AST; + if ( discrim_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + discrim_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = discrim_part_opt_AST->getFirstChild(); + else + currentAST.child = discrim_part_opt_AST; + currentAST.advanceChildToEnd(); + } + discrim_part_opt_AST = RefAdaAST(currentAST.root); + returnAST = discrim_part_opt_AST; +} + +void AdaParser::task_definition_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST task_definition_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case IS: + { + match(IS); + task_items_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + private_task_items_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + task_definition_opt_AST = RefAdaAST(currentAST.root); + break; + } + case SEMI: + { + match(SEMI); + if ( inputState->guessing==0 ) { +#line 415 "ada.g" + pop_def_id(); +#line 4197 "AdaParser.cpp" + } + task_definition_opt_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = task_definition_opt_AST; +} + +void AdaParser::task_items_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST task_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((LA(1) == PRAGMA)) { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop138; + } + + } + _loop138:; + } // ( ... )* + entrydecls_repspecs_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + task_items_opt_AST = RefAdaAST(currentAST.root); +#line 473 "ada.g" + task_items_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TASK_ITEMS_OPT,"TASK_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(task_items_opt_AST)))); +#line 4239 "AdaParser.cpp" + currentAST.root = task_items_opt_AST; + if ( task_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + task_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = task_items_opt_AST->getFirstChild(); + else + currentAST.child = task_items_opt_AST; + currentAST.advanceChildToEnd(); + } + task_items_opt_AST = RefAdaAST(currentAST.root); + returnAST = task_items_opt_AST; +} + +void AdaParser::private_task_items_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST private_task_items_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PRIVATE: + { + match(PRIVATE); + { // ( ... )* + for (;;) { + if ((LA(1) == PRAGMA)) { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop163; + } + + } + _loop163:; + } // ( ... )* + entrydecls_repspecs_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + private_task_items_opt_AST = RefAdaAST(currentAST.root); +#line 530 "ada.g" + private_task_items_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PRIVATE_TASK_ITEMS_OPT,"PRIVATE_TASK_ITEMS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(private_task_items_opt_AST)))); +#line 4298 "AdaParser.cpp" + currentAST.root = private_task_items_opt_AST; + if ( private_task_items_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + private_task_items_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = private_task_items_opt_AST->getFirstChild(); + else + currentAST.child = private_task_items_opt_AST; + currentAST.advanceChildToEnd(); + } + private_task_items_opt_AST = RefAdaAST(currentAST.root); + returnAST = private_task_items_opt_AST; +} + +void AdaParser::discrim_part_text() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrim_part_text_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAREN); + { + switch ( LA(1)) { + case BOX: + { + RefAdaAST tmp137_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp137_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp137_AST)); + } + match(BOX); + break; + } + case IDENTIFIER: + { + discriminant_specifications(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(RPAREN); + discrim_part_text_AST = RefAdaAST(currentAST.root); + returnAST = discrim_part_text_AST; +} + +void AdaParser::discriminant_specifications() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discriminant_specifications_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + discriminant_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == SEMI)) { + match(SEMI); + discriminant_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop130; + } + + } + _loop130:; + } // ( ... )* + if ( inputState->guessing==0 ) { + discriminant_specifications_AST = RefAdaAST(currentAST.root); +#line 450 "ada.g" + discriminant_specifications_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_SPECIFICATIONS,"DISCRIMINANT_SPECIFICATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_specifications_AST)))); +#line 4378 "AdaParser.cpp" + currentAST.root = discriminant_specifications_AST; + if ( discriminant_specifications_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + discriminant_specifications_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = discriminant_specifications_AST->getFirstChild(); + else + currentAST.child = discriminant_specifications_AST; + currentAST.advanceChildToEnd(); + } + discriminant_specifications_AST = RefAdaAST(currentAST.root); + returnAST = discriminant_specifications_AST; +} + +void AdaParser::known_discrim_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST known_discrim_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAREN); + discriminant_specifications(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { + known_discrim_part_AST = RefAdaAST(currentAST.root); +#line 430 "ada.g" + known_discrim_part_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(known_discrim_part_AST)))); +#line 4407 "AdaParser.cpp" + currentAST.root = known_discrim_part_AST; + if ( known_discrim_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + known_discrim_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = known_discrim_part_AST->getFirstChild(); + else + currentAST.child = known_discrim_part_AST; + currentAST.advanceChildToEnd(); + } + known_discrim_part_AST = RefAdaAST(currentAST.root); + returnAST = known_discrim_part_AST; +} + +void AdaParser::empty_discrim_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST empty_discrim_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ( inputState->guessing==0 ) { + empty_discrim_opt_AST = RefAdaAST(currentAST.root); +#line 436 "ada.g" + empty_discrim_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(empty_discrim_opt_AST)))); +#line 4430 "AdaParser.cpp" + currentAST.root = empty_discrim_opt_AST; + if ( empty_discrim_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + empty_discrim_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = empty_discrim_opt_AST->getFirstChild(); + else + currentAST.child = empty_discrim_opt_AST; + currentAST.advanceChildToEnd(); + } + empty_discrim_opt_AST = RefAdaAST(currentAST.root); + returnAST = empty_discrim_opt_AST; +} + +void AdaParser::discrim_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrim_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + discrim_part_text(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + discrim_part_AST = RefAdaAST(currentAST.root); +#line 443 "ada.g" + discrim_part_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrim_part_AST)))); +#line 4457 "AdaParser.cpp" + currentAST.root = discrim_part_AST; + if ( discrim_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + discrim_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = discrim_part_AST->getFirstChild(); + else + currentAST.child = discrim_part_AST; + currentAST.advanceChildToEnd(); + } + discrim_part_AST = RefAdaAST(currentAST.root); + returnAST = discrim_part_AST; +} + +void AdaParser::discriminant_specification() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discriminant_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + def_ids_colon(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + access_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + init_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + discriminant_specification_AST = RefAdaAST(currentAST.root); +#line 457 "ada.g" + discriminant_specification_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_SPECIFICATION,"DISCRIMINANT_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_specification_AST)))); +#line 4496 "AdaParser.cpp" + currentAST.root = discriminant_specification_AST; + if ( discriminant_specification_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + discriminant_specification_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = discriminant_specification_AST->getFirstChild(); + else + currentAST.child = discriminant_specification_AST; + currentAST.advanceChildToEnd(); + } + discriminant_specification_AST = RefAdaAST(currentAST.root); + returnAST = discriminant_specification_AST; +} + +void AdaParser::access_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST access_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ACCESS: + { + RefAdaAST tmp142_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp142_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp142_AST)); + } + match(ACCESS); + break; + } + case IDENTIFIER: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + access_opt_AST = RefAdaAST(currentAST.root); +#line 464 "ada.g" + access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(access_opt_AST)))); +#line 4540 "AdaParser.cpp" + currentAST.root = access_opt_AST; + if ( access_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + access_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = access_opt_AST->getFirstChild(); + else + currentAST.child = access_opt_AST; + currentAST.advanceChildToEnd(); + } + access_opt_AST = RefAdaAST(currentAST.root); + returnAST = access_opt_AST; +} + +void AdaParser::entrydecls_repspecs_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entrydecls_repspecs_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((LA(1) == ENTRY)) { + entry_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + rep_spec(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop142; + } + } + } + _loop142:; + } // ( ... )* + } + else { + goto _loop143; + } + + } + _loop143:; + } // ( ... )* + entrydecls_repspecs_opt_AST = RefAdaAST(currentAST.root); + returnAST = entrydecls_repspecs_opt_AST; +} + +void AdaParser::entry_declaration() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_declaration_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + e = LT(1); + if ( inputState->guessing == 0 ) { + e_AST = astFactory->create(e); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + } + match(ENTRY); + RefAdaAST tmp143_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp143_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp143_AST)); + } + match(IDENTIFIER); + discrete_subtype_def_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 482 "ada.g" + Set (e_AST, ENTRY_DECLARATION); +#line 4635 "AdaParser.cpp" + } + entry_declaration_AST = RefAdaAST(currentAST.root); + returnAST = entry_declaration_AST; +} + +void AdaParser::rep_spec() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST rep_spec_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + r = LT(1); + if ( inputState->guessing == 0 ) { + r_AST = astFactory->create(r); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + } + match(FOR); + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(USE); + rep_spec_part(r_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + rep_spec_AST = RefAdaAST(currentAST.root); + returnAST = rep_spec_AST; +} + +void AdaParser::discrete_subtype_def_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrete_subtype_def_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + bool synPredMatched148 = false; + if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) { + int _m148 = mark(); + synPredMatched148 = true; + inputState->guessing++; + try { + { + match(LPAREN); + discrete_subtype_definition(); + match(RPAREN); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched148 = false; + } + rewind(_m148); + inputState->guessing--; + } + if ( synPredMatched148 ) { + match(LPAREN); + discrete_subtype_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + } + else if ((LA(1) == SEMI || LA(1) == LPAREN) && (_tokenSet_14.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root); +#line 489 "ada.g" + discrete_subtype_def_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRETE_SUBTYPE_DEF_OPT,"DISCRETE_SUBTYPE_DEF_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discrete_subtype_def_opt_AST)))); +#line 4712 "AdaParser.cpp" + currentAST.root = discrete_subtype_def_opt_AST; + if ( discrete_subtype_def_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + discrete_subtype_def_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = discrete_subtype_def_opt_AST->getFirstChild(); + else + currentAST.child = discrete_subtype_def_opt_AST; + currentAST.advanceChildToEnd(); + } + discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root); + returnAST = discrete_subtype_def_opt_AST; +} + +void AdaParser::discrete_subtype_definition() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrete_subtype_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + bool synPredMatched152 = false; + if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) { + int _m152 = mark(); + synPredMatched152 = true; + inputState->guessing++; + try { + { + range(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched152 = false; + } + rewind(_m152); + inputState->guessing--; + } + if ( synPredMatched152 ) { + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == IDENTIFIER) && (_tokenSet_15.member(LA(2)))) { + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + discrete_subtype_definition_AST = RefAdaAST(currentAST.root); + returnAST = discrete_subtype_definition_AST; +} + +void AdaParser::subtype_ind() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subtype_ind_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + constraint_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + subtype_ind_AST = RefAdaAST(currentAST.root); +#line 693 "ada.g" + subtype_ind_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SUBTYPE_INDICATION,"SUBTYPE_INDICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(subtype_ind_AST)))); +#line 4785 "AdaParser.cpp" + currentAST.root = subtype_ind_AST; + if ( subtype_ind_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + subtype_ind_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = subtype_ind_AST->getFirstChild(); + else + currentAST.child = subtype_ind_AST; + currentAST.advanceChildToEnd(); + } + subtype_ind_AST = RefAdaAST(currentAST.root); + returnAST = subtype_ind_AST; +} + +void AdaParser::rep_spec_part( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST rep_spec_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case RECORD: + { + match(RECORD); + align_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + comp_loc_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(RECORD); + if ( inputState->guessing==0 ) { +#line 512 "ada.g" + Set(t, RECORD_REPRESENTATION_CLAUSE); +#line 4822 "AdaParser.cpp" + } + rep_spec_part_AST = RefAdaAST(currentAST.root); + break; + } + case AT: + { + match(AT); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 514 "ada.g" + Set(t, AT_CLAUSE); +#line 4837 "AdaParser.cpp" + } + rep_spec_part_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 517 "ada.g" + Set(t, ATTRIBUTE_DEFINITION_CLAUSE); +#line 4861 "AdaParser.cpp" + } + rep_spec_part_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = rep_spec_part_AST; +} + +void AdaParser::align_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST align_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case AT: + { + match(AT); + match(MOD); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + break; + } + case PRAGMA: + case IDENTIFIER: + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + align_opt_AST = RefAdaAST(currentAST.root); +#line 521 "ada.g" + align_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MOD_CLAUSE_OPT,"MOD_CLAUSE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(align_opt_AST)))); +#line 4908 "AdaParser.cpp" + currentAST.root = align_opt_AST; + if ( align_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + align_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = align_opt_AST->getFirstChild(); + else + currentAST.child = align_opt_AST; + currentAST.advanceChildToEnd(); + } + align_opt_AST = RefAdaAST(currentAST.root); + returnAST = align_opt_AST; +} + +void AdaParser::comp_loc_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST comp_loc_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + { + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(AT); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RANGE); + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + break; + } + default: + { + goto _loop159; + } + } + } + _loop159:; + } // ( ... )* + if ( inputState->guessing==0 ) { + comp_loc_s_AST = RefAdaAST(currentAST.root); +#line 525 "ada.g" + comp_loc_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_CLAUSES_OPT,"COMPONENT_CLAUSES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comp_loc_s_AST)))); +#line 4968 "AdaParser.cpp" + currentAST.root = comp_loc_s_AST; + if ( comp_loc_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + comp_loc_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = comp_loc_s_AST->getFirstChild(); + else + currentAST.child = comp_loc_s_AST; + currentAST.advanceChildToEnd(); + } + comp_loc_s_AST = RefAdaAST(currentAST.root); + returnAST = comp_loc_s_AST; +} + +void AdaParser::protected_definition() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST protected_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(IS); + prot_op_decl_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + prot_private_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + protected_definition_AST = RefAdaAST(currentAST.root); + returnAST = protected_definition_AST; +} + +void AdaParser::prot_private_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prot_private_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PRIVATE: + { + match(PRIVATE); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + case PROCEDURE: + case FUNCTION: + case ENTRY: + case FOR: + { + prot_op_decl(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + { + comp_decl(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop168; + } + } + } + _loop168:; + } // ( ... )* + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + prot_private_opt_AST = RefAdaAST(currentAST.root); +#line 545 "ada.g" + prot_private_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_PRIVATE_OPT,"PROT_PRIVATE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_private_opt_AST)))); +#line 5061 "AdaParser.cpp" + currentAST.root = prot_private_opt_AST; + if ( prot_private_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + prot_private_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = prot_private_opt_AST->getFirstChild(); + else + currentAST.child = prot_private_opt_AST; + currentAST.advanceChildToEnd(); + } + prot_private_opt_AST = RefAdaAST(currentAST.root); + returnAST = prot_private_opt_AST; +} + +void AdaParser::prot_op_decl() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prot_op_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case ENTRY: + { + entry_declaration(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + prot_op_decl_AST = RefAdaAST(currentAST.root); + break; + } + case PROCEDURE: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PROCEDURE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 561 "ada.g" + pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION); +#line 5113 "AdaParser.cpp" + } + prot_op_decl_AST = RefAdaAST(currentAST.root); + break; + } + case FUNCTION: + { + f = LT(1); + if ( inputState->guessing == 0 ) { + f_AST = astFactory->create(f); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + } + match(FUNCTION); + def_designator(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 563 "ada.g" + pop_def_id(); Set(f_AST, FUNCTION_DECLARATION); +#line 5138 "AdaParser.cpp" + } + prot_op_decl_AST = RefAdaAST(currentAST.root); + break; + } + case FOR: + { + rep_spec(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + prot_op_decl_AST = RefAdaAST(currentAST.root); + break; + } + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + prot_op_decl_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = prot_op_decl_AST; +} + +void AdaParser::comp_decl() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST comp_decl_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + def_ids_colon(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_subtype_def(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + init_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { + comp_decl_AST = RefAdaAST(currentAST.root); +#line 575 "ada.g" + comp_decl_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_DECLARATION,"COMPONENT_DECLARATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(comp_decl_AST)))); +#line 5192 "AdaParser.cpp" + currentAST.root = comp_decl_AST; + if ( comp_decl_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + comp_decl_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = comp_decl_AST->getFirstChild(); + else + currentAST.child = comp_decl_AST; + currentAST.advanceChildToEnd(); + } + comp_decl_AST = RefAdaAST(currentAST.root); + returnAST = comp_decl_AST; +} + +void AdaParser::prot_op_decl_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prot_op_decl_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((_tokenSet_16.member(LA(1)))) { + prot_op_decl(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop172; + } + + } + _loop172:; + } // ( ... )* + if ( inputState->guessing==0 ) { + prot_op_decl_s_AST = RefAdaAST(currentAST.root); +#line 555 "ada.g" + prot_op_decl_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_OP_DECLARATIONS,"PROT_OP_DECLARATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_op_decl_s_AST)))); +#line 5229 "AdaParser.cpp" + currentAST.root = prot_op_decl_s_AST; + if ( prot_op_decl_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + prot_op_decl_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = prot_op_decl_s_AST->getFirstChild(); + else + currentAST.child = prot_op_decl_s_AST; + currentAST.advanceChildToEnd(); + } + prot_op_decl_s_AST = RefAdaAST(currentAST.root); + returnAST = prot_op_decl_s_AST; +} + +void AdaParser::prot_member_decl_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prot_member_decl_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + case PROCEDURE: + case FUNCTION: + case ENTRY: + case FOR: + { + prot_op_decl(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + { + comp_decl(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop176; + } + } + } + _loop176:; + } // ( ... )* + if ( inputState->guessing==0 ) { + prot_member_decl_s_AST = RefAdaAST(currentAST.root); +#line 569 "ada.g" + prot_member_decl_s_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_MEMBER_DECLARATIONS,"PROT_MEMBER_DECLARATIONS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_member_decl_s_AST)))); +#line 5283 "AdaParser.cpp" + currentAST.root = prot_member_decl_s_AST; + if ( prot_member_decl_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + prot_member_decl_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = prot_member_decl_s_AST->getFirstChild(); + else + currentAST.child = prot_member_decl_s_AST; + currentAST.advanceChildToEnd(); + } + prot_member_decl_s_AST = RefAdaAST(currentAST.root); + returnAST = prot_member_decl_s_AST; +} + +void AdaParser::component_subtype_def() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST component_subtype_def_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + aliased_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + component_subtype_def_AST = RefAdaAST(currentAST.root); + returnAST = component_subtype_def_AST; +} + +void AdaParser::type_def( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST type_def_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + enum_id_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 638 "ada.g" + Set(t, ENUMERATION_TYPE_DECLARATION); +#line 5332 "AdaParser.cpp" + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case RANGE: + { + match(RANGE); + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 640 "ada.g" + Set(t, SIGNED_INTEGER_TYPE_DECLARATION); +#line 5347 "AdaParser.cpp" + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case MOD: + { + match(MOD); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 642 "ada.g" + Set(t, MODULAR_TYPE_DECLARATION); +#line 5362 "AdaParser.cpp" + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case DIGITS: + { + match(DIGITS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_constraint_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 644 "ada.g" + Set(t, FLOATING_POINT_DECLARATION); +#line 5381 "AdaParser.cpp" + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case DELTA: + { + match(DELTA); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case RANGE: + { + match(RANGE); + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 647 "ada.g" + Set(t, ORDINARY_FIXED_POINT_DECLARATION); +#line 5405 "AdaParser.cpp" + } + break; + } + case DIGITS: + { + match(DIGITS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_constraint_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 649 "ada.g" + Set(t, DECIMAL_FIXED_POINT_DECLARATION); +#line 5423 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case ARRAY: + { + array_type_definition(t); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case ACCESS: + { + access_type_definition(t); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + case PRIVATE: + case NEW: + case NuLL: + case RECORD: + case ABSTRACT: + case TAGGED: + case LIMITED: + { + empty_discrim_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + derived_or_private_or_record(t, false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + type_def_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = type_def_AST; +} + +void AdaParser::derived_or_private_or_record( + RefAdaAST t, boolean has_discrim +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST derived_or_private_or_record_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + bool synPredMatched246 = false; + if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) { + int _m246 = mark(); + synPredMatched246 = true; + inputState->guessing++; + try { + { + { + switch ( LA(1)) { + case ABSTRACT: + { + match(ABSTRACT); + break; + } + case NEW: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(NEW); + subtype_ind(); + match(WITH); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched246 = false; + } + rewind(_m246); + inputState->guessing--; + } + if ( synPredMatched246 ) { + abstract_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(NEW); + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(WITH); + { + switch ( LA(1)) { + case PRIVATE: + { + match(PRIVATE); + if ( inputState->guessing==0 ) { +#line 772 "ada.g" + Set(t, PRIVATE_EXTENSION_DECLARATION); +#line 5542 "AdaParser.cpp" + } + break; + } + case NuLL: + case RECORD: + { + record_definition(has_discrim); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 774 "ada.g" + Set(t, DERIVED_RECORD_EXTENSION); +#line 5556 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + derived_or_private_or_record_AST = RefAdaAST(currentAST.root); + } + else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) { + match(NEW); + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 776 "ada.g" + Set(t, ORDINARY_DERIVED_TYPE_DECLARATION); +#line 5577 "AdaParser.cpp" + } + derived_or_private_or_record_AST = RefAdaAST(currentAST.root); + } + else if ((_tokenSet_17.member(LA(1))) && (_tokenSet_18.member(LA(2)))) { + abstract_tagged_limited_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case PRIVATE: + { + match(PRIVATE); + if ( inputState->guessing==0 ) { +#line 778 "ada.g" + Set(t, PRIVATE_TYPE_DECLARATION); +#line 5594 "AdaParser.cpp" + } + break; + } + case NuLL: + case RECORD: + { + record_definition(has_discrim); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 780 "ada.g" + Set(t, RECORD_TYPE_DECLARATION); +#line 5608 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + derived_or_private_or_record_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = derived_or_private_or_record_AST; +} + +void AdaParser::local_enum_name() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST local_enum_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp177_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp177_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp177_AST)); + } + match(IDENTIFIER); + local_enum_name_AST = RefAdaAST(currentAST.root); + returnAST = local_enum_name_AST; +} + +void AdaParser::enumeration_aggregate() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST enumeration_aggregate_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + parenth_values(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + enumeration_aggregate_AST = RefAdaAST(currentAST.root); + returnAST = enumeration_aggregate_AST; +} + +void AdaParser::aliased_constant_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST aliased_constant_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ALIASED: + { + RefAdaAST tmp178_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp178_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp178_AST)); + } + match(ALIASED); + break; + } + case IDENTIFIER: + case CONSTANT: + case ARRAY: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case CONSTANT: + { + RefAdaAST tmp179_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp179_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp179_AST)); + } + match(CONSTANT); + break; + } + case IDENTIFIER: + case ARRAY: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + aliased_constant_opt_AST = RefAdaAST(currentAST.root); +#line 858 "ada.g" + aliased_constant_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(aliased_constant_opt_AST)))); +#line 5712 "AdaParser.cpp" + currentAST.root = aliased_constant_opt_AST; + if ( aliased_constant_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + aliased_constant_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = aliased_constant_opt_AST->getFirstChild(); + else + currentAST.child = aliased_constant_opt_AST; + currentAST.advanceChildToEnd(); + } + aliased_constant_opt_AST = RefAdaAST(currentAST.root); + returnAST = aliased_constant_opt_AST; +} + +void AdaParser::array_type_definition( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST array_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(ARRAY); + match(LPAREN); + index_or_discrete_range_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + match(OF); + component_subtype_def(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 669 "ada.g" + Set(t, ARRAY_TYPE_DECLARATION); +#line 5747 "AdaParser.cpp" + } + array_type_definition_AST = RefAdaAST(currentAST.root); + returnAST = array_type_definition_AST; +} + +void AdaParser::enum_id_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST enum_id_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + enumeration_literal_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + enumeration_literal_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop197; + } + + } + _loop197:; + } // ( ... )* + enum_id_s_AST = RefAdaAST(currentAST.root); + returnAST = enum_id_s_AST; +} + +void AdaParser::range_constraint_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST range_constraint_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case RANGE: + { + range_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case COMMA: + case RPAREN: + case WITH: + case ASSIGN: + case LOOP: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + range_constraint_opt_AST = RefAdaAST(currentAST.root); + returnAST = range_constraint_opt_AST; +} + +void AdaParser::access_type_definition( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST access_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(ACCESS); + { + switch ( LA(1)) { + case PROCEDURE: + case FUNCTION: + case PROTECTED: + { + protected_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case PROCEDURE: + { + match(PROCEDURE); + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 751 "ada.g" + Set(t, ACCESS_TO_PROCEDURE_DECLARATION); +#line 5846 "AdaParser.cpp" + } + break; + } + case FUNCTION: + { + match(FUNCTION); + func_formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RETURN); + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 753 "ada.g" + Set(t, ACCESS_TO_FUNCTION_DECLARATION); +#line 5865 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case IDENTIFIER: + case ALL: + case CONSTANT: + { + constant_all_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 756 "ada.g" + Set(t, ACCESS_TO_OBJECT_DECLARATION); +#line 5892 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + access_type_definition_AST = RefAdaAST(currentAST.root); + returnAST = access_type_definition_AST; +} + +void AdaParser::enumeration_literal_specification() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST enumeration_literal_specification_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case IDENTIFIER: + { + RefAdaAST tmp189_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp189_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp189_AST)); + } + match(IDENTIFIER); + enumeration_literal_specification_AST = RefAdaAST(currentAST.root); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp190_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp190_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp190_AST)); + } + match(CHARACTER_LITERAL); + enumeration_literal_specification_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = enumeration_literal_specification_AST; +} + +void AdaParser::index_or_discrete_range_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST index_or_discrete_range_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + index_or_discrete_range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + RefAdaAST tmp191_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp191_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp191_AST)); + } + match(COMMA); + index_or_discrete_range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop204; + } + + } + _loop204:; + } // ( ... )* + index_or_discrete_range_s_AST = RefAdaAST(currentAST.root); + returnAST = index_or_discrete_range_s_AST; +} + +void AdaParser::index_or_discrete_range() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST index_or_discrete_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case DOT_DOT: + { + RefAdaAST tmp192_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp192_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp192_AST)); + } + match(DOT_DOT); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case RANGE: + { + RefAdaAST tmp193_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp193_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp193_AST)); + } + match(RANGE); + { + switch ( LA(1)) { + case BOX: + { + RefAdaAST tmp194_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp194_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp194_AST)); + } + match(BOX); + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case COMMA: + case RPAREN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + index_or_discrete_range_AST = RefAdaAST(currentAST.root); + returnAST = index_or_discrete_range_AST; +} + +void AdaParser::aliased_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST aliased_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ALIASED: + { + RefAdaAST tmp195_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp195_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp195_AST)); + } + match(ALIASED); + break; + } + case IDENTIFIER: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + aliased_opt_AST = RefAdaAST(currentAST.root); +#line 689 "ada.g" + aliased_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(aliased_opt_AST)))); +#line 6093 "AdaParser.cpp" + currentAST.root = aliased_opt_AST; + if ( aliased_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + aliased_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = aliased_opt_AST->getFirstChild(); + else + currentAST.child = aliased_opt_AST; + currentAST.advanceChildToEnd(); + } + aliased_opt_AST = RefAdaAST(currentAST.root); + returnAST = aliased_opt_AST; +} + +void AdaParser::constraint_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST constraint_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case RANGE: + { + range_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case DIGITS: + { + digits_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case DELTA: + { + delta_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case COMMA: + case RPAREN: + case WITH: + case ASSIGN: + case LOOP: + { + break; + } + default: + bool synPredMatched215 = false; + if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) { + int _m215 = mark(); + synPredMatched215 = true; + inputState->guessing++; + try { + { + index_constraint(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched215 = false; + } + rewind(_m215); + inputState->guessing--; + } + if ( synPredMatched215 ) { + index_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2)))) { + discriminant_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + constraint_opt_AST = RefAdaAST(currentAST.root); + returnAST = constraint_opt_AST; +} + +void AdaParser::digits_constraint() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST digits_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + d = LT(1); + if ( inputState->guessing == 0 ) { + d_AST = astFactory->create(d); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + } + match(DIGITS); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_constraint_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 706 "ada.g" + Set(d_AST, DIGITS_CONSTRAINT); +#line 6208 "AdaParser.cpp" + } + digits_constraint_AST = RefAdaAST(currentAST.root); + returnAST = digits_constraint_AST; +} + +void AdaParser::delta_constraint() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST delta_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + d = LT(1); + if ( inputState->guessing == 0 ) { + d_AST = astFactory->create(d); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + } + match(DELTA); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_constraint_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 710 "ada.g" + Set(d_AST, DELTA_CONSTRAINT); +#line 6238 "AdaParser.cpp" + } + delta_constraint_AST = RefAdaAST(currentAST.root); + returnAST = delta_constraint_AST; +} + +void AdaParser::index_constraint() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST index_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(LPAREN); + discrete_range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + discrete_range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop220; + } + + } + _loop220:; + } // ( ... )* + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 714 "ada.g" + Set(p_AST, INDEX_CONSTRAINT); +#line 6281 "AdaParser.cpp" + } + index_constraint_AST = RefAdaAST(currentAST.root); + returnAST = index_constraint_AST; +} + +void AdaParser::discriminant_constraint() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discriminant_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(LPAREN); + discriminant_association(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + discriminant_association(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop226; + } + + } + _loop226:; + } // ( ... )* + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 724 "ada.g" + Set(p_AST, DISCRIMINANT_CONSTRAINT); +#line 6324 "AdaParser.cpp" + } + discriminant_constraint_AST = RefAdaAST(currentAST.root); + returnAST = discriminant_constraint_AST; +} + +void AdaParser::discrete_range() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrete_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + bool synPredMatched223 = false; + if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) { + int _m223 = mark(); + synPredMatched223 = true; + inputState->guessing++; + try { + { + range(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched223 = false; + } + rewind(_m223); + inputState->guessing--; + } + if ( synPredMatched223 ) { + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrete_range_AST = RefAdaAST(currentAST.root); + } + else if ((LA(1) == IDENTIFIER) && (_tokenSet_19.member(LA(2)))) { + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrete_range_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = discrete_range_AST; +} + +void AdaParser::discriminant_association() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discriminant_association_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + selector_names_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + discriminant_association_AST = RefAdaAST(currentAST.root); +#line 728 "ada.g" + discriminant_association_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DISCRIMINANT_ASSOCIATION,"DISCRIMINANT_ASSOCIATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(discriminant_association_AST)))); +#line 6390 "AdaParser.cpp" + currentAST.root = discriminant_association_AST; + if ( discriminant_association_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + discriminant_association_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = discriminant_association_AST->getFirstChild(); + else + currentAST.child = discriminant_association_AST; + currentAST.advanceChildToEnd(); + } + discriminant_association_AST = RefAdaAST(currentAST.root); + returnAST = discriminant_association_AST; +} + +void AdaParser::selector_names_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST selector_names_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + bool synPredMatched231 = false; + if (((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT || LA(2) == PIPE))) { + int _m231 = mark(); + synPredMatched231 = true; + inputState->guessing++; + try { + { + association_head(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched231 = false; + } + rewind(_m231); + inputState->guessing--; + } + if ( synPredMatched231 ) { + association_head(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_1.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + selector_names_opt_AST = RefAdaAST(currentAST.root); +#line 736 "ada.g" + selector_names_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SELECTOR_NAMES_OPT,"SELECTOR_NAMES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(selector_names_opt_AST)))); +#line 6443 "AdaParser.cpp" + currentAST.root = selector_names_opt_AST; + if ( selector_names_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + selector_names_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = selector_names_opt_AST->getFirstChild(); + else + currentAST.child = selector_names_opt_AST; + currentAST.advanceChildToEnd(); + } + selector_names_opt_AST = RefAdaAST(currentAST.root); + returnAST = selector_names_opt_AST; +} + +void AdaParser::association_head() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST association_head_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + selector_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == PIPE)) { + match(PIPE); + selector_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop234; + } + + } + _loop234:; + } // ( ... )* + match(RIGHT_SHAFT); + association_head_AST = RefAdaAST(currentAST.root); + returnAST = association_head_AST; +} + +void AdaParser::selector_name() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST selector_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp202_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp202_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp202_AST)); + } + match(IDENTIFIER); + selector_name_AST = RefAdaAST(currentAST.root); + returnAST = selector_name_AST; +} + +void AdaParser::protected_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST protected_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PROTECTED: + { + RefAdaAST tmp203_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp203_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp203_AST)); + } + match(PROTECTED); + break; + } + case PROCEDURE: + case FUNCTION: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + protected_opt_AST = RefAdaAST(currentAST.root); +#line 761 "ada.g" + protected_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(protected_opt_AST)))); +#line 6533 "AdaParser.cpp" + currentAST.root = protected_opt_AST; + if ( protected_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + protected_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = protected_opt_AST->getFirstChild(); + else + currentAST.child = protected_opt_AST; + currentAST.advanceChildToEnd(); + } + protected_opt_AST = RefAdaAST(currentAST.root); + returnAST = protected_opt_AST; +} + +void AdaParser::constant_all_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST constant_all_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case CONSTANT: + { + RefAdaAST tmp204_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp204_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp204_AST)); + } + match(CONSTANT); + break; + } + case ALL: + { + RefAdaAST tmp205_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp205_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp205_AST)); + } + match(ALL); + break; + } + case IDENTIFIER: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + constant_all_opt_AST = RefAdaAST(currentAST.root); +#line 765 "ada.g" + constant_all_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(constant_all_opt_AST)))); +#line 6588 "AdaParser.cpp" + currentAST.root = constant_all_opt_AST; + if ( constant_all_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + constant_all_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = constant_all_opt_AST->getFirstChild(); + else + currentAST.child = constant_all_opt_AST; + currentAST.advanceChildToEnd(); + } + constant_all_opt_AST = RefAdaAST(currentAST.root); + returnAST = constant_all_opt_AST; +} + +void AdaParser::abstract_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST abstract_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ABSTRACT: + { + RefAdaAST tmp206_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp206_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp206_AST)); + } + match(ABSTRACT); + break; + } + case NEW: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + abstract_opt_AST = RefAdaAST(currentAST.root); +#line 785 "ada.g" + abstract_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abstract_opt_AST)))); +#line 6632 "AdaParser.cpp" + currentAST.root = abstract_opt_AST; + if ( abstract_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + abstract_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = abstract_opt_AST->getFirstChild(); + else + currentAST.child = abstract_opt_AST; + currentAST.advanceChildToEnd(); + } + abstract_opt_AST = RefAdaAST(currentAST.root); + returnAST = abstract_opt_AST; +} + +void AdaParser::record_definition( + boolean has_discrim +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST record_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case RECORD: + { + match(RECORD); + component_list(has_discrim); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(RECORD); + record_definition_AST = RefAdaAST(currentAST.root); + break; + } + case NuLL: + { + match(NuLL); + match(RECORD); + record_definition_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = record_definition_AST; +} + +void AdaParser::abstract_tagged_limited_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST abstract_tagged_limited_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ABSTRACT: + { + RefAdaAST tmp212_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp212_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp212_AST)); + } + match(ABSTRACT); + match(TAGGED); + break; + } + case TAGGED: + { + RefAdaAST tmp214_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp214_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp214_AST)); + } + match(TAGGED); + break; + } + case PRIVATE: + case NuLL: + case RECORD: + case LIMITED: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case LIMITED: + { + RefAdaAST tmp215_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp215_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp215_AST)); + } + match(LIMITED); + break; + } + case PRIVATE: + case NuLL: + case RECORD: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root); +#line 847 "ada.g" + abstract_tagged_limited_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abstract_tagged_limited_opt_AST)))); +#line 6750 "AdaParser.cpp" + currentAST.root = abstract_tagged_limited_opt_AST; + if ( abstract_tagged_limited_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + abstract_tagged_limited_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = abstract_tagged_limited_opt_AST->getFirstChild(); + else + currentAST.child = abstract_tagged_limited_opt_AST; + currentAST.advanceChildToEnd(); + } + abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root); + returnAST = abstract_tagged_limited_opt_AST; +} + +void AdaParser::component_list( + boolean has_discrim +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST component_list_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case NuLL: + { + match(NuLL); + match(SEMI); + component_list_AST = RefAdaAST(currentAST.root); + break; + } + case PRAGMA: + case IDENTIFIER: + { + component_items(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case CASE: + { + variant_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if (!( has_discrim )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim "); + break; + } + case END: + case WHEN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + component_list_AST = RefAdaAST(currentAST.root); + break; + } + case CASE: + { + empty_component_items(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + variant_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if (!( has_discrim )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim "); + component_list_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = component_list_AST; +} + +void AdaParser::component_items() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST component_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )+ + int _cnt256=0; + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + { + comp_decl(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + if ( _cnt256>=1 ) { goto _loop256; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + } + _cnt256++; + } + _loop256:; + } // ( ... )+ + if ( inputState->guessing==0 ) { + component_items_AST = RefAdaAST(currentAST.root); +#line 800 "ada.g" + component_items_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(component_items_AST)))); +#line 6873 "AdaParser.cpp" + currentAST.root = component_items_AST; + if ( component_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + component_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = component_items_AST->getFirstChild(); + else + currentAST.child = component_items_AST; + currentAST.advanceChildToEnd(); + } + component_items_AST = RefAdaAST(currentAST.root); + returnAST = component_items_AST; +} + +void AdaParser::variant_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST variant_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST c_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + c = LT(1); + if ( inputState->guessing == 0 ) { + c_AST = astFactory->create(c); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + } + match(CASE); + discriminant_direct_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + variant_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(CASE); + match(SEMI); + if ( inputState->guessing==0 ) { +#line 812 "ada.g" + Set (c_AST, VARIANT_PART); +#line 6914 "AdaParser.cpp" + } + variant_part_AST = RefAdaAST(currentAST.root); + returnAST = variant_part_AST; +} + +void AdaParser::empty_component_items() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST empty_component_items_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ( inputState->guessing==0 ) { + empty_component_items_AST = RefAdaAST(currentAST.root); +#line 806 "ada.g" + empty_component_items_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(empty_component_items_AST)))); +#line 6930 "AdaParser.cpp" + currentAST.root = empty_component_items_AST; + if ( empty_component_items_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + empty_component_items_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = empty_component_items_AST->getFirstChild(); + else + currentAST.child = empty_component_items_AST; + currentAST.advanceChildToEnd(); + } + empty_component_items_AST = RefAdaAST(currentAST.root); + returnAST = empty_component_items_AST; +} + +void AdaParser::discriminant_direct_name() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discriminant_direct_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp222_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp222_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp222_AST)); + } + match(IDENTIFIER); + discriminant_direct_name_AST = RefAdaAST(currentAST.root); + returnAST = discriminant_direct_name_AST; +} + +void AdaParser::variant_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST variant_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )+ + int _cnt262=0; + for (;;) { + if ((LA(1) == WHEN)) { + variant(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + if ( _cnt262>=1 ) { goto _loop262; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt262++; + } + _loop262:; + } // ( ... )+ + if ( inputState->guessing==0 ) { + variant_s_AST = RefAdaAST(currentAST.root); +#line 819 "ada.g" + variant_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(VARIANTS,"VARIANTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(variant_s_AST)))); +#line 6984 "AdaParser.cpp" + currentAST.root = variant_s_AST; + if ( variant_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + variant_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = variant_s_AST->getFirstChild(); + else + currentAST.child = variant_s_AST; + currentAST.advanceChildToEnd(); + } + variant_s_AST = RefAdaAST(currentAST.root); + returnAST = variant_s_AST; +} + +void AdaParser::variant() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST variant_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + w = LT(1); + if ( inputState->guessing == 0 ) { + w_AST = astFactory->create(w); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + } + match(WHEN); + choice_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RIGHT_SHAFT); + component_list(true); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 823 "ada.g" + Set (w_AST, VARIANT); +#line 7022 "AdaParser.cpp" + } + variant_AST = RefAdaAST(currentAST.root); + returnAST = variant_AST; +} + +void AdaParser::choice_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST choice_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + choice(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == PIPE)) { + RefAdaAST tmp224_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp224_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp224_AST)); + } + match(PIPE); + choice(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop266; + } + + } + _loop266:; + } // ( ... )* + choice_s_AST = RefAdaAST(currentAST.root); + returnAST = choice_s_AST; +} + +void AdaParser::choice() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST choice_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + if ((LA(1) == OTHERS)) { + RefAdaAST tmp225_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp225_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp225_AST)); + } + match(OTHERS); + choice_AST = RefAdaAST(currentAST.root); + } + else { + bool synPredMatched269 = false; + if (((_tokenSet_0.member(LA(1))) && (_tokenSet_20.member(LA(2))))) { + int _m269 = mark(); + synPredMatched269 = true; + inputState->guessing++; + try { + { + discrete_with_range(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched269 = false; + } + rewind(_m269); + inputState->guessing--; + } + if ( synPredMatched269 ) { + discrete_with_range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + choice_AST = RefAdaAST(currentAST.root); + } + else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_21.member(LA(2)))) { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + choice_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = choice_AST; +} + +void AdaParser::discrete_with_range() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discrete_with_range_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + bool synPredMatched272 = false; + if (((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == TIC || LA(2) == RANGE))) { + int _m272 = mark(); + synPredMatched272 = true; + inputState->guessing++; + try { + { + mark_with_constraint(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched272 = false; + } + rewind(_m272); + inputState->guessing--; + } + if ( synPredMatched272 ) { + mark_with_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrete_with_range_AST = RefAdaAST(currentAST.root); + } + else if ((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2)))) { + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrete_with_range_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = discrete_with_range_AST; +} + +void AdaParser::mark_with_constraint() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST mark_with_constraint_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_constraint(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + mark_with_constraint_AST = RefAdaAST(currentAST.root); +#line 839 "ada.g" + mark_with_constraint_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MARK_WITH_CONSTRAINT,"MARK_WITH_CONSTRAINT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(mark_with_constraint_AST)))); +#line 7174 "AdaParser.cpp" + currentAST.root = mark_with_constraint_AST; + if ( mark_with_constraint_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + mark_with_constraint_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = mark_with_constraint_AST->getFirstChild(); + else + currentAST.child = mark_with_constraint_AST; + currentAST.advanceChildToEnd(); + } + mark_with_constraint_AST = RefAdaAST(currentAST.root); + returnAST = mark_with_constraint_AST; +} + +void AdaParser::generic_formal_part_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST generic_formal_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case USE: + { + use_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case WITH: + case TYPE: + { + generic_formal_parameter(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop289; + } + } + } + _loop289:; + } // ( ... )* + if ( inputState->guessing==0 ) { + generic_formal_part_opt_AST = RefAdaAST(currentAST.root); +#line 885 "ada.g" + generic_formal_part_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(GENERIC_FORMAL_PART,"GENERIC_FORMAL_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(generic_formal_part_opt_AST)))); +#line 7234 "AdaParser.cpp" + currentAST.root = generic_formal_part_opt_AST; + if ( generic_formal_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + generic_formal_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = generic_formal_part_opt_AST->getFirstChild(); + else + currentAST.child = generic_formal_part_opt_AST; + currentAST.advanceChildToEnd(); + } + generic_formal_part_opt_AST = RefAdaAST(currentAST.root); + returnAST = generic_formal_part_opt_AST; +} + +void AdaParser::generic_formal_parameter() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST generic_formal_parameter_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case TYPE: + { + t = LT(1); + if ( inputState->guessing == 0 ) { + t_AST = astFactory->create(t); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST)); + } + match(TYPE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IS: + { + match(IS); + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + match(BOX); + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 895 "ada.g" + Set (t_AST, FORMAL_DISCRETE_TYPE_DECLARATION); +#line 7285 "AdaParser.cpp" + } + break; + } + case RANGE: + { + match(RANGE); + match(BOX); + if ( inputState->guessing==0 ) { +#line 897 "ada.g" + Set (t_AST, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION); +#line 7296 "AdaParser.cpp" + } + break; + } + case MOD: + { + match(MOD); + match(BOX); + if ( inputState->guessing==0 ) { +#line 899 "ada.g" + Set (t_AST, FORMAL_MODULAR_TYPE_DECLARATION); +#line 7307 "AdaParser.cpp" + } + break; + } + case DELTA: + { + match(DELTA); + match(BOX); + { + switch ( LA(1)) { + case DIGITS: + { + match(DIGITS); + match(BOX); + if ( inputState->guessing==0 ) { +#line 902 "ada.g" + Set (t_AST, FORMAL_DECIMAL_FIXED_POINT_DECLARATION); +#line 7324 "AdaParser.cpp" + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 903 "ada.g" + Set (t_AST, FORMAL_ORDINARY_FIXED_POINT_DECLARATION); +#line 7333 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case DIGITS: + { + match(DIGITS); + match(BOX); + if ( inputState->guessing==0 ) { +#line 906 "ada.g" + Set (t_AST, FORMAL_FLOATING_POINT_DECLARATION); +#line 7352 "AdaParser.cpp" + } + break; + } + case ARRAY: + { + array_type_definition(t_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ACCESS: + { + access_type_definition(t_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRIVATE: + case NEW: + case ABSTRACT: + case TAGGED: + case LIMITED: + { + empty_discrim_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discriminable_type_definition(t_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case LPAREN: + { + discrim_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + discriminable_type_definition(t_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 913 "ada.g" + pop_def_id(); +#line 7418 "AdaParser.cpp" + } + break; + } + case WITH: + { + w = LT(1); + if ( inputState->guessing == 0 ) { + w_AST = astFactory->create(w); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + } + match(WITH); + { + switch ( LA(1)) { + case PROCEDURE: + { + match(PROCEDURE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subprogram_default_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 915 "ada.g" + Set(w_AST, FORMAL_PROCEDURE_DECLARATION); +#line 7450 "AdaParser.cpp" + } + break; + } + case FUNCTION: + { + match(FUNCTION); + def_designator(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + subprogram_default_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 917 "ada.g" + Set(w_AST, FORMAL_FUNCTION_DECLARATION); +#line 7472 "AdaParser.cpp" + } + break; + } + case PACKAGE: + { + match(PACKAGE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + match(NEW); + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_package_actual_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 919 "ada.g" + Set(w_AST, FORMAL_PACKAGE_DECLARATION); +#line 7496 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 921 "ada.g" + pop_def_id(); +#line 7509 "AdaParser.cpp" + } + break; + } + case IDENTIFIER: + { + parameter_specification(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + generic_formal_parameter_AST = RefAdaAST(currentAST.root); + returnAST = generic_formal_parameter_AST; +} + +void AdaParser::discriminable_type_definition( + RefAdaAST t +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST discriminable_type_definition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + bool synPredMatched299 = false; + if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) { + int _m299 = mark(); + synPredMatched299 = true; + inputState->guessing++; + try { + { + { + switch ( LA(1)) { + case ABSTRACT: + { + match(ABSTRACT); + break; + } + case NEW: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(NEW); + subtype_ind(); + match(WITH); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched299 = false; + } + rewind(_m299); + inputState->guessing--; + } + if ( synPredMatched299 ) { + abstract_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(NEW); + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(WITH); + match(PRIVATE); + if ( inputState->guessing==0 ) { +#line 930 "ada.g" + Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION); +#line 7589 "AdaParser.cpp" + } + discriminable_type_definition_AST = RefAdaAST(currentAST.root); + } + else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) { + match(NEW); + subtype_ind(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 932 "ada.g" + Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION); +#line 7602 "AdaParser.cpp" + } + discriminable_type_definition_AST = RefAdaAST(currentAST.root); + } + else if ((_tokenSet_22.member(LA(1))) && (_tokenSet_23.member(LA(2)))) { + abstract_tagged_limited_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(PRIVATE); + if ( inputState->guessing==0 ) { +#line 934 "ada.g" + Set (t, FORMAL_PRIVATE_TYPE_DECLARATION); +#line 7615 "AdaParser.cpp" + } + discriminable_type_definition_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = discriminable_type_definition_AST; +} + +void AdaParser::subprogram_default_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subprogram_default_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IS: + { + match(IS); + { + switch ( LA(1)) { + case BOX: + { + RefAdaAST tmp253_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp253_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp253_AST)); + } + match(BOX); + break; + } + case IDENTIFIER: + { + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + subprogram_default_opt_AST = RefAdaAST(currentAST.root); + returnAST = subprogram_default_opt_AST; +} + +void AdaParser::formal_package_actual_part_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST formal_package_actual_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LPAREN: + { + match(LPAREN); + { + switch ( LA(1)) { + case BOX: + { + RefAdaAST tmp255_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp255_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp255_AST)); + } + match(BOX); + break; + } + case IDENTIFIER: + { + defining_identifier_list(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(RPAREN); + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + formal_package_actual_part_opt_AST = RefAdaAST(currentAST.root); + returnAST = formal_package_actual_part_opt_AST; +} + +void AdaParser::body_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST body_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + declarative_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + block_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + body_part_AST = RefAdaAST(currentAST.root); + returnAST = body_part_AST; +} + +void AdaParser::declarative_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST declarative_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + { + declarative_item(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop316; + } + } + } + _loop316:; + } // ( ... )* + if ( inputState->guessing==0 ) { + declarative_part_AST = RefAdaAST(currentAST.root); +#line 978 "ada.g" + declarative_part_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARATIVE_PART,"DECLARATIVE_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(declarative_part_AST)))); +#line 7799 "AdaParser.cpp" + currentAST.root = declarative_part_AST; + if ( declarative_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + declarative_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = declarative_part_AST->getFirstChild(); + else + currentAST.child = declarative_part_AST; + currentAST.advanceChildToEnd(); + } + declarative_part_AST = RefAdaAST(currentAST.root); + returnAST = declarative_part_AST; +} + +void AdaParser::block_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST block_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken b = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST b_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + b = LT(1); + if ( inputState->guessing == 0 ) { + b_AST = astFactory->create(b); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(b_AST)); + } + match(BEGIN); + handled_stmt_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1058 "ada.g" + Set(b_AST, BLOCK_BODY); +#line 7832 "AdaParser.cpp" + } + block_body_AST = RefAdaAST(currentAST.root); + returnAST = block_body_AST; +} + +void AdaParser::declarative_item() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST declarative_item_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST pkg_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken tsk = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST tsk_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken pro = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST pro_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PACKAGE: + { + pkg = LT(1); + if ( inputState->guessing == 0 ) { + pkg_AST = astFactory->create(pkg); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pkg_AST)); + } + match(PACKAGE); + { + switch ( LA(1)) { + case BODY: + { + body_is(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case SEPARATE: + { + separate(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 986 "ada.g" + Set(pkg_AST, PACKAGE_BODY_STUB); +#line 7878 "AdaParser.cpp" + } + break; + } + case PRAGMA: + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case END: + case SUBTYPE: + case GENERIC: + case BEGIN: + { + pkg_body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 988 "ada.g" + Set(pkg_AST, PACKAGE_BODY); +#line 7904 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + break; + } + case IDENTIFIER: + { + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + spec_decl_part(pkg_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case TASK: + { + tsk = LT(1); + if ( inputState->guessing == 0 ) { + tsk_AST = astFactory->create(tsk); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tsk_AST)); + } + match(TASK); + { + switch ( LA(1)) { + case BODY: + { + body_is(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case SEPARATE: + { + separate(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 994 "ada.g" + Set(tsk_AST, TASK_BODY_STUB); +#line 7964 "AdaParser.cpp" + } + break; + } + case PRAGMA: + case IDENTIFIER: + case USE: + case TYPE: + case PACKAGE: + case PROCEDURE: + case FUNCTION: + case TASK: + case PROTECTED: + case FOR: + case SUBTYPE: + case GENERIC: + case BEGIN: + { + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 995 "ada.g" + Set(tsk_AST, TASK_BODY); +#line 7989 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + break; + } + case IDENTIFIER: + case TYPE: + { + task_type_or_single_decl(tsk_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case PROTECTED: + { + pro = LT(1); + if ( inputState->guessing == 0 ) { + pro_AST = astFactory->create(pro); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(pro_AST)); + } + match(PROTECTED); + { + switch ( LA(1)) { + case BODY: + { + body_is(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case SEPARATE: + { + separate(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1002 "ada.g" + Set(pro_AST, PROTECTED_BODY_STUB); +#line 8046 "AdaParser.cpp" + } + break; + } + case PRAGMA: + case PROCEDURE: + case FUNCTION: + case ENTRY: + case END: + { + prot_op_bodies_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1004 "ada.g" + Set(pro_AST, PROTECTED_BODY); +#line 8067 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case IDENTIFIER: + case TYPE: + { + prot_type_or_single_decl(pro_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + break; + } + case PROCEDURE: + case FUNCTION: + { + subprog_decl_or_rename_or_inst_or_body(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case USE: + case TYPE: + case FOR: + case SUBTYPE: + case GENERIC: + { + decl_common(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + declarative_item_AST = RefAdaAST(currentAST.root); + returnAST = declarative_item_AST; +} + +void AdaParser::body_is() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST body_is_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(BODY); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + body_is_AST = RefAdaAST(currentAST.root); + returnAST = body_is_AST; +} + +void AdaParser::separate() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST separate_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(SEPARATE); + if ( inputState->guessing==0 ) { +#line 1023 "ada.g" + pop_def_id(); +#line 8153 "AdaParser.cpp" + } + separate_AST = RefAdaAST(currentAST.root); + returnAST = separate_AST; +} + +void AdaParser::prot_op_bodies_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST prot_op_bodies_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case ENTRY: + { + entry_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PROCEDURE: + case FUNCTION: + { + subprog_decl_or_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop332; + } + } + } + _loop332:; + } // ( ... )* + if ( inputState->guessing==0 ) { + prot_op_bodies_opt_AST = RefAdaAST(currentAST.root); +#line 1039 "ada.g" + prot_op_bodies_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(PROT_OP_BODIES_OPT,"PROT_OP_BODIES_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(prot_op_bodies_opt_AST)))); +#line 8205 "AdaParser.cpp" + currentAST.root = prot_op_bodies_opt_AST; + if ( prot_op_bodies_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + prot_op_bodies_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = prot_op_bodies_opt_AST->getFirstChild(); + else + currentAST.child = prot_op_bodies_opt_AST; + currentAST.advanceChildToEnd(); + } + prot_op_bodies_opt_AST = RefAdaAST(currentAST.root); + returnAST = prot_op_bodies_opt_AST; +} + +void AdaParser::block_body_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST block_body_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case BEGIN: + { + match(BEGIN); + handled_stmt_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + block_body_opt_AST = RefAdaAST(currentAST.root); +#line 1030 "ada.g" + block_body_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK_BODY_OPT,"BLOCK_BODY_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_body_opt_AST)))); +#line 8249 "AdaParser.cpp" + currentAST.root = block_body_opt_AST; + if ( block_body_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + block_body_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = block_body_opt_AST->getFirstChild(); + else + currentAST.child = block_body_opt_AST; + currentAST.advanceChildToEnd(); + } + block_body_opt_AST = RefAdaAST(currentAST.root); + returnAST = block_body_opt_AST; +} + +void AdaParser::handled_stmt_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST handled_stmt_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + except_handler_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + handled_stmt_s_AST = RefAdaAST(currentAST.root); +#line 1062 "ada.g" + handled_stmt_s_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(HANDLED_SEQUENCE_OF_STATEMENTS,"HANDLED_SEQUENCE_OF_STATEMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(handled_stmt_s_AST)))); +#line 8280 "AdaParser.cpp" + currentAST.root = handled_stmt_s_AST; + if ( handled_stmt_s_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + handled_stmt_s_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = handled_stmt_s_AST->getFirstChild(); + else + currentAST.child = handled_stmt_s_AST; + currentAST.advanceChildToEnd(); + } + handled_stmt_s_AST = RefAdaAST(currentAST.root); + returnAST = handled_stmt_s_AST; +} + +void AdaParser::entry_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST e_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + e = LT(1); + if ( inputState->guessing == 0 ) { + e_AST = astFactory->create(e); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(e_AST)); + } + match(ENTRY); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + entry_body_formal_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + entry_barrier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1236 "ada.g" + Set (e_AST, ENTRY_BODY); +#line 8327 "AdaParser.cpp" + } + entry_body_AST = RefAdaAST(currentAST.root); + returnAST = entry_body_AST; +} + +void AdaParser::subprog_decl_or_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subprog_decl_or_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case PROCEDURE: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PROCEDURE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IS: + { + match(IS); + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1046 "ada.g" + Set(p_AST, PROCEDURE_BODY); +#line 8371 "AdaParser.cpp" + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 1047 "ada.g" + pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION); +#line 8380 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + subprog_decl_or_body_AST = RefAdaAST(currentAST.root); + break; + } + case FUNCTION: + { + f = LT(1); + if ( inputState->guessing == 0 ) { + f_AST = astFactory->create(f); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + } + match(FUNCTION); + def_designator(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IS: + { + match(IS); + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1051 "ada.g" + Set(f_AST, FUNCTION_BODY); +#line 8422 "AdaParser.cpp" + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 1052 "ada.g" + pop_def_id(); Set(f_AST, FUNCTION_DECLARATION); +#line 8431 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + subprog_decl_or_body_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = subprog_decl_or_body_AST; +} + +void AdaParser::statements() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST statements_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )+ + int _cnt342=0; + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case NuLL: + case RETURN: + case FOR: + case CASE: + case BEGIN: + case LT_LT: + case IF: + case LOOP: + case WHILE: + case DECLARE: + case EXIT: + case GOTO: + case ACCEPT: + case DELAY: + case SELECT: + case ABORT: + case RAISE: + case REQUEUE: + { + statement(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + if ( _cnt342>=1 ) { goto _loop342; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + } + _cnt342++; + } + _loop342:; + } // ( ... )+ + if ( inputState->guessing==0 ) { + statements_AST = RefAdaAST(currentAST.root); +#line 1074 "ada.g" + statements_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(SEQUENCE_OF_STATEMENTS,"SEQUENCE_OF_STATEMENTS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(statements_AST)))); +#line 8509 "AdaParser.cpp" + currentAST.root = statements_AST; + if ( statements_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + statements_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = statements_AST->getFirstChild(); + else + currentAST.child = statements_AST; + currentAST.advanceChildToEnd(); + } + statements_AST = RefAdaAST(currentAST.root); + returnAST = statements_AST; +} + +void AdaParser::except_handler_part_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST except_handler_part_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case EXCEPTION: + { + match(EXCEPTION); + { // ( ... )+ + int _cnt429=0; + for (;;) { + if ((LA(1) == WHEN)) { + exception_handler(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + if ( _cnt429>=1 ) { goto _loop429; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt429++; + } + _loop429:; + } // ( ... )+ + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + except_handler_part_opt_AST = RefAdaAST(currentAST.root); +#line 1365 "ada.g" + except_handler_part_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(EXCEPT_HANDLER_PART_OPT,"EXCEPT_HANDLER_PART_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(except_handler_part_opt_AST)))); +#line 8566 "AdaParser.cpp" + currentAST.root = except_handler_part_opt_AST; + if ( except_handler_part_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + except_handler_part_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = except_handler_part_opt_AST->getFirstChild(); + else + currentAST.child = except_handler_part_opt_AST; + currentAST.advanceChildToEnd(); + } + except_handler_part_opt_AST = RefAdaAST(currentAST.root); + returnAST = except_handler_part_opt_AST; +} + +void AdaParser::handled_stmts_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST handled_stmts_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case PRAGMA: + case IDENTIFIER: + case NuLL: + case RETURN: + case FOR: + case CASE: + case BEGIN: + case LT_LT: + case IF: + case LOOP: + case WHILE: + case DECLARE: + case EXIT: + case GOTO: + case ACCEPT: + case DELAY: + case SELECT: + case ABORT: + case RAISE: + case REQUEUE: + { + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + except_handler_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + handled_stmts_opt_AST = RefAdaAST(currentAST.root); +#line 1068 "ada.g" + handled_stmts_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(HANDLED_STMTS_OPT,"HANDLED_STMTS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(handled_stmts_opt_AST)))); +#line 8632 "AdaParser.cpp" + currentAST.root = handled_stmts_opt_AST; + if ( handled_stmts_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + handled_stmts_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = handled_stmts_opt_AST->getFirstChild(); + else + currentAST.child = handled_stmts_opt_AST; + currentAST.advanceChildToEnd(); + } + handled_stmts_opt_AST = RefAdaAST(currentAST.root); + returnAST = handled_stmts_opt_AST; +} + +void AdaParser::statement() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST statement_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + def_label_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case NuLL: + { + null_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case EXIT: + { + exit_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case RETURN: + { + return_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case GOTO: + { + goto_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case DELAY: + { + delay_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ABORT: + { + abort_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case RAISE: + { + raise_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case REQUEUE: + { + requeue_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ACCEPT: + { + accept_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SELECT: + { + select_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IF: + { + if_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case CASE: + { + case_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + case LOOP: + case WHILE: + { + loop_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + break; + } + case BEGIN: + case DECLARE: + { + block(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(SEMI); + break; + } + default: + if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) { + statement_identifier(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case FOR: + case LOOP: + case WHILE: + { + loop_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + break; + } + case BEGIN: + case DECLARE: + { + block(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + } + else if ((LA(1) == IDENTIFIER) && (_tokenSet_24.member(LA(2)))) { + call_or_assignment(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + statement_AST = RefAdaAST(currentAST.root); +#line 1100 "ada.g" + statement_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(STATEMENT,"STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(statement_AST)))); +#line 8833 "AdaParser.cpp" + currentAST.root = statement_AST; + if ( statement_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + statement_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = statement_AST->getFirstChild(); + else + currentAST.child = statement_AST; + currentAST.advanceChildToEnd(); + } + statement_AST = RefAdaAST(currentAST.root); + returnAST = statement_AST; +} + +void AdaParser::def_label_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST def_label_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case LT_LT: + { + match(LT_LT); + RefAdaAST tmp277_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp277_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp277_AST)); + } + match(IDENTIFIER); + match(GT_GT); + break; + } + case IDENTIFIER: + case NuLL: + case RETURN: + case FOR: + case CASE: + case BEGIN: + case IF: + case LOOP: + case WHILE: + case DECLARE: + case EXIT: + case GOTO: + case ACCEPT: + case DELAY: + case SELECT: + case ABORT: + case RAISE: + case REQUEUE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + def_label_opt_AST = RefAdaAST(currentAST.root); +#line 1104 "ada.g" + def_label_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(LABEL_OPT,"LABEL_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(def_label_opt_AST)))); +#line 8896 "AdaParser.cpp" + currentAST.root = def_label_opt_AST; + if ( def_label_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + def_label_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = def_label_opt_AST->getFirstChild(); + else + currentAST.child = def_label_opt_AST; + currentAST.advanceChildToEnd(); + } + def_label_opt_AST = RefAdaAST(currentAST.root); + returnAST = def_label_opt_AST; +} + +void AdaParser::null_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST null_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(NuLL); + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1108 "ada.g" + Set(s_AST, NULL_STATEMENT); +#line 8926 "AdaParser.cpp" + } + null_stmt_AST = RefAdaAST(currentAST.root); + returnAST = null_stmt_AST; +} + +void AdaParser::exit_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST exit_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(EXIT); + { + switch ( LA(1)) { + case IDENTIFIER: + { + label_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case WHEN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + { + switch ( LA(1)) { + case WHEN: + { + RefAdaAST tmp280_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp280_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp280_AST)); + } + match(WHEN); + condition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1206 "ada.g" + Set(s_AST, EXIT_STATEMENT); +#line 8996 "AdaParser.cpp" + } + exit_stmt_AST = RefAdaAST(currentAST.root); + returnAST = exit_stmt_AST; +} + +void AdaParser::return_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST return_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(RETURN); + { + switch ( LA(1)) { + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1213 "ada.g" + Set(s_AST, RETURN_STATEMENT); +#line 9049 "AdaParser.cpp" + } + return_stmt_AST = RefAdaAST(currentAST.root); + returnAST = return_stmt_AST; +} + +void AdaParser::goto_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST goto_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(GOTO); + label_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1217 "ada.g" + Set(s_AST, GOTO_STATEMENT); +#line 9076 "AdaParser.cpp" + } + goto_stmt_AST = RefAdaAST(currentAST.root); + returnAST = goto_stmt_AST; +} + +void AdaParser::delay_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST delay_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST d_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + d = LT(1); + if ( inputState->guessing == 0 ) { + d_AST = astFactory->create(d); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(d_AST)); + } + match(DELAY); + until_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1282 "ada.g" + Set (d_AST, DELAY_STATEMENT); +#line 9107 "AdaParser.cpp" + } + delay_stmt_AST = RefAdaAST(currentAST.root); + returnAST = delay_stmt_AST; +} + +void AdaParser::abort_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST abort_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + a = LT(1); + if ( inputState->guessing == 0 ) { + a_AST = astFactory->create(a); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + } + match(ABORT); + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == COMMA)) { + match(COMMA); + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop425; + } + + } + _loop425:; + } // ( ... )* + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1361 "ada.g" + Set (a_AST, ABORT_STATEMENT); +#line 9150 "AdaParser.cpp" + } + abort_stmt_AST = RefAdaAST(currentAST.root); + returnAST = abort_stmt_AST; +} + +void AdaParser::raise_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST raise_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + r = LT(1); + if ( inputState->guessing == 0 ) { + r_AST = astFactory->create(r); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + } + match(RAISE); + { + switch ( LA(1)) { + case IDENTIFIER: + { + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1389 "ada.g" + Set (r_AST, RAISE_STATEMENT); +#line 9193 "AdaParser.cpp" + } + raise_stmt_AST = RefAdaAST(currentAST.root); + returnAST = raise_stmt_AST; +} + +void AdaParser::requeue_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST requeue_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST r_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + r = LT(1); + if ( inputState->guessing == 0 ) { + r_AST = astFactory->create(r); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(r_AST)); + } + match(REQUEUE); + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case WITH: + { + match(WITH); + RefAdaAST tmp289_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp289_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp289_AST)); + } + match(ABORT); + break; + } + case SEMI: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1393 "ada.g" + Set (r_AST, REQUEUE_STATEMENT); +#line 9243 "AdaParser.cpp" + } + requeue_stmt_AST = RefAdaAST(currentAST.root); + returnAST = requeue_stmt_AST; +} + +void AdaParser::accept_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST accept_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST a_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + a = LT(1); + if ( inputState->guessing == 0 ) { + a_AST = astFactory->create(a); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(a_AST)); + } + match(ACCEPT); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + entry_index_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case DO: + { + match(DO); + handled_stmts_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + break; + } + case SEMI: + { + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1264 "ada.g" + pop_def_id(); +#line 9296 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 1266 "ada.g" + Set (a_AST, ACCEPT_STATEMENT); +#line 9309 "AdaParser.cpp" + } + accept_stmt_AST = RefAdaAST(currentAST.root); + returnAST = accept_stmt_AST; +} + +void AdaParser::select_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST select_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(SELECT); + { + bool synPredMatched403 = false; + if (((LA(1) == IDENTIFIER || LA(1) == DELAY) && (_tokenSet_25.member(LA(2))))) { + int _m403 = mark(); + synPredMatched403 = true; + inputState->guessing++; + try { + { + triggering_alternative(); + match(THEN); + match(ABORT); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched403 = false; + } + rewind(_m403); + inputState->guessing--; + } + if ( synPredMatched403 ) { + triggering_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(THEN); + match(ABORT); + abortable_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1297 "ada.g" + Set (s_AST, ASYNCHRONOUS_SELECT); +#line 9361 "AdaParser.cpp" + } + } + else if ((_tokenSet_26.member(LA(1))) && (_tokenSet_27.member(LA(2)))) { + selective_accept(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1299 "ada.g" + Set (s_AST, SELECTIVE_ACCEPT); +#line 9372 "AdaParser.cpp" + } + } + else if ((LA(1) == IDENTIFIER) && (_tokenSet_28.member(LA(2)))) { + entry_call_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case OR: + { + match(OR); + delay_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1301 "ada.g" + Set (s_AST, TIMED_ENTRY_CALL); +#line 9392 "AdaParser.cpp" + } + break; + } + case ELSE: + { + match(ELSE); + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1302 "ada.g" + Set (s_AST, CONDITIONAL_ENTRY_CALL); +#line 9406 "AdaParser.cpp" + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + match(END); + match(SELECT); + match(SEMI); + select_stmt_AST = RefAdaAST(currentAST.root); + returnAST = select_stmt_AST; +} + +void AdaParser::if_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST if_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(IF); + cond_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + elsifs_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(IF); + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1114 "ada.g" + Set(s_AST, IF_STATEMENT); +#line 9460 "AdaParser.cpp" + } + if_stmt_AST = RefAdaAST(currentAST.root); + returnAST = if_stmt_AST; +} + +void AdaParser::case_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST case_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(CASE); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + alternative_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(CASE); + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1134 "ada.g" + Set(s_AST, CASE_STATEMENT); +#line 9494 "AdaParser.cpp" + } + case_stmt_AST = RefAdaAST(currentAST.root); + returnAST = case_stmt_AST; +} + +void AdaParser::loop_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST loop_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken l = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST l_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + iteration_scheme_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + l = LT(1); + if ( inputState->guessing == 0 ) { + l_AST = astFactory->create(l); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(l_AST)); + } + match(LOOP); + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(END); + match(LOOP); + if ( inputState->guessing==0 ) { +#line 1146 "ada.g" + Set(l_AST, LOOP_STATEMENT); +#line 9526 "AdaParser.cpp" + } + loop_stmt_AST = RefAdaAST(currentAST.root); + returnAST = loop_stmt_AST; +} + +void AdaParser::block() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST block_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + declare_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + block_body(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + block_AST = RefAdaAST(currentAST.root); +#line 1198 "ada.g" + block_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(BLOCK_STATEMENT,"BLOCK_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(block_AST)))); +#line 9549 "AdaParser.cpp" + currentAST.root = block_AST; + if ( block_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + block_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = block_AST->getFirstChild(); + else + currentAST.child = block_AST; + currentAST.advanceChildToEnd(); + } + block_AST = RefAdaAST(currentAST.root); + returnAST = block_AST; +} + +void AdaParser::statement_identifier() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST statement_identifier_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + n = LT(1); + if ( inputState->guessing == 0 ) { + n_AST = astFactory->create(n); + } + match(IDENTIFIER); + match(COLON); + if ( inputState->guessing==0 ) { +#line 1186 "ada.g" + push_def_id(n_AST); +#line 9578 "AdaParser.cpp" + } + returnAST = statement_identifier_AST; +} + +void AdaParser::id_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST id_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + id_opt_aux(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + id_opt_AST = RefAdaAST(currentAST.root); +#line 1172 "ada.g" + id_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ID_OPT,"ID_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_opt_AST)))); +#line 9596 "AdaParser.cpp" + currentAST.root = id_opt_AST; + if ( id_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + id_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = id_opt_AST->getFirstChild(); + else + currentAST.child = id_opt_AST; + currentAST.advanceChildToEnd(); + } + id_opt_AST = RefAdaAST(currentAST.root); + returnAST = id_opt_AST; +} + +void AdaParser::call_or_assignment() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST call_or_assignment_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case ASSIGN: + { + match(ASSIGN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + call_or_assignment_AST = RefAdaAST(currentAST.root); +#line 1222 "ada.g" + call_or_assignment_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ASSIGNMENT_STATEMENT,"ASSIGNMENT_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(call_or_assignment_AST)))); +#line 9632 "AdaParser.cpp" + currentAST.root = call_or_assignment_AST; + if ( call_or_assignment_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + call_or_assignment_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = call_or_assignment_AST->getFirstChild(); + else + currentAST.child = call_or_assignment_AST; + currentAST.advanceChildToEnd(); + } + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { + call_or_assignment_AST = RefAdaAST(currentAST.root); +#line 1225 "ada.g" + call_or_assignment_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CALL_STATEMENT,"CALL_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(call_or_assignment_AST)))); +#line 9650 "AdaParser.cpp" + currentAST.root = call_or_assignment_AST; + if ( call_or_assignment_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + call_or_assignment_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = call_or_assignment_AST->getFirstChild(); + else + currentAST.child = call_or_assignment_AST; + currentAST.advanceChildToEnd(); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + match(SEMI); + call_or_assignment_AST = RefAdaAST(currentAST.root); + returnAST = call_or_assignment_AST; +} + +void AdaParser::cond_clause() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST cond_clause_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST c_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + condition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + c = LT(1); + if ( inputState->guessing == 0 ) { + c_AST = astFactory->create(c); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST)); + } + match(THEN); + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1118 "ada.g" + Set(c_AST, COND_CLAUSE); +#line 9696 "AdaParser.cpp" + } + cond_clause_AST = RefAdaAST(currentAST.root); + returnAST = cond_clause_AST; +} + +void AdaParser::elsifs_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST elsifs_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((LA(1) == ELSIF)) { + match(ELSIF); + cond_clause(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop354; + } + + } + _loop354:; + } // ( ... )* + if ( inputState->guessing==0 ) { + elsifs_opt_AST = RefAdaAST(currentAST.root); +#line 1126 "ada.g" + elsifs_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELSIFS_OPT,"ELSIFS_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(elsifs_opt_AST)))); +#line 9727 "AdaParser.cpp" + currentAST.root = elsifs_opt_AST; + if ( elsifs_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + elsifs_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = elsifs_opt_AST->getFirstChild(); + else + currentAST.child = elsifs_opt_AST; + currentAST.advanceChildToEnd(); + } + elsifs_opt_AST = RefAdaAST(currentAST.root); + returnAST = elsifs_opt_AST; +} + +void AdaParser::else_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST else_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case ELSE: + { + match(ELSE); + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case END: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + else_opt_AST = RefAdaAST(currentAST.root); +#line 1130 "ada.g" + else_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ELSE_OPT,"ELSE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(else_opt_AST)))); +#line 9770 "AdaParser.cpp" + currentAST.root = else_opt_AST; + if ( else_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + else_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = else_opt_AST->getFirstChild(); + else + currentAST.child = else_opt_AST; + currentAST.advanceChildToEnd(); + } + else_opt_AST = RefAdaAST(currentAST.root); + returnAST = else_opt_AST; +} + +void AdaParser::condition() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST condition_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + condition_AST = RefAdaAST(currentAST.root); + returnAST = condition_AST; +} + +void AdaParser::alternative_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST alternative_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )+ + int _cnt360=0; + for (;;) { + if ((LA(1) == WHEN)) { + case_statement_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + if ( _cnt360>=1 ) { goto _loop360; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} + } + + _cnt360++; + } + _loop360:; + } // ( ... )+ + alternative_s_AST = RefAdaAST(currentAST.root); + returnAST = alternative_s_AST; +} + +void AdaParser::case_statement_alternative() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST case_statement_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + s = LT(1); + if ( inputState->guessing == 0 ) { + s_AST = astFactory->create(s); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST)); + } + match(WHEN); + choice_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RIGHT_SHAFT); + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1141 "ada.g" + Set(s_AST, CASE_STATEMENT_ALTERNATIVE); +#line 9847 "AdaParser.cpp" + } + case_statement_alternative_AST = RefAdaAST(currentAST.root); + returnAST = case_statement_alternative_AST; +} + +void AdaParser::iteration_scheme_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST iteration_scheme_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case WHILE: + { + RefAdaAST tmp316_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp316_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp316_AST)); + } + match(WHILE); + condition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case FOR: + { + RefAdaAST tmp317_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp317_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp317_AST)); + } + match(FOR); + RefAdaAST tmp318_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp318_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp318_AST)); + } + match(IDENTIFIER); + match(IN); + reverse_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + discrete_subtype_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LOOP: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + iteration_scheme_opt_AST = RefAdaAST(currentAST.root); +#line 1152 "ada.g" + iteration_scheme_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ITERATION_SCHEME_OPT,"ITERATION_SCHEME_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(iteration_scheme_opt_AST)))); +#line 9914 "AdaParser.cpp" + currentAST.root = iteration_scheme_opt_AST; + if ( iteration_scheme_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + iteration_scheme_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = iteration_scheme_opt_AST->getFirstChild(); + else + currentAST.child = iteration_scheme_opt_AST; + currentAST.advanceChildToEnd(); + } + iteration_scheme_opt_AST = RefAdaAST(currentAST.root); + returnAST = iteration_scheme_opt_AST; +} + +void AdaParser::reverse_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST reverse_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case REVERSE: + { + RefAdaAST tmp320_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp320_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp320_AST)); + } + match(REVERSE); + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + reverse_opt_AST = RefAdaAST(currentAST.root); +#line 1158 "ada.g" + reverse_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(reverse_opt_AST)))); +#line 9968 "AdaParser.cpp" + currentAST.root = reverse_opt_AST; + if ( reverse_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + reverse_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = reverse_opt_AST->getFirstChild(); + else + currentAST.child = reverse_opt_AST; + currentAST.advanceChildToEnd(); + } + reverse_opt_AST = RefAdaAST(currentAST.root); + returnAST = reverse_opt_AST; +} + +void AdaParser::id_opt_aux() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST id_opt_aux_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1161 "ada.g" + RefAdaAST endid; +#line 9988 "AdaParser.cpp" + + switch ( LA(1)) { + case CHAR_STRING: + { + endid=definable_operator_symbol(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if (!( end_id_matches_def_id (endid) )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (endid) "); + id_opt_aux_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + { + compound_name(); + if (inputState->guessing==0) { + n_AST = returnAST; + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if (!( end_id_matches_def_id (n_AST) )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (n_AST) "); + id_opt_aux_AST = RefAdaAST(currentAST.root); + break; + } + case SEMI: + { + if ( inputState->guessing==0 ) { +#line 1168 "ada.g" + pop_def_id(); +#line 10019 "AdaParser.cpp" + } + id_opt_aux_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = id_opt_aux_AST; +} + +void AdaParser::declare_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST declare_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case DECLARE: + { + match(DECLARE); + declarative_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case BEGIN: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + declare_opt_AST = RefAdaAST(currentAST.root); +#line 1202 "ada.g" + declare_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DECLARE_OPT,"DECLARE_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(declare_opt_AST)))); +#line 10062 "AdaParser.cpp" + currentAST.root = declare_opt_AST; + if ( declare_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + declare_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = declare_opt_AST->getFirstChild(); + else + currentAST.child = declare_opt_AST; + currentAST.advanceChildToEnd(); + } + declare_opt_AST = RefAdaAST(currentAST.root); + returnAST = declare_opt_AST; +} + +void AdaParser::label_name() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST label_name_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + RefAdaAST tmp322_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp322_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp322_AST)); + } + match(IDENTIFIER); + label_name_AST = RefAdaAST(currentAST.root); + returnAST = label_name_AST; +} + +void AdaParser::entry_body_formal_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_body_formal_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + entry_index_spec_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + entry_body_formal_part_AST = RefAdaAST(currentAST.root); + returnAST = entry_body_formal_part_AST; +} + +void AdaParser::entry_barrier() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_barrier_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(WHEN); + condition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + entry_barrier_AST = RefAdaAST(currentAST.root); + returnAST = entry_barrier_AST; +} + +void AdaParser::entry_index_spec_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_index_spec_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + bool synPredMatched388 = false; + if (((LA(1) == LPAREN) && (LA(2) == FOR))) { + int _m388 = mark(); + synPredMatched388 = true; + inputState->guessing++; + try { + { + match(LPAREN); + match(FOR); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched388 = false; + } + rewind(_m388); + inputState->guessing--; + } + if ( synPredMatched388 ) { + match(LPAREN); + match(FOR); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IN); + discrete_subtype_definition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + } + else if ((LA(1) == LPAREN || LA(1) == WHEN) && (_tokenSet_0.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + entry_index_spec_opt_AST = RefAdaAST(currentAST.root); +#line 1247 "ada.g" + entry_index_spec_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_INDEX_SPECIFICATION,"ENTRY_INDEX_SPECIFICATION")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_index_spec_opt_AST)))); +#line 10170 "AdaParser.cpp" + currentAST.root = entry_index_spec_opt_AST; + if ( entry_index_spec_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + entry_index_spec_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = entry_index_spec_opt_AST->getFirstChild(); + else + currentAST.child = entry_index_spec_opt_AST; + currentAST.advanceChildToEnd(); + } + entry_index_spec_opt_AST = RefAdaAST(currentAST.root); + returnAST = entry_index_spec_opt_AST; +} + +void AdaParser::entry_call_stmt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_call_stmt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { + entry_call_stmt_AST = RefAdaAST(currentAST.root); +#line 1257 "ada.g" + entry_call_stmt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_CALL_STATEMENT,"ENTRY_CALL_STATEMENT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_call_stmt_AST)))); +#line 10198 "AdaParser.cpp" + currentAST.root = entry_call_stmt_AST; + if ( entry_call_stmt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + entry_call_stmt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = entry_call_stmt_AST->getFirstChild(); + else + currentAST.child = entry_call_stmt_AST; + currentAST.advanceChildToEnd(); + } + entry_call_stmt_AST = RefAdaAST(currentAST.root); + returnAST = entry_call_stmt_AST; +} + +void AdaParser::entry_index_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_index_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + bool synPredMatched396 = false; + if (((LA(1) == LPAREN) && (_tokenSet_0.member(LA(2))))) { + int _m396 = mark(); + synPredMatched396 = true; + inputState->guessing++; + try { + { + match(LPAREN); + expression(); + match(RPAREN); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched396 = false; + } + rewind(_m396); + inputState->guessing--; + } + if ( synPredMatched396 ) { + match(LPAREN); + expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + } + else if ((LA(1) == SEMI || LA(1) == LPAREN || LA(1) == DO) && (_tokenSet_29.member(LA(2)))) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + entry_index_opt_AST = RefAdaAST(currentAST.root); +#line 1276 "ada.g" + entry_index_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_INDEX_OPT,"ENTRY_INDEX_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_index_opt_AST)))); +#line 10255 "AdaParser.cpp" + currentAST.root = entry_index_opt_AST; + if ( entry_index_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + entry_index_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = entry_index_opt_AST->getFirstChild(); + else + currentAST.child = entry_index_opt_AST; + currentAST.advanceChildToEnd(); + } + entry_index_opt_AST = RefAdaAST(currentAST.root); + returnAST = entry_index_opt_AST; +} + +void AdaParser::until_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST until_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case UNTIL: + { + RefAdaAST tmp331_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp331_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp331_AST)); + } + match(UNTIL); + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case PLUS: + case MINUS: + case ABS: + case NUMERIC_LIT: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { + until_opt_AST = RefAdaAST(currentAST.root); +#line 1286 "ada.g" + until_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(MODIFIERS,"MODIFIERS")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(until_opt_AST)))); +#line 10309 "AdaParser.cpp" + currentAST.root = until_opt_AST; + if ( until_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + until_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = until_opt_AST->getFirstChild(); + else + currentAST.child = until_opt_AST; + currentAST.advanceChildToEnd(); + } + until_opt_AST = RefAdaAST(currentAST.root); + returnAST = until_opt_AST; +} + +void AdaParser::triggering_alternative() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST triggering_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case DELAY: + { + delay_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + { + entry_call_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + stmts_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + triggering_alternative_AST = RefAdaAST(currentAST.root); +#line 1310 "ada.g" + triggering_alternative_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(TRIGGERING_ALTERNATIVE,"TRIGGERING_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(triggering_alternative_AST)))); +#line 10360 "AdaParser.cpp" + currentAST.root = triggering_alternative_AST; + if ( triggering_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + triggering_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = triggering_alternative_AST->getFirstChild(); + else + currentAST.child = triggering_alternative_AST; + currentAST.advanceChildToEnd(); + } + triggering_alternative_AST = RefAdaAST(currentAST.root); + returnAST = triggering_alternative_AST; +} + +void AdaParser::abortable_part() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST abortable_part_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + stmts_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + abortable_part_AST = RefAdaAST(currentAST.root); +#line 1316 "ada.g" + abortable_part_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ABORTABLE_PART,"ABORTABLE_PART")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(abortable_part_AST)))); +#line 10387 "AdaParser.cpp" + currentAST.root = abortable_part_AST; + if ( abortable_part_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + abortable_part_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = abortable_part_AST->getFirstChild(); + else + currentAST.child = abortable_part_AST; + currentAST.advanceChildToEnd(); + } + abortable_part_AST = RefAdaAST(currentAST.root); + returnAST = abortable_part_AST; +} + +void AdaParser::selective_accept() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST selective_accept_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + guard_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + select_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + or_select_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + else_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + selective_accept_AST = RefAdaAST(currentAST.root); + returnAST = selective_accept_AST; +} + +void AdaParser::entry_call_alternative() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST entry_call_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + entry_call_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + stmts_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + entry_call_alternative_AST = RefAdaAST(currentAST.root); +#line 1322 "ada.g" + entry_call_alternative_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ENTRY_CALL_ALTERNATIVE,"ENTRY_CALL_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(entry_call_alternative_AST)))); +#line 10443 "AdaParser.cpp" + currentAST.root = entry_call_alternative_AST; + if ( entry_call_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + entry_call_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = entry_call_alternative_AST->getFirstChild(); + else + currentAST.child = entry_call_alternative_AST; + currentAST.advanceChildToEnd(); + } + entry_call_alternative_AST = RefAdaAST(currentAST.root); + returnAST = entry_call_alternative_AST; +} + +void AdaParser::delay_alternative() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST delay_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + delay_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + stmts_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + delay_alternative_AST = RefAdaAST(currentAST.root); +#line 1347 "ada.g" + delay_alternative_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(DELAY_ALTERNATIVE,"DELAY_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(delay_alternative_AST)))); +#line 10474 "AdaParser.cpp" + currentAST.root = delay_alternative_AST; + if ( delay_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + delay_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = delay_alternative_AST->getFirstChild(); + else + currentAST.child = delay_alternative_AST; + currentAST.advanceChildToEnd(); + } + delay_alternative_AST = RefAdaAST(currentAST.root); + returnAST = delay_alternative_AST; +} + +void AdaParser::stmts_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST stmts_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case PRAGMA: + { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case NuLL: + case RETURN: + case FOR: + case CASE: + case BEGIN: + case LT_LT: + case IF: + case LOOP: + case WHILE: + case DECLARE: + case EXIT: + case GOTO: + case ACCEPT: + case DELAY: + case SELECT: + case ABORT: + case RAISE: + case REQUEUE: + { + statement(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop419; + } + } + } + _loop419:; + } // ( ... )* + stmts_opt_AST = RefAdaAST(currentAST.root); + returnAST = stmts_opt_AST; +} + +void AdaParser::guard_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST guard_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case WHEN: + { + w = LT(1); + if ( inputState->guessing == 0 ) { + w_AST = astFactory->create(w); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + } + match(WHEN); + condition(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RIGHT_SHAFT); + { // ( ... )* + for (;;) { + if ((LA(1) == PRAGMA)) { + pragma(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop413; + } + + } + _loop413:; + } // ( ... )* + break; + } + case ACCEPT: + case DELAY: + case TERMINATE: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + if ( inputState->guessing==0 ) { +#line 1331 "ada.g" + Set(w_AST, GUARD_OPT); +#line 10595 "AdaParser.cpp" + } + guard_opt_AST = RefAdaAST(currentAST.root); + returnAST = guard_opt_AST; +} + +void AdaParser::select_alternative() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST select_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case ACCEPT: + { + accept_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + select_alternative_AST = RefAdaAST(currentAST.root); + break; + } + case DELAY: + { + delay_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + select_alternative_AST = RefAdaAST(currentAST.root); + break; + } + case TERMINATE: + { + t = LT(1); + if ( inputState->guessing == 0 ) { + t_AST = astFactory->create(t); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST)); + } + match(TERMINATE); + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1337 "ada.g" + Set(t_AST, TERMINATE_ALTERNATIVE); +#line 10639 "AdaParser.cpp" + } + select_alternative_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = select_alternative_AST; +} + +void AdaParser::or_select_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST or_select_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { // ( ... )* + for (;;) { + if ((LA(1) == OR)) { + match(OR); + guard_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + select_alternative(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop422; + } + + } + _loop422:; + } // ( ... )* + if ( inputState->guessing==0 ) { + or_select_opt_AST = RefAdaAST(currentAST.root); +#line 1356 "ada.g" + or_select_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(OR_SELECT_OPT,"OR_SELECT_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(or_select_opt_AST)))); +#line 10682 "AdaParser.cpp" + currentAST.root = or_select_opt_AST; + if ( or_select_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + or_select_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = or_select_opt_AST->getFirstChild(); + else + currentAST.child = or_select_opt_AST; + currentAST.advanceChildToEnd(); + } + or_select_opt_AST = RefAdaAST(currentAST.root); + returnAST = or_select_opt_AST; +} + +void AdaParser::accept_alternative() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST accept_alternative_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + accept_stmt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + stmts_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { + accept_alternative_AST = RefAdaAST(currentAST.root); +#line 1341 "ada.g" + accept_alternative_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(ACCEPT_ALTERNATIVE,"ACCEPT_ALTERNATIVE")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(accept_alternative_AST)))); +#line 10713 "AdaParser.cpp" + currentAST.root = accept_alternative_AST; + if ( accept_alternative_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + accept_alternative_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = accept_alternative_AST->getFirstChild(); + else + currentAST.child = accept_alternative_AST; + currentAST.advanceChildToEnd(); + } + accept_alternative_AST = RefAdaAST(currentAST.root); + returnAST = accept_alternative_AST; +} + +void AdaParser::exception_handler() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST exception_handler_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST w_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + w = LT(1); + if ( inputState->guessing == 0 ) { + w_AST = astFactory->create(w); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(w_AST)); + } + match(WHEN); + identifier_colon_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + except_choice_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RIGHT_SHAFT); + statements(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1372 "ada.g" + Set (w_AST, EXCEPTION_HANDLER); +#line 10755 "AdaParser.cpp" + } + exception_handler_AST = RefAdaAST(currentAST.root); + returnAST = exception_handler_AST; +} + +void AdaParser::identifier_colon_opt() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST identifier_colon_opt_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) { + RefAdaAST tmp336_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp336_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp336_AST)); + } + match(IDENTIFIER); + match(COLON); + } + else if ((LA(1) == IDENTIFIER || LA(1) == OTHERS) && (LA(2) == RIGHT_SHAFT || LA(2) == DOT || LA(2) == PIPE)) { + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + } + if ( inputState->guessing==0 ) { + identifier_colon_opt_AST = RefAdaAST(currentAST.root); +#line 1376 "ada.g" + identifier_colon_opt_AST = + RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IDENTIFIER_COLON_OPT,"IDENTIFIER_COLON_OPT")))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(identifier_colon_opt_AST)))); +#line 10788 "AdaParser.cpp" + currentAST.root = identifier_colon_opt_AST; + if ( identifier_colon_opt_AST!=RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) && + identifier_colon_opt_AST->getFirstChild() != RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST) ) + currentAST.child = identifier_colon_opt_AST->getFirstChild(); + else + currentAST.child = identifier_colon_opt_AST; + currentAST.advanceChildToEnd(); + } + identifier_colon_opt_AST = RefAdaAST(currentAST.root); + returnAST = identifier_colon_opt_AST; +} + +void AdaParser::except_choice_s() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST except_choice_s_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + exception_choice(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + if ((LA(1) == PIPE)) { + RefAdaAST tmp338_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp338_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp338_AST)); + } + match(PIPE); + exception_choice(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + } + else { + goto _loop435; + } + + } + _loop435:; + } // ( ... )* + except_choice_s_AST = RefAdaAST(currentAST.root); + returnAST = except_choice_s_AST; +} + +void AdaParser::exception_choice() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST exception_choice_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case IDENTIFIER: + { + compound_name(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + exception_choice_AST = RefAdaAST(currentAST.root); + break; + } + case OTHERS: + { + RefAdaAST tmp339_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp339_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp339_AST)); + } + match(OTHERS); + exception_choice_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = exception_choice_AST; +} + +void AdaParser::operator_call() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST operator_call_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken cs = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST cs_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + cs = LT(1); + if ( inputState->guessing == 0 ) { + cs_AST = astFactory->create(cs); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cs_AST)); + } + match(CHAR_STRING); + operator_call_tail(cs_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + operator_call_AST = RefAdaAST(currentAST.root); + returnAST = operator_call_AST; +} + +void AdaParser::operator_call_tail( + RefAdaAST opstr +) { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST operator_call_tail_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + match(LPAREN); + if (!( is_operator_symbol(opstr->getText().c_str()) )) + throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(opstr->getText().c_str()) "); + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 1401 "ada.g" + opstr->setType(OPERATOR_SYMBOL); +#line 10908 "AdaParser.cpp" + } + operator_call_tail_AST = RefAdaAST(currentAST.root); + returnAST = operator_call_tail_AST; +} + +void AdaParser::relation() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST relation_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case IN: + { + RefAdaAST tmp342_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp342_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp342_AST)); + } + match(IN); + range_or_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case NOT: + { + n = LT(1); + if ( inputState->guessing == 0 ) { + n_AST = astFactory->create(n); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST)); + } + match(NOT); + match(IN); + range_or_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1425 "ada.g" + Set (n_AST, NOT_IN); +#line 10957 "AdaParser.cpp" + } + break; + } + case EQ: + { + RefAdaAST tmp344_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp344_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp344_AST)); + } + match(EQ); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case NE: + { + RefAdaAST tmp345_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp345_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp345_AST)); + } + match(NE); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LT_: + { + RefAdaAST tmp346_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp346_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp346_AST)); + } + match(LT_); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LE: + { + RefAdaAST tmp347_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp347_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp347_AST)); + } + match(LE); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case GT: + { + RefAdaAST tmp348_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp348_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp348_AST)); + } + match(GT); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case GE: + { + RefAdaAST tmp349_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp349_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp349_AST)); + } + match(GE); + simple_expression(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case COMMA: + case RPAREN: + case RIGHT_SHAFT: + case WITH: + case RANGE: + case DIGITS: + case IS: + case PIPE: + case DOT_DOT: + case ASSIGN: + case THEN: + case LOOP: + case OR: + case AND: + case XOR: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + relation_AST = RefAdaAST(currentAST.root); + returnAST = relation_AST; +} + +void AdaParser::range_or_mark() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST range_or_mark_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + bool synPredMatched455 = false; + if (((_tokenSet_0.member(LA(1))) && (_tokenSet_8.member(LA(2))))) { + int _m455 = mark(); + synPredMatched455 = true; + inputState->guessing++; + try { + { + range(); + } + } + catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { + synPredMatched455 = false; + } + rewind(_m455); + inputState->guessing--; + } + if ( synPredMatched455 ) { + range(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_or_mark_AST = RefAdaAST(currentAST.root); + } + else if ((LA(1) == IDENTIFIER) && (_tokenSet_30.member(LA(2)))) { + subtype_mark(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + range_or_mark_AST = RefAdaAST(currentAST.root); + } + else { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + + returnAST = range_or_mark_AST; +} + +void AdaParser::signed_term() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST signed_term_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken m = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST m_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case PLUS: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PLUS); + term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1447 "ada.g" + Set(p_AST, UNARY_PLUS); +#line 11141 "AdaParser.cpp" + } + signed_term_AST = RefAdaAST(currentAST.root); + break; + } + case MINUS: + { + m = LT(1); + if ( inputState->guessing == 0 ) { + m_AST = astFactory->create(m); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(m_AST)); + } + match(MINUS); + term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1448 "ada.g" + Set(m_AST, UNARY_MINUS); +#line 11161 "AdaParser.cpp" + } + signed_term_AST = RefAdaAST(currentAST.root); + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NOT: + case ABS: + case NUMERIC_LIT: + { + term(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + signed_term_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = signed_term_AST; +} + +void AdaParser::term() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST term_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case STAR: + { + RefAdaAST tmp350_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp350_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp350_AST)); + } + match(STAR); + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case DIV: + { + RefAdaAST tmp351_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp351_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp351_AST)); + } + match(DIV); + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case MOD: + { + RefAdaAST tmp352_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp352_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp352_AST)); + } + match(MOD); + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case REM: + { + RefAdaAST tmp353_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp353_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp353_AST)); + } + match(REM); + factor(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + goto _loop462; + } + } + } + _loop462:; + } // ( ... )* + term_AST = RefAdaAST(currentAST.root); + returnAST = term_AST; +} + +void AdaParser::factor() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST factor_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case NOT: + { + RefAdaAST tmp354_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp354_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp354_AST)); + } + match(NOT); + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case ABS: + { + RefAdaAST tmp355_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp355_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp355_AST)); + } + match(ABS); + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case LPAREN: + case NEW: + case CHARACTER_LITERAL: + case CHAR_STRING: + case NuLL: + case NUMERIC_LIT: + { + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + { + switch ( LA(1)) { + case EXPON: + { + RefAdaAST tmp356_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp356_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp356_AST)); + } + match(EXPON); + primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case COMMA: + case RPAREN: + case RIGHT_SHAFT: + case WITH: + case RANGE: + case DIGITS: + case IS: + case PIPE: + case DOT_DOT: + case IN: + case ASSIGN: + case MOD: + case THEN: + case LOOP: + 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: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + factor_AST = RefAdaAST(currentAST.root); + returnAST = factor_AST; +} + +void AdaParser::primary() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST primary_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken cs = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST cs_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + { + switch ( LA(1)) { + case IDENTIFIER: + { + name_or_qualified(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case LPAREN: + { + parenthesized_primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case NEW: + { + allocator(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case NuLL: + { + RefAdaAST tmp357_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp357_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp357_AST)); + } + match(NuLL); + break; + } + case NUMERIC_LIT: + { + RefAdaAST tmp358_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp358_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp358_AST)); + } + match(NUMERIC_LIT); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp359_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp359_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp359_AST)); + } + match(CHARACTER_LITERAL); + break; + } + case CHAR_STRING: + { + cs = LT(1); + if ( inputState->guessing == 0 ) { + cs_AST = astFactory->create(cs); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(cs_AST)); + } + match(CHAR_STRING); + { + switch ( LA(1)) { + case LPAREN: + { + operator_call_tail(cs_AST); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case SEMI: + case COMMA: + case RPAREN: + case RIGHT_SHAFT: + case WITH: + case RANGE: + case DIGITS: + case IS: + case PIPE: + case DOT_DOT: + case IN: + case ASSIGN: + case MOD: + case THEN: + case LOOP: + 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 EXPON: + { + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + primary_AST = RefAdaAST(currentAST.root); + returnAST = primary_AST; +} + +void AdaParser::name_or_qualified() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST name_or_qualified_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); +#line 1479 "ada.g" + RefAdaAST dummy; +#line 11528 "AdaParser.cpp" + + RefAdaAST tmp360_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp360_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp360_AST)); + } + match(IDENTIFIER); + { // ( ... )* + for (;;) { + switch ( LA(1)) { + case DOT: + { + RefAdaAST tmp361_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp361_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp361_AST)); + } + match(DOT); + { + switch ( LA(1)) { + case ALL: + { + RefAdaAST tmp362_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp362_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp362_AST)); + } + match(ALL); + break; + } + case IDENTIFIER: + { + RefAdaAST tmp363_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp363_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp363_AST)); + } + match(IDENTIFIER); + break; + } + case CHARACTER_LITERAL: + { + RefAdaAST tmp364_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp364_AST = astFactory->create(LT(1)); + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp364_AST)); + } + match(CHARACTER_LITERAL); + break; + } + case CHAR_STRING: + { + dummy=is_operator(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + case LPAREN: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(LPAREN); + value_s(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(RPAREN); + if ( inputState->guessing==0 ) { +#line 1487 "ada.g" + Set(p_AST, INDEXED_COMPONENT); +#line 11611 "AdaParser.cpp" + } + break; + } + case TIC: + { + RefAdaAST tmp366_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + if ( inputState->guessing == 0 ) { + tmp366_AST = astFactory->create(LT(1)); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp366_AST)); + } + match(TIC); + { + switch ( LA(1)) { + case LPAREN: + { + parenthesized_primary(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + case IDENTIFIER: + case RANGE: + case DIGITS: + case DELTA: + case ACCESS: + { + attribute_id(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + } + break; + } + default: + { + goto _loop473; + } + } + } + _loop473:; + } // ( ... )* + name_or_qualified_AST = RefAdaAST(currentAST.root); + returnAST = name_or_qualified_AST; +} + +void AdaParser::allocator() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST allocator_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST n_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + n = LT(1); + if ( inputState->guessing == 0 ) { + n_AST = astFactory->create(n); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST)); + } + match(NEW); + name_or_qualified(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + if ( inputState->guessing==0 ) { +#line 1493 "ada.g" + Set(n_AST, ALLOCATOR); +#line 11685 "AdaParser.cpp" + } + allocator_AST = RefAdaAST(currentAST.root); + returnAST = allocator_AST; +} + +void AdaParser::subprogram_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST subprogram_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST f_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + switch ( LA(1)) { + case PROCEDURE: + { + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PROCEDURE); + def_id(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + formal_part_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1507 "ada.g" + pop_def_id(); Set(p_AST, PROCEDURE_BODY); +#line 11726 "AdaParser.cpp" + } + subprogram_body_AST = RefAdaAST(currentAST.root); + break; + } + case FUNCTION: + { + f = LT(1); + if ( inputState->guessing == 0 ) { + f_AST = astFactory->create(f); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(f_AST)); + } + match(FUNCTION); + def_designator(false); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + function_tail(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(IS); + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1509 "ada.g" + pop_def_id(); Set(f_AST, FUNCTION_BODY); +#line 11756 "AdaParser.cpp" + } + subprogram_body_AST = RefAdaAST(currentAST.root); + break; + } + default: + { + throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); + } + } + returnAST = subprogram_body_AST; +} + +void AdaParser::package_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST package_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PACKAGE); + body_is(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + pkg_body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1513 "ada.g" + Set(p_AST, PACKAGE_BODY); +#line 11794 "AdaParser.cpp" + } + package_body_AST = RefAdaAST(currentAST.root); + returnAST = package_body_AST; +} + +void AdaParser::task_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST task_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST t_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + t = LT(1); + if ( inputState->guessing == 0 ) { + t_AST = astFactory->create(t); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(t_AST)); + } + match(TASK); + body_is(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + body_part(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1517 "ada.g" + Set(t_AST, TASK_BODY); +#line 11825 "AdaParser.cpp" + } + task_body_AST = RefAdaAST(currentAST.root); + returnAST = task_body_AST; +} + +void AdaParser::protected_body() { + returnAST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; + RefAdaAST protected_body_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; + RefAdaAST p_AST = RefAdaAST(ANTLR_USE_NAMESPACE(antlr)nullAST); + + p = LT(1); + if ( inputState->guessing == 0 ) { + p_AST = astFactory->create(p); + astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(p_AST)); + } + match(PROTECTED); + body_is(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + prot_op_bodies_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + end_id_opt(); + if (inputState->guessing==0) { + astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST)); + } + match(SEMI); + if ( inputState->guessing==0 ) { +#line 1521 "ada.g" + Set(p_AST, PROTECTED_BODY); +#line 11860 "AdaParser.cpp" + } + protected_body_AST = RefAdaAST(currentAST.root); + returnAST = protected_body_AST; +} + +void AdaParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) +{ + factory.setMaxNodeType(289); +} +const char* AdaParser::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", + 0 +}; + +const unsigned long AdaParser::_tokenSet_0_data_[] = { 67109024UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "not" PLUS +// MINUS "abs" NUMERIC_LIT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_0(_tokenSet_0_data_,10); +const unsigned long AdaParser::_tokenSet_1_data_[] = { 201364384UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN COMMA RPAREN DOT TIC "new" "others" "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 +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_1(_tokenSet_1_data_,10); +const unsigned long AdaParser::_tokenSet_2_data_[] = { 8388800UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI LPAREN "is" "renames" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_2(_tokenSet_2_data_,10); +const unsigned long AdaParser::_tokenSet_3_data_[] = { 52453426UL, 1611238800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" +// CHAR_STRING "separate" "abstract" "task" "protected" "for" "end" "subtype" +// "generic" "begin" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_3(_tokenSet_3_data_,10); +const unsigned long AdaParser::_tokenSet_4_data_[] = { 8392896UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI LPAREN DOT "is" "in" "renames" "when" "do" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_4(_tokenSet_4_data_,10); +const unsigned long AdaParser::_tokenSet_5_data_[] = { 8388800UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI LPAREN "is" "in" "renames" "when" "do" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_5(_tokenSet_5_data_,10); +const unsigned long AdaParser::_tokenSet_6_data_[] = { 53502002UL, 537496976UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" +// "function" CHAR_STRING "separate" "abstract" "task" "protected" "for" +// "end" "subtype" "generic" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_6(_tokenSet_6_data_,10); +const unsigned long AdaParser::_tokenSet_7_data_[] = { 8392832UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// LPAREN DOT "is" "return" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_7(_tokenSet_7_data_,10); +const unsigned long AdaParser::_tokenSet_8_data_[] = { 738234528UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN DOT TIC "new" "others" DOT_DOT CHARACTER_LITERAL CHAR_STRING +// "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_8(_tokenSet_8_data_,10); +const unsigned long AdaParser::_tokenSet_9_data_[] = { 201326752UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN "new" "others" CHARACTER_LITERAL CHAR_STRING "null" +// "not" PLUS MINUS "abs" NUMERIC_LIT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_9(_tokenSet_9_data_,10); +const unsigned long AdaParser::_tokenSet_10_data_[] = { 1006739360UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "new" +// "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 +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_10(_tokenSet_10_data_,10); +const unsigned long AdaParser::_tokenSet_11_data_[] = { 1006737312UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT DOT TIC "range" "new" "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 +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_11(_tokenSet_11_data_,10); +const unsigned long AdaParser::_tokenSet_12_data_[] = { 32UL, 23068672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER "constant" "array" "aliased" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_12(_tokenSet_12_data_,10); +const unsigned long AdaParser::_tokenSet_13_data_[] = { 495840UL, 6299648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER SEMI LPAREN DOT TIC "range" "digits" "delta" ASSIGN "constant" +// "array" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_13(_tokenSet_13_data_,10); +const unsigned long AdaParser::_tokenSet_14_data_[] = { 51380274UL, 114688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// EOF "pragma" IDENTIFIER "private" "procedure" "function" "entry" "for" +// "end" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_14(_tokenSet_14_data_,10); +const unsigned long AdaParser::_tokenSet_15_data_[] = { 496256UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// LPAREN RPAREN DOT TIC "range" "digits" "delta" "loop" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_15(_tokenSet_15_data_,10); +const unsigned long AdaParser::_tokenSet_16_data_[] = { 50331664UL, 49152UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "pragma" "procedure" "function" "entry" "for" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_16(_tokenSet_16_data_,10); +const unsigned long AdaParser::_tokenSet_17_data_[] = { 1048576UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "private" "null" "record" "abstract" "tagged" "limited" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_17(_tokenSet_17_data_,10); +const unsigned long AdaParser::_tokenSet_18_data_[] = { 1048688UL, 436207712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "pragma" IDENTIFIER SEMI "private" "null" "record" "case" "tagged" "limited" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_18(_tokenSet_18_data_,10); +const unsigned long AdaParser::_tokenSet_19_data_[] = { 496512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// LPAREN COMMA RPAREN DOT TIC "range" "digits" "delta" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_19(_tokenSet_19_data_,10); +const unsigned long AdaParser::_tokenSet_20_data_[] = { 738300064UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN DOT TIC "range" "new" "others" DOT_DOT CHARACTER_LITERAL +// CHAR_STRING "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" +// EXPON NUMERIC_LIT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_20(_tokenSet_20_data_,10); +const unsigned long AdaParser::_tokenSet_21_data_[] = { 469800096UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER LPAREN RIGHT_SHAFT DOT TIC "new" "others" PIPE "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 +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_21(_tokenSet_21_data_,10); +const unsigned long AdaParser::_tokenSet_22_data_[] = { 1048576UL, 402653440UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "private" "abstract" "tagged" "limited" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_22(_tokenSet_22_data_,10); +const unsigned long AdaParser::_tokenSet_23_data_[] = { 1048640UL, 402653184UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI "private" "tagged" "limited" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_23(_tokenSet_23_data_,10); +const unsigned long AdaParser::_tokenSet_24_data_[] = { 37056UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI LPAREN DOT TIC ASSIGN +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_24(_tokenSet_24_data_,10); +const unsigned long AdaParser::_tokenSet_25_data_[] = { 67145952UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER SEMI LPAREN DOT TIC "new" CHARACTER_LITERAL CHAR_STRING "null" +// "until" "not" PLUS MINUS "abs" NUMERIC_LIT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_25(_tokenSet_25_data_,10); +const unsigned long AdaParser::_tokenSet_26_data_[] = { 0UL, 67108864UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "when" "accept" "delay" "terminate" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_26(_tokenSet_26_data_,10); +const unsigned long AdaParser::_tokenSet_27_data_[] = { 67109088UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// IDENTIFIER SEMI LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "until" +// "not" PLUS MINUS "abs" NUMERIC_LIT +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_27(_tokenSet_27_data_,10); +const unsigned long AdaParser::_tokenSet_28_data_[] = { 37056UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI LPAREN DOT TIC +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_28(_tokenSet_28_data_,10); +const unsigned long AdaParser::_tokenSet_29_data_[] = { 48UL, 3323036192UL, 1814398UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// "pragma" IDENTIFIER "null" "return" "for" "end" "exception" "case" "when" +// "begin" LT_LT "if" "then" "elsif" "else" "loop" "while" "declare" "exit" +// "goto" "accept" "delay" "select" "abort" "or" "raise" "requeue" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_29(_tokenSet_29_data_,10); +const unsigned long AdaParser::_tokenSet_30_data_[] = { 813932352UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; +// SEMI COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" "is" PIPE +// DOT_DOT ASSIGN "then" "loop" "or" "and" "xor" +const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_30(_tokenSet_30_data_,10); + + |