KDevelop API Documentation

AdaParser.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "ada.g" -> "AdaParser.cpp"$ */
00002 #include "AdaParser.hpp"
00003 #include <antlr/NoViableAltException.hpp>
00004 #include <antlr/SemanticException.hpp>
00005 #include <antlr/ASTFactory.hpp>
00006 #line 1 "ada.g"
00007 #line 8 "AdaParser.cpp"
00008 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
00009 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
00010 {
00011 }
00012 
00013 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
00014 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
00015 {
00016 }
00017 
00018 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
00019 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
00020 {
00021 }
00022 
00023 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
00024 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
00025 {
00026 }
00027 
00028 AdaParser::AdaParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
00029 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
00030 {
00031 }
00032 
00033 void AdaParser::compilation_unit() {
00034     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00035     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00036     RefAdaAST compilation_unit_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00037     
00038     try {      // for error handling
00039         context_items_opt();
00040         if (inputState->guessing==0) {
00041             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00042         }
00043         {
00044         switch ( LA(1)) {
00045         case PRIVATE:
00046         case PACKAGE:
00047         case PROCEDURE:
00048         case FUNCTION:
00049         case GENERIC:
00050         {
00051             library_item();
00052             if (inputState->guessing==0) {
00053                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00054             }
00055             break;
00056         }
00057         case SEPARATE:
00058         {
00059             subunit();
00060             if (inputState->guessing==0) {
00061                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00062             }
00063             break;
00064         }
00065         default:
00066         {
00067             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00068         }
00069         }
00070         }
00071         { // ( ... )*
00072         for (;;) {
00073             if ((LA(1) == PRAGMA)) {
00074                 pragma();
00075                 if (inputState->guessing==0) {
00076                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00077                 }
00078             }
00079             else {
00080                 goto _loop4;
00081             }
00082             
00083         }
00084         _loop4:;
00085         } // ( ... )*
00086         compilation_unit_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00087     }
00088     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00089         if( inputState->guessing == 0 ) {
00090             reportError(ex);
00091             consume();
00092             consumeUntil(_tokenSet_0);
00093         } else {
00094             throw;
00095         }
00096     }
00097     returnAST = compilation_unit_AST;
00098 }
00099 
00100 void AdaParser::context_items_opt() {
00101     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00102     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00103     RefAdaAST context_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00104     
00105     try {      // for error handling
00106         { // ( ... )*
00107         for (;;) {
00108             if ((LA(1) == PRAGMA)) {
00109                 pragma();
00110                 if (inputState->guessing==0) {
00111                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00112                 }
00113             }
00114             else {
00115                 goto _loop14;
00116             }
00117             
00118         }
00119         _loop14:;
00120         } // ( ... )*
00121         { // ( ... )*
00122         for (;;) {
00123             if ((LA(1) == WITH)) {
00124                 with_clause();
00125                 if (inputState->guessing==0) {
00126                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00127                 }
00128                 { // ( ... )*
00129                 for (;;) {
00130                     switch ( LA(1)) {
00131                     case USE:
00132                     {
00133                         use_clause();
00134                         if (inputState->guessing==0) {
00135                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00136                         }
00137                         break;
00138                     }
00139                     case PRAGMA:
00140                     {
00141                         pragma();
00142                         if (inputState->guessing==0) {
00143                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00144                         }
00145                         break;
00146                     }
00147                     default:
00148                     {
00149                         goto _loop17;
00150                     }
00151                     }
00152                 }
00153                 _loop17:;
00154                 } // ( ... )*
00155             }
00156             else {
00157                 goto _loop18;
00158             }
00159             
00160         }
00161         _loop18:;
00162         } // ( ... )*
00163         if ( inputState->guessing==0 ) {
00164             context_items_opt_AST = RefAdaAST(currentAST.root);
00165 #line 86 "ada.g"
00166             context_items_opt_AST =
00167                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CONTEXT_CLAUSE,"CONTEXT_CLAUSE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(context_items_opt_AST.get()))));
00168 #line 169 "AdaParser.cpp"
00169             currentAST.root = context_items_opt_AST;
00170             if ( context_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
00171                 context_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00172                   currentAST.child = context_items_opt_AST->getFirstChild();
00173             else
00174                 currentAST.child = context_items_opt_AST;
00175             currentAST.advanceChildToEnd();
00176         }
00177         context_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00178     }
00179     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00180         if( inputState->guessing == 0 ) {
00181             reportError(ex);
00182             consume();
00183             consumeUntil(_tokenSet_1);
00184         } else {
00185             throw;
00186         }
00187     }
00188     returnAST = context_items_opt_AST;
00189 }
00190 
00191 void AdaParser::library_item() {
00192     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00193     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00194     RefAdaAST library_item_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00195     
00196     try {      // for error handling
00197         private_opt();
00198         if (inputState->guessing==0) {
00199             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00200         }
00201         {
00202         switch ( LA(1)) {
00203         case PACKAGE:
00204         {
00205             lib_pkg_spec_or_body();
00206             if (inputState->guessing==0) {
00207                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00208             }
00209             break;
00210         }
00211         case PROCEDURE:
00212         case FUNCTION:
00213         {
00214             subprog_decl_or_rename_or_inst_or_body(true);
00215             if (inputState->guessing==0) {
00216                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00217             }
00218             break;
00219         }
00220         case GENERIC:
00221         {
00222             generic_decl(true);
00223             if (inputState->guessing==0) {
00224                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00225             }
00226             break;
00227         }
00228         default:
00229         {
00230             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00231         }
00232         }
00233         }
00234         if ( inputState->guessing==0 ) {
00235             library_item_AST = RefAdaAST(currentAST.root);
00236 #line 133 "ada.g"
00237             library_item_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LIBRARY_ITEM,"LIBRARY_ITEM").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(library_item_AST.get()))));
00238 #line 239 "AdaParser.cpp"
00239             currentAST.root = library_item_AST;
00240             if ( library_item_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
00241                 library_item_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00242                   currentAST.child = library_item_AST->getFirstChild();
00243             else
00244                 currentAST.child = library_item_AST;
00245             currentAST.advanceChildToEnd();
00246         }
00247         library_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00248     }
00249     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00250         if( inputState->guessing == 0 ) {
00251             reportError(ex);
00252             consume();
00253             consumeUntil(_tokenSet_2);
00254         } else {
00255             throw;
00256         }
00257     }
00258     returnAST = library_item_AST;
00259 }
00260 
00261 void AdaParser::subunit() {
00262     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00263     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00264     RefAdaAST subunit_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00265     ANTLR_USE_NAMESPACE(antlr)RefToken  sep = ANTLR_USE_NAMESPACE(antlr)nullToken;
00266     RefAdaAST sep_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00267     
00268     try {      // for error handling
00269         sep = LT(1);
00270         if ( inputState->guessing == 0 ) {
00271             sep_AST = astFactory->create(sep);
00272             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(sep_AST.get()));
00273         }
00274         match(SEPARATE);
00275         match(LPAREN);
00276         compound_name();
00277         if (inputState->guessing==0) {
00278             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00279         }
00280         match(RPAREN);
00281         if ( inputState->guessing==0 ) {
00282 #line 1472 "ada.g"
00283             Set(sep_AST, SUBUNIT);
00284 #line 285 "AdaParser.cpp"
00285         }
00286         {
00287         switch ( LA(1)) {
00288         case PROCEDURE:
00289         case FUNCTION:
00290         {
00291             subprogram_body();
00292             if (inputState->guessing==0) {
00293                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00294             }
00295             break;
00296         }
00297         case PACKAGE:
00298         {
00299             package_body();
00300             if (inputState->guessing==0) {
00301                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00302             }
00303             break;
00304         }
00305         case TASK:
00306         {
00307             task_body();
00308             if (inputState->guessing==0) {
00309                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00310             }
00311             break;
00312         }
00313         case PROTECTED:
00314         {
00315             protected_body();
00316             if (inputState->guessing==0) {
00317                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00318             }
00319             break;
00320         }
00321         default:
00322         {
00323             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00324         }
00325         }
00326         }
00327         subunit_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00328     }
00329     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00330         if( inputState->guessing == 0 ) {
00331             reportError(ex);
00332             consume();
00333             consumeUntil(_tokenSet_2);
00334         } else {
00335             throw;
00336         }
00337     }
00338     returnAST = subunit_AST;
00339 }
00340 
00341 void AdaParser::pragma() {
00342     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00343     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00344     RefAdaAST pragma_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00345     
00346     try {      // for error handling
00347         RefAdaAST tmp3_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00348         if ( inputState->guessing == 0 ) {
00349             tmp3_AST = astFactory->create(LT(1));
00350             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp3_AST.get()));
00351         }
00352         match(PRAGMA);
00353         RefAdaAST tmp4_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00354         if ( inputState->guessing == 0 ) {
00355             tmp4_AST = astFactory->create(LT(1));
00356             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp4_AST.get()));
00357         }
00358         match(IDENTIFIER);
00359         pragma_args_opt();
00360         if (inputState->guessing==0) {
00361             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00362         }
00363         match(SEMI);
00364         pragma_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00365     }
00366     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00367         if( inputState->guessing == 0 ) {
00368             reportError(ex);
00369             consume();
00370             consumeUntil(_tokenSet_3);
00371         } else {
00372             throw;
00373         }
00374     }
00375     returnAST = pragma_AST;
00376 }
00377 
00378 void AdaParser::pragma_args_opt() {
00379     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00380     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00381     RefAdaAST pragma_args_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00382     
00383     try {      // for error handling
00384         {
00385         switch ( LA(1)) {
00386         case LPAREN:
00387         {
00388             match(LPAREN);
00389             pragma_arg();
00390             if (inputState->guessing==0) {
00391                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00392             }
00393             { // ( ... )*
00394             for (;;) {
00395                 if ((LA(1) == COMMA)) {
00396                     match(COMMA);
00397                     pragma_arg();
00398                     if (inputState->guessing==0) {
00399                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00400                     }
00401                 }
00402                 else {
00403                     goto _loop9;
00404                 }
00405                 
00406             }
00407             _loop9:;
00408             } // ( ... )*
00409             match(RPAREN);
00410             break;
00411         }
00412         case SEMI:
00413         {
00414             break;
00415         }
00416         default:
00417         {
00418             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00419         }
00420         }
00421         }
00422         pragma_args_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00423     }
00424     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00425         if( inputState->guessing == 0 ) {
00426             reportError(ex);
00427             consume();
00428             consumeUntil(_tokenSet_4);
00429         } else {
00430             throw;
00431         }
00432     }
00433     returnAST = pragma_args_opt_AST;
00434 }
00435 
00436 void AdaParser::pragma_arg() {
00437     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00438     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00439     RefAdaAST pragma_arg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00440     
00441     try {      // for error handling
00442         {
00443         if ((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT)) {
00444             RefAdaAST tmp9_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00445             if ( inputState->guessing == 0 ) {
00446                 tmp9_AST = astFactory->create(LT(1));
00447                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp9_AST.get()));
00448             }
00449             match(IDENTIFIER);
00450             RefAdaAST tmp10_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00451             if ( inputState->guessing == 0 ) {
00452                 tmp10_AST = astFactory->create(LT(1));
00453                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp10_AST.get()));
00454             }
00455             match(RIGHT_SHAFT);
00456         }
00457         else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
00458         }
00459         else {
00460             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00461         }
00462         
00463         }
00464         expression();
00465         if (inputState->guessing==0) {
00466             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00467         }
00468         pragma_arg_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00469     }
00470     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00471         if( inputState->guessing == 0 ) {
00472             reportError(ex);
00473             consume();
00474             consumeUntil(_tokenSet_7);
00475         } else {
00476             throw;
00477         }
00478     }
00479     returnAST = pragma_arg_AST;
00480 }
00481 
00482 void AdaParser::expression() {
00483     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00484     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00485     RefAdaAST expression_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00486     ANTLR_USE_NAMESPACE(antlr)RefToken  a = ANTLR_USE_NAMESPACE(antlr)nullToken;
00487     RefAdaAST a_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00488     ANTLR_USE_NAMESPACE(antlr)RefToken  o = ANTLR_USE_NAMESPACE(antlr)nullToken;
00489     RefAdaAST o_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00490     
00491     try {      // for error handling
00492         relation();
00493         if (inputState->guessing==0) {
00494             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00495         }
00496         { // ( ... )*
00497         for (;;) {
00498             switch ( LA(1)) {
00499             case AND:
00500             {
00501                 a = LT(1);
00502                 if ( inputState->guessing == 0 ) {
00503                     a_AST = astFactory->create(a);
00504                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get()));
00505                 }
00506                 match(AND);
00507                 {
00508                 switch ( LA(1)) {
00509                 case THEN:
00510                 {
00511                     match(THEN);
00512                     if ( inputState->guessing==0 ) {
00513 #line 1392 "ada.g"
00514                         Set (a_AST, AND_THEN);
00515 #line 516 "AdaParser.cpp"
00516                     }
00517                     break;
00518                 }
00519                 case IDENTIFIER:
00520                 case LPAREN:
00521                 case NEW:
00522                 case CHARACTER_LITERAL:
00523                 case CHAR_STRING:
00524                 case NuLL:
00525                 case NOT:
00526                 case PLUS:
00527                 case MINUS:
00528                 case ABS:
00529                 case NUMERIC_LIT:
00530                 {
00531                     break;
00532                 }
00533                 default:
00534                 {
00535                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00536                 }
00537                 }
00538                 }
00539                 relation();
00540                 if (inputState->guessing==0) {
00541                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00542                 }
00543                 break;
00544             }
00545             case OR:
00546             {
00547                 o = LT(1);
00548                 if ( inputState->guessing == 0 ) {
00549                     o_AST = astFactory->create(o);
00550                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(o_AST.get()));
00551                 }
00552                 match(OR);
00553                 {
00554                 switch ( LA(1)) {
00555                 case ELSE:
00556                 {
00557                     match(ELSE);
00558                     if ( inputState->guessing==0 ) {
00559 #line 1393 "ada.g"
00560                         Set (o_AST, OR_ELSE);
00561 #line 562 "AdaParser.cpp"
00562                     }
00563                     break;
00564                 }
00565                 case IDENTIFIER:
00566                 case LPAREN:
00567                 case NEW:
00568                 case CHARACTER_LITERAL:
00569                 case CHAR_STRING:
00570                 case NuLL:
00571                 case NOT:
00572                 case PLUS:
00573                 case MINUS:
00574                 case ABS:
00575                 case NUMERIC_LIT:
00576                 {
00577                     break;
00578                 }
00579                 default:
00580                 {
00581                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00582                 }
00583                 }
00584                 }
00585                 relation();
00586                 if (inputState->guessing==0) {
00587                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00588                 }
00589                 break;
00590             }
00591             case XOR:
00592             {
00593                 RefAdaAST tmp13_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00594                 if ( inputState->guessing == 0 ) {
00595                     tmp13_AST = astFactory->create(LT(1));
00596                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp13_AST.get()));
00597                 }
00598                 match(XOR);
00599                 relation();
00600                 if (inputState->guessing==0) {
00601                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00602                 }
00603                 break;
00604             }
00605             default:
00606             {
00607                 goto _loop445;
00608             }
00609             }
00610         }
00611         _loop445:;
00612         } // ( ... )*
00613         expression_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00614     }
00615     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00616         if( inputState->guessing == 0 ) {
00617             reportError(ex);
00618             consume();
00619             consumeUntil(_tokenSet_8);
00620         } else {
00621             throw;
00622         }
00623     }
00624     returnAST = expression_AST;
00625 }
00626 
00627 void AdaParser::with_clause() {
00628     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00629     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00630     RefAdaAST with_clause_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00631     ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
00632     RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00633     
00634     try {      // for error handling
00635         w = LT(1);
00636         if ( inputState->guessing == 0 ) {
00637             w_AST = astFactory->create(w);
00638             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
00639         }
00640         match(WITH);
00641         c_name_list();
00642         if (inputState->guessing==0) {
00643             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00644         }
00645         match(SEMI);
00646         if ( inputState->guessing==0 ) {
00647 #line 94 "ada.g"
00648             Set(w_AST, WITH_CLAUSE);
00649 #line 650 "AdaParser.cpp"
00650         }
00651         with_clause_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00652     }
00653     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00654         if( inputState->guessing == 0 ) {
00655             reportError(ex);
00656             consume();
00657             consumeUntil(_tokenSet_9);
00658         } else {
00659             throw;
00660         }
00661     }
00662     returnAST = with_clause_AST;
00663 }
00664 
00665 void AdaParser::use_clause() {
00666     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00667     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00668     RefAdaAST use_clause_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00669     ANTLR_USE_NAMESPACE(antlr)RefToken  u = ANTLR_USE_NAMESPACE(antlr)nullToken;
00670     RefAdaAST u_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00671     
00672     try {      // for error handling
00673         u = LT(1);
00674         if ( inputState->guessing == 0 ) {
00675             u_AST = astFactory->create(u);
00676             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(u_AST.get()));
00677         }
00678         match(USE);
00679         {
00680         switch ( LA(1)) {
00681         case TYPE:
00682         {
00683             match(TYPE);
00684             subtype_mark();
00685             if (inputState->guessing==0) {
00686                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00687             }
00688             { // ( ... )*
00689             for (;;) {
00690                 if ((LA(1) == COMMA)) {
00691                     match(COMMA);
00692                     subtype_mark();
00693                     if (inputState->guessing==0) {
00694                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00695                     }
00696                 }
00697                 else {
00698                     goto _loop29;
00699                 }
00700                 
00701             }
00702             _loop29:;
00703             } // ( ... )*
00704             if ( inputState->guessing==0 ) {
00705 #line 108 "ada.g"
00706                 Set(u_AST, USE_TYPE_CLAUSE);
00707 #line 708 "AdaParser.cpp"
00708             }
00709             break;
00710         }
00711         case IDENTIFIER:
00712         {
00713             c_name_list();
00714             if (inputState->guessing==0) {
00715                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00716             }
00717             if ( inputState->guessing==0 ) {
00718 #line 109 "ada.g"
00719                 Set(u_AST, USE_CLAUSE);
00720 #line 721 "AdaParser.cpp"
00721             }
00722             break;
00723         }
00724         default:
00725         {
00726             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00727         }
00728         }
00729         }
00730         match(SEMI);
00731         use_clause_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00732     }
00733     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00734         if( inputState->guessing == 0 ) {
00735             reportError(ex);
00736             consume();
00737             consumeUntil(_tokenSet_10);
00738         } else {
00739             throw;
00740         }
00741     }
00742     returnAST = use_clause_AST;
00743 }
00744 
00745 void AdaParser::c_name_list() {
00746     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00747     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00748     RefAdaAST c_name_list_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00749     
00750     try {      // for error handling
00751         compound_name();
00752         if (inputState->guessing==0) {
00753             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00754         }
00755         { // ( ... )*
00756         for (;;) {
00757             if ((LA(1) == COMMA)) {
00758                 match(COMMA);
00759                 compound_name();
00760                 if (inputState->guessing==0) {
00761                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00762                 }
00763             }
00764             else {
00765                 goto _loop22;
00766             }
00767             
00768         }
00769         _loop22:;
00770         } // ( ... )*
00771         c_name_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00772     }
00773     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00774         if( inputState->guessing == 0 ) {
00775             reportError(ex);
00776             consume();
00777             consumeUntil(_tokenSet_4);
00778         } else {
00779             throw;
00780         }
00781     }
00782     returnAST = c_name_list_AST;
00783 }
00784 
00785 void AdaParser::compound_name() {
00786     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00787     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00788     RefAdaAST compound_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00789     
00790     try {      // for error handling
00791         RefAdaAST tmp19_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00792         if ( inputState->guessing == 0 ) {
00793             tmp19_AST = astFactory->create(LT(1));
00794             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp19_AST.get()));
00795         }
00796         match(IDENTIFIER);
00797         { // ( ... )*
00798         for (;;) {
00799             if ((LA(1) == DOT)) {
00800                 RefAdaAST tmp20_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00801                 if ( inputState->guessing == 0 ) {
00802                     tmp20_AST = astFactory->create(LT(1));
00803                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp20_AST.get()));
00804                 }
00805                 match(DOT);
00806                 RefAdaAST tmp21_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00807                 if ( inputState->guessing == 0 ) {
00808                     tmp21_AST = astFactory->create(LT(1));
00809                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp21_AST.get()));
00810                 }
00811                 match(IDENTIFIER);
00812             }
00813             else {
00814                 goto _loop25;
00815             }
00816             
00817         }
00818         _loop25:;
00819         } // ( ... )*
00820         compound_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00821     }
00822     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00823         if( inputState->guessing == 0 ) {
00824             reportError(ex);
00825             consume();
00826             consumeUntil(_tokenSet_11);
00827         } else {
00828             throw;
00829         }
00830     }
00831     returnAST = compound_name_AST;
00832 }
00833 
00834 void AdaParser::subtype_mark() {
00835     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00836     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00837     RefAdaAST subtype_mark_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00838     
00839     try {      // for error handling
00840         compound_name();
00841         if (inputState->guessing==0) {
00842             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00843         }
00844         {
00845         switch ( LA(1)) {
00846         case TIC:
00847         {
00848             RefAdaAST tmp22_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00849             if ( inputState->guessing == 0 ) {
00850                 tmp22_AST = astFactory->create(LT(1));
00851                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp22_AST.get()));
00852             }
00853             match(TIC);
00854             attribute_id();
00855             if (inputState->guessing==0) {
00856                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00857             }
00858             break;
00859         }
00860         case SEMI:
00861         case LPAREN:
00862         case COMMA:
00863         case RPAREN:
00864         case RIGHT_SHAFT:
00865         case WITH:
00866         case USE:
00867         case RANGE:
00868         case DIGITS:
00869         case DELTA:
00870         case IS:
00871         case PIPE:
00872         case DOT_DOT:
00873         case RENAMES:
00874         case ASSIGN:
00875         case AT:
00876         case THEN:
00877         case LOOP:
00878         case OR:
00879         case AND:
00880         case XOR:
00881         {
00882             break;
00883         }
00884         default:
00885         {
00886             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00887         }
00888         }
00889         }
00890         subtype_mark_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00891     }
00892     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00893         if( inputState->guessing == 0 ) {
00894             reportError(ex);
00895             consume();
00896             consumeUntil(_tokenSet_12);
00897         } else {
00898             throw;
00899         }
00900     }
00901     returnAST = subtype_mark_AST;
00902 }
00903 
00904 void AdaParser::attribute_id() {
00905     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00906     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00907     RefAdaAST attribute_id_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00908     
00909     try {      // for error handling
00910         switch ( LA(1)) {
00911         case RANGE:
00912         {
00913             RefAdaAST tmp23_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00914             if ( inputState->guessing == 0 ) {
00915                 tmp23_AST = astFactory->create(LT(1));
00916                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp23_AST.get()));
00917             }
00918             match(RANGE);
00919             attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00920             break;
00921         }
00922         case DIGITS:
00923         {
00924             RefAdaAST tmp24_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00925             if ( inputState->guessing == 0 ) {
00926                 tmp24_AST = astFactory->create(LT(1));
00927                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp24_AST.get()));
00928             }
00929             match(DIGITS);
00930             attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00931             break;
00932         }
00933         case DELTA:
00934         {
00935             RefAdaAST tmp25_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00936             if ( inputState->guessing == 0 ) {
00937                 tmp25_AST = astFactory->create(LT(1));
00938                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp25_AST.get()));
00939             }
00940             match(DELTA);
00941             attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00942             break;
00943         }
00944         case ACCESS:
00945         {
00946             RefAdaAST tmp26_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00947             if ( inputState->guessing == 0 ) {
00948                 tmp26_AST = astFactory->create(LT(1));
00949                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp26_AST.get()));
00950             }
00951             match(ACCESS);
00952             attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00953             break;
00954         }
00955         case IDENTIFIER:
00956         {
00957             RefAdaAST tmp27_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00958             if ( inputState->guessing == 0 ) {
00959                 tmp27_AST = astFactory->create(LT(1));
00960                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp27_AST.get()));
00961             }
00962             match(IDENTIFIER);
00963             attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
00964             break;
00965         }
00966         default:
00967         {
00968             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00969         }
00970         }
00971     }
00972     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00973         if( inputState->guessing == 0 ) {
00974             reportError(ex);
00975             consume();
00976             consumeUntil(_tokenSet_13);
00977         } else {
00978             throw;
00979         }
00980     }
00981     returnAST = attribute_id_AST;
00982 }
00983 
00984 void AdaParser::private_opt() {
00985     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00986     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00987     RefAdaAST private_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00988     
00989     try {      // for error handling
00990         {
00991         switch ( LA(1)) {
00992         case PRIVATE:
00993         {
00994             RefAdaAST tmp28_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00995             if ( inputState->guessing == 0 ) {
00996                 tmp28_AST = astFactory->create(LT(1));
00997                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp28_AST.get()));
00998             }
00999             match(PRIVATE);
01000             break;
01001         }
01002         case PACKAGE:
01003         case PROCEDURE:
01004         case FUNCTION:
01005         case GENERIC:
01006         {
01007             break;
01008         }
01009         default:
01010         {
01011             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01012         }
01013         }
01014         }
01015         if ( inputState->guessing==0 ) {
01016             private_opt_AST = RefAdaAST(currentAST.root);
01017 #line 137 "ada.g"
01018             private_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(private_opt_AST.get()))));
01019 #line 1020 "AdaParser.cpp"
01020             currentAST.root = private_opt_AST;
01021             if ( private_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
01022                 private_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01023                   currentAST.child = private_opt_AST->getFirstChild();
01024             else
01025                 currentAST.child = private_opt_AST;
01026             currentAST.advanceChildToEnd();
01027         }
01028         private_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01029     }
01030     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01031         if( inputState->guessing == 0 ) {
01032             reportError(ex);
01033             consume();
01034             consumeUntil(_tokenSet_14);
01035         } else {
01036             throw;
01037         }
01038     }
01039     returnAST = private_opt_AST;
01040 }
01041 
01042 void AdaParser::lib_pkg_spec_or_body() {
01043     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01044     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01045     RefAdaAST lib_pkg_spec_or_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01046     ANTLR_USE_NAMESPACE(antlr)RefToken  pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
01047     RefAdaAST pkg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01048     
01049     try {      // for error handling
01050         pkg = LT(1);
01051         if ( inputState->guessing == 0 ) {
01052             pkg_AST = astFactory->create(pkg);
01053             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get()));
01054         }
01055         match(PACKAGE);
01056         {
01057         switch ( LA(1)) {
01058         case BODY:
01059         {
01060             match(BODY);
01061             def_id(true);
01062             if (inputState->guessing==0) {
01063                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01064             }
01065             match(IS);
01066             pkg_body_part();
01067             if (inputState->guessing==0) {
01068                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01069             }
01070             end_id_opt();
01071             match(SEMI);
01072             if ( inputState->guessing==0 ) {
01073 #line 143 "ada.g"
01074                 Set(pkg_AST, PACKAGE_BODY);
01075 #line 1076 "AdaParser.cpp"
01076             }
01077             break;
01078         }
01079         case IDENTIFIER:
01080         {
01081             def_id(true);
01082             if (inputState->guessing==0) {
01083                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01084             }
01085             spec_decl_part(pkg_AST);
01086             if (inputState->guessing==0) {
01087                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01088             }
01089             break;
01090         }
01091         default:
01092         {
01093             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01094         }
01095         }
01096         }
01097         lib_pkg_spec_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01098     }
01099     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01100         if( inputState->guessing == 0 ) {
01101             reportError(ex);
01102             consume();
01103             consumeUntil(_tokenSet_2);
01104         } else {
01105             throw;
01106         }
01107     }
01108     returnAST = lib_pkg_spec_or_body_AST;
01109 }
01110 
01111 void AdaParser::subprog_decl_or_rename_or_inst_or_body(
01112     bool lib_level
01113 ) {
01114     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01115     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01116     RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01117     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
01118     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01119     ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
01120     RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01121 #line 930 "ada.g"
01122     RefAdaAST t;
01123 #line 1124 "AdaParser.cpp"
01124     
01125     try {      // for error handling
01126         switch ( LA(1)) {
01127         case PROCEDURE:
01128         {
01129             p = LT(1);
01130             if ( inputState->guessing == 0 ) {
01131                 p_AST = astFactory->create(p);
01132                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
01133             }
01134             match(PROCEDURE);
01135             def_id(lib_level);
01136             if (inputState->guessing==0) {
01137                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01138             }
01139             {
01140             if ((LA(1) == IS) && (LA(2) == NEW)) {
01141                 generic_subp_inst();
01142                 if (inputState->guessing==0) {
01143                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01144                 }
01145                 if ( inputState->guessing==0 ) {
01146 #line 934 "ada.g"
01147                     Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
01148 #line 1149 "AdaParser.cpp"
01149                 }
01150             }
01151             else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) {
01152                 formal_part_opt();
01153                 if (inputState->guessing==0) {
01154                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01155                 }
01156                 {
01157                 switch ( LA(1)) {
01158                 case RENAMES:
01159                 {
01160                     renames();
01161                     if (inputState->guessing==0) {
01162                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01163                     }
01164                     if ( inputState->guessing==0 ) {
01165 #line 936 "ada.g"
01166                         Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
01167 #line 1168 "AdaParser.cpp"
01168                     }
01169                     break;
01170                 }
01171                 case IS:
01172                 {
01173                     match(IS);
01174                     {
01175                     switch ( LA(1)) {
01176                     case SEPARATE:
01177                     case ABSTRACT:
01178                     {
01179                         separate_or_abstract(p_AST);
01180                         if (inputState->guessing==0) {
01181                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01182                         }
01183                         break;
01184                     }
01185                     case PRAGMA:
01186                     case IDENTIFIER:
01187                     case USE:
01188                     case TYPE:
01189                     case PACKAGE:
01190                     case PROCEDURE:
01191                     case FUNCTION:
01192                     case TASK:
01193                     case PROTECTED:
01194                     case FOR:
01195                     case SUBTYPE:
01196                     case GENERIC:
01197                     case BEGIN:
01198                     {
01199                         body_part();
01200                         if (inputState->guessing==0) {
01201                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01202                         }
01203                         if ( inputState->guessing==0 ) {
01204 #line 938 "ada.g"
01205                             Set(p_AST, PROCEDURE_BODY);
01206 #line 1207 "AdaParser.cpp"
01207                         }
01208                         break;
01209                     }
01210                     default:
01211                     {
01212                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01213                     }
01214                     }
01215                     }
01216                     break;
01217                 }
01218                 case SEMI:
01219                 {
01220                     if ( inputState->guessing==0 ) {
01221 #line 940 "ada.g"
01222                         pop_def_id();
01223                                         Set(p_AST, PROCEDURE_DECLARATION);
01224 #line 1225 "AdaParser.cpp"
01225                     }
01226                     break;
01227                 }
01228                 default:
01229                 {
01230                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01231                 }
01232                 }
01233                 }
01234                 match(SEMI);
01235             }
01236             else {
01237                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01238             }
01239             
01240             }
01241             subprog_decl_or_rename_or_inst_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01242             break;
01243         }
01244         case FUNCTION:
01245         {
01246             f = LT(1);
01247             if ( inputState->guessing == 0 ) {
01248                 f_AST = astFactory->create(f);
01249                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
01250             }
01251             match(FUNCTION);
01252             def_designator(lib_level);
01253             if (inputState->guessing==0) {
01254                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01255             }
01256             {
01257             switch ( LA(1)) {
01258             case IS:
01259             {
01260                 generic_subp_inst();
01261                 if (inputState->guessing==0) {
01262                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01263                 }
01264                 if ( inputState->guessing==0 ) {
01265 #line 947 "ada.g"
01266                     Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
01267 #line 1268 "AdaParser.cpp"
01268                 }
01269                 break;
01270             }
01271             case LPAREN:
01272             case RETURN:
01273             {
01274                 function_tail();
01275                 if (inputState->guessing==0) {
01276                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01277                 }
01278                 {
01279                 switch ( LA(1)) {
01280                 case RENAMES:
01281                 {
01282                     renames();
01283                     if (inputState->guessing==0) {
01284                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01285                     }
01286                     if ( inputState->guessing==0 ) {
01287 #line 949 "ada.g"
01288                         Set(f_AST, FUNCTION_RENAMING_DECLARATION);
01289 #line 1290 "AdaParser.cpp"
01290                     }
01291                     break;
01292                 }
01293                 case IS:
01294                 {
01295                     match(IS);
01296                     {
01297                     switch ( LA(1)) {
01298                     case SEPARATE:
01299                     case ABSTRACT:
01300                     {
01301                         separate_or_abstract(f_AST);
01302                         if (inputState->guessing==0) {
01303                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01304                         }
01305                         break;
01306                     }
01307                     case PRAGMA:
01308                     case IDENTIFIER:
01309                     case USE:
01310                     case TYPE:
01311                     case PACKAGE:
01312                     case PROCEDURE:
01313                     case FUNCTION:
01314                     case TASK:
01315                     case PROTECTED:
01316                     case FOR:
01317                     case SUBTYPE:
01318                     case GENERIC:
01319                     case BEGIN:
01320                     {
01321                         body_part();
01322                         if (inputState->guessing==0) {
01323                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01324                         }
01325                         if ( inputState->guessing==0 ) {
01326 #line 951 "ada.g"
01327                             Set(f_AST, FUNCTION_BODY);
01328 #line 1329 "AdaParser.cpp"
01329                         }
01330                         break;
01331                     }
01332                     default:
01333                     {
01334                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01335                     }
01336                     }
01337                     }
01338                     break;
01339                 }
01340                 case SEMI:
01341                 {
01342                     if ( inputState->guessing==0 ) {
01343 #line 953 "ada.g"
01344                         pop_def_id();
01345                                         Set(f_AST, FUNCTION_DECLARATION);
01346 #line 1347 "AdaParser.cpp"
01347                     }
01348                     break;
01349                 }
01350                 default:
01351                 {
01352                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01353                 }
01354                 }
01355                 }
01356                 match(SEMI);
01357                 break;
01358             }
01359             default:
01360             {
01361                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01362             }
01363             }
01364             }
01365             subprog_decl_or_rename_or_inst_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01366             break;
01367         }
01368         default:
01369         {
01370             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01371         }
01372         }
01373     }
01374     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01375         if( inputState->guessing == 0 ) {
01376             reportError(ex);
01377             consume();
01378             consumeUntil(_tokenSet_17);
01379         } else {
01380             throw;
01381         }
01382     }
01383     returnAST = subprog_decl_or_rename_or_inst_or_body_AST;
01384 }
01385 
01386 void AdaParser::generic_decl(
01387     bool lib_level
01388 ) {
01389     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01390     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01391     RefAdaAST generic_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01392     ANTLR_USE_NAMESPACE(antlr)RefToken  g = ANTLR_USE_NAMESPACE(antlr)nullToken;
01393     RefAdaAST g_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01394     
01395     try {      // for error handling
01396         g = LT(1);
01397         if ( inputState->guessing == 0 ) {
01398             g_AST = astFactory->create(g);
01399             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(g_AST.get()));
01400         }
01401         match(GENERIC);
01402         generic_formal_part_opt();
01403         if (inputState->guessing==0) {
01404             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01405         }
01406         {
01407         switch ( LA(1)) {
01408         case PACKAGE:
01409         {
01410             match(PACKAGE);
01411             def_id(lib_level);
01412             if (inputState->guessing==0) {
01413                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01414             }
01415             {
01416             switch ( LA(1)) {
01417             case RENAMES:
01418             {
01419                 renames();
01420                 if (inputState->guessing==0) {
01421                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01422                 }
01423                 if ( inputState->guessing==0 ) {
01424 #line 851 "ada.g"
01425                     Set(g_AST, GENERIC_PACKAGE_RENAMING);
01426 #line 1427 "AdaParser.cpp"
01427                 }
01428                 break;
01429             }
01430             case IS:
01431             {
01432                 match(IS);
01433                 pkg_spec_part();
01434                 if (inputState->guessing==0) {
01435                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01436                 }
01437                 if ( inputState->guessing==0 ) {
01438 #line 852 "ada.g"
01439                     Set(g_AST, GENERIC_PACKAGE_DECLARATION);
01440 #line 1441 "AdaParser.cpp"
01441                 }
01442                 break;
01443             }
01444             default:
01445             {
01446                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01447             }
01448             }
01449             }
01450             break;
01451         }
01452         case PROCEDURE:
01453         {
01454             match(PROCEDURE);
01455             def_id(lib_level);
01456             if (inputState->guessing==0) {
01457                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01458             }
01459             formal_part_opt();
01460             if (inputState->guessing==0) {
01461                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01462             }
01463             {
01464             switch ( LA(1)) {
01465             case RENAMES:
01466             {
01467                 renames();
01468                 if (inputState->guessing==0) {
01469                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01470                 }
01471                 if ( inputState->guessing==0 ) {
01472 #line 855 "ada.g"
01473                     Set(g_AST, GENERIC_PROCEDURE_RENAMING);
01474 #line 1475 "AdaParser.cpp"
01475                 }
01476                 break;
01477             }
01478             case SEMI:
01479             {
01480                 if ( inputState->guessing==0 ) {
01481 #line 858 "ada.g"
01482                     Set(g_AST, GENERIC_PROCEDURE_DECLARATION); pop_def_id();
01483 #line 1484 "AdaParser.cpp"
01484                 }
01485                 break;
01486             }
01487             default:
01488             {
01489                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01490             }
01491             }
01492             }
01493             break;
01494         }
01495         case FUNCTION:
01496         {
01497             match(FUNCTION);
01498             def_designator(lib_level);
01499             if (inputState->guessing==0) {
01500                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01501             }
01502             function_tail();
01503             if (inputState->guessing==0) {
01504                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01505             }
01506             {
01507             switch ( LA(1)) {
01508             case RENAMES:
01509             {
01510                 renames();
01511                 if (inputState->guessing==0) {
01512                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01513                 }
01514                 if ( inputState->guessing==0 ) {
01515 #line 861 "ada.g"
01516                     Set(g_AST, GENERIC_FUNCTION_RENAMING);
01517 #line 1518 "AdaParser.cpp"
01518                 }
01519                 break;
01520             }
01521             case SEMI:
01522             {
01523                 if ( inputState->guessing==0 ) {
01524 #line 864 "ada.g"
01525                     Set(g_AST, GENERIC_FUNCTION_DECLARATION); pop_def_id();
01526 #line 1527 "AdaParser.cpp"
01527                 }
01528                 break;
01529             }
01530             default:
01531             {
01532                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01533             }
01534             }
01535             }
01536             break;
01537         }
01538         default:
01539         {
01540             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01541         }
01542         }
01543         }
01544         match(SEMI);
01545         generic_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01546     }
01547     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01548         if( inputState->guessing == 0 ) {
01549             reportError(ex);
01550             consume();
01551             consumeUntil(_tokenSet_18);
01552         } else {
01553             throw;
01554         }
01555     }
01556     returnAST = generic_decl_AST;
01557 }
01558 
01559 void AdaParser::def_id(
01560     bool lib_level
01561 ) {
01562     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01563     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01564     RefAdaAST def_id_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01565     RefAdaAST cn_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01566     ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
01567     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01568     
01569     try {      // for error handling
01570         if (((LA(1) == IDENTIFIER) && (_tokenSet_19.member(LA(2))))&&( lib_level )) {
01571             compound_name();
01572             if (inputState->guessing==0) {
01573                 cn_AST = returnAST;
01574                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01575             }
01576             if ( inputState->guessing==0 ) {
01577 #line 171 "ada.g"
01578                 push_def_id(cn_AST);
01579 #line 1580 "AdaParser.cpp"
01580             }
01581             def_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01582         }
01583         else if (((LA(1) == IDENTIFIER) && (_tokenSet_20.member(LA(2))))&&( !lib_level )) {
01584             n = LT(1);
01585             if ( inputState->guessing == 0 ) {
01586                 n_AST = astFactory->create(n);
01587                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
01588             }
01589             match(IDENTIFIER);
01590             if ( inputState->guessing==0 ) {
01591 #line 172 "ada.g"
01592                 push_def_id(n_AST);
01593 #line 1594 "AdaParser.cpp"
01594             }
01595             def_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01596         }
01597         else {
01598             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01599         }
01600         
01601     }
01602     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01603         if( inputState->guessing == 0 ) {
01604             reportError(ex);
01605             consume();
01606             consumeUntil(_tokenSet_20);
01607         } else {
01608             throw;
01609         }
01610     }
01611     returnAST = def_id_AST;
01612 }
01613 
01614 void AdaParser::pkg_body_part() {
01615     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01616     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01617     RefAdaAST pkg_body_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01618     
01619     try {      // for error handling
01620         declarative_part();
01621         if (inputState->guessing==0) {
01622             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01623         }
01624         block_body_opt();
01625         if (inputState->guessing==0) {
01626             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01627         }
01628         pkg_body_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01629     }
01630     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01631         if( inputState->guessing == 0 ) {
01632             reportError(ex);
01633             consume();
01634             consumeUntil(_tokenSet_21);
01635         } else {
01636             throw;
01637         }
01638     }
01639     returnAST = pkg_body_part_AST;
01640 }
01641 
01642 void AdaParser::end_id_opt() {
01643     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01644     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01645     RefAdaAST end_id_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01646     
01647     try {      // for error handling
01648         match(END);
01649         id_opt();
01650         if (inputState->guessing==0) {
01651             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01652         }
01653         end_id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01654     }
01655     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01656         if( inputState->guessing == 0 ) {
01657             reportError(ex);
01658             consume();
01659             consumeUntil(_tokenSet_4);
01660         } else {
01661             throw;
01662         }
01663     }
01664     returnAST = end_id_opt_AST;
01665 }
01666 
01667 void AdaParser::spec_decl_part(
01668     RefAdaAST pkg
01669 ) {
01670     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01671     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01672     RefAdaAST spec_decl_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01673     
01674     try {      // for error handling
01675         {
01676         switch ( LA(1)) {
01677         case IS:
01678         {
01679             match(IS);
01680             {
01681             switch ( LA(1)) {
01682             case NEW:
01683             {
01684                 generic_inst();
01685                 if (inputState->guessing==0) {
01686                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01687                 }
01688                 if ( inputState->guessing==0 ) {
01689 #line 363 "ada.g"
01690                     Set(pkg, GENERIC_PACKAGE_INSTANTIATION);
01691 #line 1692 "AdaParser.cpp"
01692                 }
01693                 break;
01694             }
01695             case PRAGMA:
01696             case IDENTIFIER:
01697             case USE:
01698             case TYPE:
01699             case PRIVATE:
01700             case PACKAGE:
01701             case PROCEDURE:
01702             case FUNCTION:
01703             case TASK:
01704             case PROTECTED:
01705             case FOR:
01706             case END:
01707             case SUBTYPE:
01708             case GENERIC:
01709             {
01710                 pkg_spec_part();
01711                 if (inputState->guessing==0) {
01712                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01713                 }
01714                 if ( inputState->guessing==0 ) {
01715 #line 364 "ada.g"
01716                     Set(pkg, PACKAGE_SPECIFICATION);
01717 #line 1718 "AdaParser.cpp"
01718                 }
01719                 break;
01720             }
01721             default:
01722             {
01723                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01724             }
01725             }
01726             }
01727             break;
01728         }
01729         case RENAMES:
01730         {
01731             renames();
01732             if (inputState->guessing==0) {
01733                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01734             }
01735             if ( inputState->guessing==0 ) {
01736 #line 366 "ada.g"
01737                 Set(pkg, PACKAGE_RENAMING_DECLARATION);
01738 #line 1739 "AdaParser.cpp"
01739             }
01740             break;
01741         }
01742         default:
01743         {
01744             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01745         }
01746         }
01747         }
01748         match(SEMI);
01749         spec_decl_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01750     }
01751     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01752         if( inputState->guessing == 0 ) {
01753             reportError(ex);
01754             consume();
01755             consumeUntil(_tokenSet_18);
01756         } else {
01757             throw;
01758         }
01759     }
01760     returnAST = spec_decl_part_AST;
01761 }
01762 
01763 void AdaParser::subprog_decl(
01764     bool lib_level
01765 ) {
01766     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01767     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01768     RefAdaAST subprog_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01769     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
01770     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01771     ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
01772     RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01773 #line 148 "ada.g"
01774     RefAdaAST t;
01775 #line 1776 "AdaParser.cpp"
01776     
01777     try {      // for error handling
01778         switch ( LA(1)) {
01779         case PROCEDURE:
01780         {
01781             p = LT(1);
01782             if ( inputState->guessing == 0 ) {
01783                 p_AST = astFactory->create(p);
01784                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
01785             }
01786             match(PROCEDURE);
01787             def_id(lib_level);
01788             if (inputState->guessing==0) {
01789                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01790             }
01791             {
01792             if ((LA(1) == IS) && (LA(2) == NEW)) {
01793                 generic_subp_inst();
01794                 if (inputState->guessing==0) {
01795                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01796                 }
01797                 if ( inputState->guessing==0 ) {
01798 #line 152 "ada.g"
01799                     Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION);
01800 #line 1801 "AdaParser.cpp"
01801                 }
01802             }
01803             else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_22.member(LA(2)))) {
01804                 formal_part_opt();
01805                 if (inputState->guessing==0) {
01806                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01807                 }
01808                 {
01809                 switch ( LA(1)) {
01810                 case RENAMES:
01811                 {
01812                     renames();
01813                     if (inputState->guessing==0) {
01814                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01815                     }
01816                     if ( inputState->guessing==0 ) {
01817 #line 154 "ada.g"
01818                         Set(p_AST, PROCEDURE_RENAMING_DECLARATION);
01819 #line 1820 "AdaParser.cpp"
01820                     }
01821                     break;
01822                 }
01823                 case SEMI:
01824                 case IS:
01825                 {
01826                     is_separate_or_abstract_or_decl(p_AST);
01827                     if (inputState->guessing==0) {
01828                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01829                     }
01830                     break;
01831                 }
01832                 default:
01833                 {
01834                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01835                 }
01836                 }
01837                 }
01838                 match(SEMI);
01839             }
01840             else {
01841                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01842             }
01843             
01844             }
01845             subprog_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01846             break;
01847         }
01848         case FUNCTION:
01849         {
01850             f = LT(1);
01851             if ( inputState->guessing == 0 ) {
01852                 f_AST = astFactory->create(f);
01853                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
01854             }
01855             match(FUNCTION);
01856             def_designator(lib_level);
01857             if (inputState->guessing==0) {
01858                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01859             }
01860             {
01861             switch ( LA(1)) {
01862             case IS:
01863             {
01864                 generic_subp_inst();
01865                 if (inputState->guessing==0) {
01866                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01867                 }
01868                 if ( inputState->guessing==0 ) {
01869 #line 161 "ada.g"
01870                     Set(f_AST, GENERIC_FUNCTION_INSTANTIATION);
01871 #line 1872 "AdaParser.cpp"
01872                 }
01873                 break;
01874             }
01875             case LPAREN:
01876             case RETURN:
01877             {
01878                 function_tail();
01879                 if (inputState->guessing==0) {
01880                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01881                 }
01882                 {
01883                 switch ( LA(1)) {
01884                 case RENAMES:
01885                 {
01886                     renames();
01887                     if (inputState->guessing==0) {
01888                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01889                     }
01890                     if ( inputState->guessing==0 ) {
01891 #line 163 "ada.g"
01892                         Set(f_AST, FUNCTION_RENAMING_DECLARATION);
01893 #line 1894 "AdaParser.cpp"
01894                     }
01895                     break;
01896                 }
01897                 case SEMI:
01898                 case IS:
01899                 {
01900                     is_separate_or_abstract_or_decl(f_AST);
01901                     if (inputState->guessing==0) {
01902                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01903                     }
01904                     break;
01905                 }
01906                 default:
01907                 {
01908                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01909                 }
01910                 }
01911                 }
01912                 match(SEMI);
01913                 break;
01914             }
01915             default:
01916             {
01917                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01918             }
01919             }
01920             }
01921             subprog_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01922             break;
01923         }
01924         default:
01925         {
01926             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01927         }
01928         }
01929     }
01930     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01931         if( inputState->guessing == 0 ) {
01932             reportError(ex);
01933             consume();
01934             consumeUntil(_tokenSet_23);
01935         } else {
01936             throw;
01937         }
01938     }
01939     returnAST = subprog_decl_AST;
01940 }
01941 
01942 void AdaParser::generic_subp_inst() {
01943     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01944     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01945     RefAdaAST generic_subp_inst_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01946     
01947     try {      // for error handling
01948         match(IS);
01949         generic_inst();
01950         if (inputState->guessing==0) {
01951             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01952         }
01953         match(SEMI);
01954         generic_subp_inst_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
01955     }
01956     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01957         if( inputState->guessing == 0 ) {
01958             reportError(ex);
01959             consume();
01960             consumeUntil(_tokenSet_18);
01961         } else {
01962             throw;
01963         }
01964     }
01965     returnAST = generic_subp_inst_AST;
01966 }
01967 
01968 void AdaParser::formal_part_opt() {
01969     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01970     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01971     RefAdaAST formal_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01972     
01973     try {      // for error handling
01974         {
01975         switch ( LA(1)) {
01976         case LPAREN:
01977         {
01978             match(LPAREN);
01979             parameter_specification();
01980             if (inputState->guessing==0) {
01981                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01982             }
01983             { // ( ... )*
01984             for (;;) {
01985                 if ((LA(1) == SEMI)) {
01986                     match(SEMI);
01987                     parameter_specification();
01988                     if (inputState->guessing==0) {
01989                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01990                     }
01991                 }
01992                 else {
01993                     goto _loop74;
01994                 }
01995                 
01996             }
01997             _loop74:;
01998             } // ( ... )*
01999             match(RPAREN);
02000             break;
02001         }
02002         case SEMI:
02003         case IS:
02004         case RENAMES:
02005         case WHEN:
02006         case DO:
02007         {
02008             break;
02009         }
02010         default:
02011         {
02012             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02013         }
02014         }
02015         }
02016         if ( inputState->guessing==0 ) {
02017             formal_part_opt_AST = RefAdaAST(currentAST.root);
02018 #line 234 "ada.g"
02019             formal_part_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(formal_part_opt_AST.get()))));
02020 #line 2021 "AdaParser.cpp"
02021             currentAST.root = formal_part_opt_AST;
02022             if ( formal_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
02023                 formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02024                   currentAST.child = formal_part_opt_AST->getFirstChild();
02025             else
02026                 currentAST.child = formal_part_opt_AST;
02027             currentAST.advanceChildToEnd();
02028         }
02029         formal_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02030     }
02031     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02032         if( inputState->guessing == 0 ) {
02033             reportError(ex);
02034             consume();
02035             consumeUntil(_tokenSet_24);
02036         } else {
02037             throw;
02038         }
02039     }
02040     returnAST = formal_part_opt_AST;
02041 }
02042 
02043 void AdaParser::renames() {
02044     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02045     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02046     RefAdaAST renames_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02047 #line 257 "ada.g"
02048     RefAdaAST dummy;
02049 #line 2050 "AdaParser.cpp"
02050     
02051     try {      // for error handling
02052         match(RENAMES);
02053         {
02054         switch ( LA(1)) {
02055         case IDENTIFIER:
02056         {
02057             name();
02058             if (inputState->guessing==0) {
02059                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02060             }
02061             break;
02062         }
02063         case CHAR_STRING:
02064         {
02065             dummy=definable_operator_symbol();
02066             if (inputState->guessing==0) {
02067                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02068             }
02069             break;
02070         }
02071         default:
02072         {
02073             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02074         }
02075         }
02076         }
02077         if ( inputState->guessing==0 ) {
02078 #line 261 "ada.g"
02079             pop_def_id();
02080 #line 2081 "AdaParser.cpp"
02081         }
02082         renames_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02083     }
02084     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02085         if( inputState->guessing == 0 ) {
02086             reportError(ex);
02087             consume();
02088             consumeUntil(_tokenSet_4);
02089         } else {
02090             throw;
02091         }
02092     }
02093     returnAST = renames_AST;
02094 }
02095 
02096 void AdaParser::is_separate_or_abstract_or_decl(
02097     RefAdaAST t
02098 ) {
02099     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02100     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02101     RefAdaAST is_separate_or_abstract_or_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02102     
02103     try {      // for error handling
02104         switch ( LA(1)) {
02105         case IS:
02106         {
02107             match(IS);
02108             separate_or_abstract(t);
02109             break;
02110         }
02111         case SEMI:
02112         {
02113             if ( inputState->guessing==0 ) {
02114 #line 304 "ada.g"
02115                 pop_def_id();
02116                         if (t->getType() == AdaTokenTypes::PROCEDURE)
02117                           Set(t, PROCEDURE_DECLARATION);
02118                         else
02119                           Set(t, FUNCTION_DECLARATION);
02120                     
02121 #line 2122 "AdaParser.cpp"
02122             }
02123             break;
02124         }
02125         default:
02126         {
02127             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02128         }
02129         }
02130     }
02131     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02132         if( inputState->guessing == 0 ) {
02133             reportError(ex);
02134             consume();
02135             consumeUntil(_tokenSet_4);
02136         } else {
02137             throw;
02138         }
02139     }
02140     returnAST = is_separate_or_abstract_or_decl_AST;
02141 }
02142 
02143 void AdaParser::def_designator(
02144     bool lib_level
02145 ) {
02146     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02147     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02148     RefAdaAST def_designator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02149     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02150 #line 329 "ada.g"
02151     RefAdaAST d;
02152 #line 2153 "AdaParser.cpp"
02153     
02154     try {      // for error handling
02155         if (((LA(1) == IDENTIFIER) && (_tokenSet_25.member(LA(2))))&&( lib_level )) {
02156             compound_name();
02157             if (inputState->guessing==0) {
02158                 n_AST = returnAST;
02159                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02160             }
02161             if ( inputState->guessing==0 ) {
02162 #line 331 "ada.g"
02163                 push_def_id(n_AST);
02164 #line 2165 "AdaParser.cpp"
02165             }
02166             def_designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02167         }
02168         else if (((LA(1) == IDENTIFIER || LA(1) == CHAR_STRING) && (LA(2) == LPAREN || LA(2) == IS || LA(2) == RETURN))&&( !lib_level )) {
02169             d=designator();
02170             if (inputState->guessing==0) {
02171                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02172             }
02173             if ( inputState->guessing==0 ) {
02174 #line 332 "ada.g"
02175                 push_def_id(d);
02176 #line 2177 "AdaParser.cpp"
02177             }
02178             def_designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02179         }
02180         else {
02181             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02182         }
02183         
02184     }
02185     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02186         if( inputState->guessing == 0 ) {
02187             reportError(ex);
02188             consume();
02189             consumeUntil(_tokenSet_26);
02190         } else {
02191             throw;
02192         }
02193     }
02194     returnAST = def_designator_AST;
02195 }
02196 
02197 void AdaParser::function_tail() {
02198     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02199     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02200     RefAdaAST function_tail_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02201     
02202     try {      // for error handling
02203         func_formal_part_opt();
02204         if (inputState->guessing==0) {
02205             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02206         }
02207         match(RETURN);
02208         subtype_mark();
02209         if (inputState->guessing==0) {
02210             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02211         }
02212         function_tail_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02213     }
02214     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02215         if( inputState->guessing == 0 ) {
02216             reportError(ex);
02217             consume();
02218             consumeUntil(_tokenSet_27);
02219         } else {
02220             throw;
02221         }
02222     }
02223     returnAST = function_tail_AST;
02224 }
02225 
02226 void AdaParser::generic_inst() {
02227     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02228     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02229     RefAdaAST generic_inst_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02230     
02231     try {      // for error handling
02232         match(NEW);
02233         compound_name();
02234         if (inputState->guessing==0) {
02235             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02236         }
02237         {
02238         switch ( LA(1)) {
02239         case LPAREN:
02240         {
02241             match(LPAREN);
02242             value_s();
02243             if (inputState->guessing==0) {
02244                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02245             }
02246             match(RPAREN);
02247             break;
02248         }
02249         case SEMI:
02250         {
02251             break;
02252         }
02253         default:
02254         {
02255             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02256         }
02257         }
02258         }
02259         if ( inputState->guessing==0 ) {
02260 #line 179 "ada.g"
02261             pop_def_id();
02262 #line 2263 "AdaParser.cpp"
02263         }
02264         generic_inst_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02265     }
02266     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02267         if( inputState->guessing == 0 ) {
02268             reportError(ex);
02269             consume();
02270             consumeUntil(_tokenSet_4);
02271         } else {
02272             throw;
02273         }
02274     }
02275     returnAST = generic_inst_AST;
02276 }
02277 
02278 void AdaParser::value_s() {
02279     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02280     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02281     RefAdaAST value_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02282     
02283     try {      // for error handling
02284         value();
02285         if (inputState->guessing==0) {
02286             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02287         }
02288         { // ( ... )*
02289         for (;;) {
02290             if ((LA(1) == COMMA)) {
02291                 match(COMMA);
02292                 value();
02293                 if (inputState->guessing==0) {
02294                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02295                 }
02296             }
02297             else {
02298                 goto _loop440;
02299             }
02300             
02301         }
02302         _loop440:;
02303         } // ( ... )*
02304         if ( inputState->guessing==0 ) {
02305             value_s_AST = RefAdaAST(currentAST.root);
02306 #line 1380 "ada.g"
02307             value_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VALUES,"VALUES").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(value_s_AST.get()))));
02308 #line 2309 "AdaParser.cpp"
02309             currentAST.root = value_s_AST;
02310             if ( value_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
02311                 value_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02312                   currentAST.child = value_s_AST->getFirstChild();
02313             else
02314                 currentAST.child = value_s_AST;
02315             currentAST.advanceChildToEnd();
02316         }
02317         value_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02318     }
02319     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02320         if( inputState->guessing == 0 ) {
02321             reportError(ex);
02322             consume();
02323             consumeUntil(_tokenSet_28);
02324         } else {
02325             throw;
02326         }
02327     }
02328     returnAST = value_s_AST;
02329 }
02330 
02331 void AdaParser::parenth_values() {
02332     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02333     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02334     RefAdaAST parenth_values_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02335     
02336     try {      // for error handling
02337         match(LPAREN);
02338         value();
02339         if (inputState->guessing==0) {
02340             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02341         }
02342         { // ( ... )*
02343         for (;;) {
02344             if ((LA(1) == COMMA)) {
02345                 match(COMMA);
02346                 value();
02347                 if (inputState->guessing==0) {
02348                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02349                 }
02350             }
02351             else {
02352                 goto _loop50;
02353             }
02354             
02355         }
02356         _loop50:;
02357         } // ( ... )*
02358         match(RPAREN);
02359         parenth_values_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02360     }
02361     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02362         if( inputState->guessing == 0 ) {
02363             reportError(ex);
02364             consume();
02365             consumeUntil(_tokenSet_4);
02366         } else {
02367             throw;
02368         }
02369     }
02370     returnAST = parenth_values_AST;
02371 }
02372 
02373 void AdaParser::value() {
02374     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02375     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02376     RefAdaAST value_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02377     
02378     try {      // for error handling
02379         {
02380         switch ( LA(1)) {
02381         case OTHERS:
02382         {
02383             RefAdaAST tmp61_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02384             if ( inputState->guessing == 0 ) {
02385                 tmp61_AST = astFactory->create(LT(1));
02386                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp61_AST.get()));
02387             }
02388             match(OTHERS);
02389             match(RIGHT_SHAFT);
02390             expression();
02391             if (inputState->guessing==0) {
02392                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02393             }
02394             break;
02395         }
02396         case IDENTIFIER:
02397         case LPAREN:
02398         case NEW:
02399         case CHARACTER_LITERAL:
02400         case CHAR_STRING:
02401         case NuLL:
02402         case NOT:
02403         case PLUS:
02404         case MINUS:
02405         case ABS:
02406         case NUMERIC_LIT:
02407         {
02408             ranged_expr_s();
02409             if (inputState->guessing==0) {
02410                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02411             }
02412             {
02413             switch ( LA(1)) {
02414             case RIGHT_SHAFT:
02415             {
02416                 RefAdaAST tmp63_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02417                 if ( inputState->guessing == 0 ) {
02418                     tmp63_AST = astFactory->create(LT(1));
02419                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp63_AST.get()));
02420                 }
02421                 match(RIGHT_SHAFT);
02422                 expression();
02423                 if (inputState->guessing==0) {
02424                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02425                 }
02426                 break;
02427             }
02428             case COMMA:
02429             case RPAREN:
02430             case WITH:
02431             {
02432                 break;
02433             }
02434             default:
02435             {
02436                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02437             }
02438             }
02439             }
02440             break;
02441         }
02442         default:
02443         {
02444             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02445         }
02446         }
02447         }
02448         value_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02449     }
02450     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02451         if( inputState->guessing == 0 ) {
02452             reportError(ex);
02453             consume();
02454             consumeUntil(_tokenSet_29);
02455         } else {
02456             throw;
02457         }
02458     }
02459     returnAST = value_AST;
02460 }
02461 
02462 void AdaParser::ranged_expr_s() {
02463     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02464     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02465     RefAdaAST ranged_expr_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02466     
02467     try {      // for error handling
02468         ranged_expr();
02469         if (inputState->guessing==0) {
02470             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02471         }
02472         { // ( ... )*
02473         for (;;) {
02474             if ((LA(1) == PIPE)) {
02475                 RefAdaAST tmp64_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02476                 if ( inputState->guessing == 0 ) {
02477                     tmp64_AST = astFactory->create(LT(1));
02478                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp64_AST.get()));
02479                 }
02480                 match(PIPE);
02481                 ranged_expr();
02482                 if (inputState->guessing==0) {
02483                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02484                 }
02485             }
02486             else {
02487                 goto _loop56;
02488             }
02489             
02490         }
02491         _loop56:;
02492         } // ( ... )*
02493         ranged_expr_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02494     }
02495     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02496         if( inputState->guessing == 0 ) {
02497             reportError(ex);
02498             consume();
02499             consumeUntil(_tokenSet_30);
02500         } else {
02501             throw;
02502         }
02503     }
02504     returnAST = ranged_expr_s_AST;
02505 }
02506 
02507 void AdaParser::ranged_expr() {
02508     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02509     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02510     RefAdaAST ranged_expr_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02511     
02512     try {      // for error handling
02513         expression();
02514         if (inputState->guessing==0) {
02515             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02516         }
02517         {
02518         switch ( LA(1)) {
02519         case DOT_DOT:
02520         {
02521             RefAdaAST tmp65_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02522             if ( inputState->guessing == 0 ) {
02523                 tmp65_AST = astFactory->create(LT(1));
02524                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp65_AST.get()));
02525             }
02526             match(DOT_DOT);
02527             simple_expression();
02528             if (inputState->guessing==0) {
02529                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02530             }
02531             break;
02532         }
02533         case RANGE:
02534         {
02535             RefAdaAST tmp66_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02536             if ( inputState->guessing == 0 ) {
02537                 tmp66_AST = astFactory->create(LT(1));
02538                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp66_AST.get()));
02539             }
02540             match(RANGE);
02541             range();
02542             if (inputState->guessing==0) {
02543                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02544             }
02545             break;
02546         }
02547         case COMMA:
02548         case RPAREN:
02549         case RIGHT_SHAFT:
02550         case WITH:
02551         case PIPE:
02552         {
02553             break;
02554         }
02555         default:
02556         {
02557             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02558         }
02559         }
02560         }
02561         ranged_expr_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02562     }
02563     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02564         if( inputState->guessing == 0 ) {
02565             reportError(ex);
02566             consume();
02567             consumeUntil(_tokenSet_31);
02568         } else {
02569             throw;
02570         }
02571     }
02572     returnAST = ranged_expr_AST;
02573 }
02574 
02575 void AdaParser::simple_expression() {
02576     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02577     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02578     RefAdaAST simple_expression_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02579     
02580     try {      // for error handling
02581         signed_term();
02582         if (inputState->guessing==0) {
02583             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02584         }
02585         { // ( ... )*
02586         for (;;) {
02587             switch ( LA(1)) {
02588             case PLUS:
02589             {
02590                 RefAdaAST tmp67_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02591                 if ( inputState->guessing == 0 ) {
02592                     tmp67_AST = astFactory->create(LT(1));
02593                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp67_AST.get()));
02594                 }
02595                 match(PLUS);
02596                 signed_term();
02597                 if (inputState->guessing==0) {
02598                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02599                 }
02600                 break;
02601             }
02602             case MINUS:
02603             {
02604                 RefAdaAST tmp68_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02605                 if ( inputState->guessing == 0 ) {
02606                     tmp68_AST = astFactory->create(LT(1));
02607                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp68_AST.get()));
02608                 }
02609                 match(MINUS);
02610                 signed_term();
02611                 if (inputState->guessing==0) {
02612                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02613                 }
02614                 break;
02615             }
02616             case CONCAT:
02617             {
02618                 RefAdaAST tmp69_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02619                 if ( inputState->guessing == 0 ) {
02620                     tmp69_AST = astFactory->create(LT(1));
02621                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp69_AST.get()));
02622                 }
02623                 match(CONCAT);
02624                 signed_term();
02625                 if (inputState->guessing==0) {
02626                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02627                 }
02628                 break;
02629             }
02630             default:
02631             {
02632                 goto _loop453;
02633             }
02634             }
02635         }
02636         _loop453:;
02637         } // ( ... )*
02638         simple_expression_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02639     }
02640     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02641         if( inputState->guessing == 0 ) {
02642             reportError(ex);
02643             consume();
02644             consumeUntil(_tokenSet_32);
02645         } else {
02646             throw;
02647         }
02648     }
02649     returnAST = simple_expression_AST;
02650 }
02651 
02652 void AdaParser::range() {
02653     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02654     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02655     RefAdaAST range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02656     
02657     try {      // for error handling
02658         {
02659         bool synPredMatched63 = false;
02660         if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) {
02661             int _m63 = mark();
02662             synPredMatched63 = true;
02663             inputState->guessing++;
02664             try {
02665                 {
02666                 range_dots();
02667                 }
02668             }
02669             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
02670                 synPredMatched63 = false;
02671             }
02672             rewind(_m63);
02673             inputState->guessing--;
02674         }
02675         if ( synPredMatched63 ) {
02676             range_dots();
02677             if (inputState->guessing==0) {
02678                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02679             }
02680         }
02681         else if ((LA(1) == IDENTIFIER) && (LA(2) == LPAREN || LA(2) == DOT || LA(2) == TIC)) {
02682             range_attrib_ref();
02683             if (inputState->guessing==0) {
02684                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02685             }
02686         }
02687         else {
02688             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02689         }
02690         
02691         }
02692         range_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02693     }
02694     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02695         if( inputState->guessing == 0 ) {
02696             reportError(ex);
02697             consume();
02698             consumeUntil(_tokenSet_34);
02699         } else {
02700             throw;
02701         }
02702     }
02703     returnAST = range_AST;
02704 }
02705 
02706 void AdaParser::range_constraint() {
02707     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02708     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02709     RefAdaAST range_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02710     
02711     try {      // for error handling
02712         match(RANGE);
02713         range();
02714         if (inputState->guessing==0) {
02715             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02716         }
02717         range_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02718     }
02719     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02720         if( inputState->guessing == 0 ) {
02721             reportError(ex);
02722             consume();
02723             consumeUntil(_tokenSet_35);
02724         } else {
02725             throw;
02726         }
02727     }
02728     returnAST = range_constraint_AST;
02729 }
02730 
02731 void AdaParser::range_dots() {
02732     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02733     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02734     RefAdaAST range_dots_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02735     
02736     try {      // for error handling
02737         simple_expression();
02738         if (inputState->guessing==0) {
02739             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02740         }
02741         RefAdaAST tmp71_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02742         if ( inputState->guessing == 0 ) {
02743             tmp71_AST = astFactory->create(LT(1));
02744             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp71_AST.get()));
02745         }
02746         match(DOT_DOT);
02747         simple_expression();
02748         if (inputState->guessing==0) {
02749             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02750         }
02751         range_dots_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02752     }
02753     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02754         if( inputState->guessing == 0 ) {
02755             reportError(ex);
02756             consume();
02757             consumeUntil(_tokenSet_34);
02758         } else {
02759             throw;
02760         }
02761     }
02762     returnAST = range_dots_AST;
02763 }
02764 
02765 void AdaParser::range_attrib_ref() {
02766     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02767     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02768     RefAdaAST range_attrib_ref_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02769     ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
02770     RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02771     
02772     try {      // for error handling
02773         prefix();
02774         if (inputState->guessing==0) {
02775             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02776         }
02777         match(TIC);
02778         r = LT(1);
02779         if ( inputState->guessing == 0 ) {
02780             r_AST = astFactory->create(r);
02781             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
02782         }
02783         match(RANGE);
02784         {
02785         switch ( LA(1)) {
02786         case LPAREN:
02787         {
02788             match(LPAREN);
02789             expression();
02790             if (inputState->guessing==0) {
02791                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02792             }
02793             match(RPAREN);
02794             break;
02795         }
02796         case SEMI:
02797         case COMMA:
02798         case RPAREN:
02799         case RIGHT_SHAFT:
02800         case WITH:
02801         case RANGE:
02802         case DIGITS:
02803         case IS:
02804         case PIPE:
02805         case DOT_DOT:
02806         case ASSIGN:
02807         case THEN:
02808         case LOOP:
02809         case OR:
02810         case AND:
02811         case XOR:
02812         {
02813             break;
02814         }
02815         default:
02816         {
02817             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02818         }
02819         }
02820         }
02821         if ( inputState->guessing==0 ) {
02822 #line 218 "ada.g"
02823             Set(r_AST, RANGE_ATTRIBUTE_REFERENCE);
02824 #line 2825 "AdaParser.cpp"
02825         }
02826         range_attrib_ref_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02827     }
02828     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02829         if( inputState->guessing == 0 ) {
02830             reportError(ex);
02831             consume();
02832             consumeUntil(_tokenSet_34);
02833         } else {
02834             throw;
02835         }
02836     }
02837     returnAST = range_attrib_ref_AST;
02838 }
02839 
02840 void AdaParser::prefix() {
02841     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02842     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02843     RefAdaAST prefix_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02844     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
02845     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02846     
02847     try {      // for error handling
02848         RefAdaAST tmp75_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02849         if ( inputState->guessing == 0 ) {
02850             tmp75_AST = astFactory->create(LT(1));
02851             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp75_AST.get()));
02852         }
02853         match(IDENTIFIER);
02854         { // ( ... )*
02855         for (;;) {
02856             switch ( LA(1)) {
02857             case DOT:
02858             {
02859                 RefAdaAST tmp76_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02860                 if ( inputState->guessing == 0 ) {
02861                     tmp76_AST = astFactory->create(LT(1));
02862                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp76_AST.get()));
02863                 }
02864                 match(DOT);
02865                 {
02866                 switch ( LA(1)) {
02867                 case ALL:
02868                 {
02869                     RefAdaAST tmp77_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02870                     if ( inputState->guessing == 0 ) {
02871                         tmp77_AST = astFactory->create(LT(1));
02872                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp77_AST.get()));
02873                     }
02874                     match(ALL);
02875                     break;
02876                 }
02877                 case IDENTIFIER:
02878                 {
02879                     RefAdaAST tmp78_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02880                     if ( inputState->guessing == 0 ) {
02881                         tmp78_AST = astFactory->create(LT(1));
02882                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp78_AST.get()));
02883                     }
02884                     match(IDENTIFIER);
02885                     break;
02886                 }
02887                 default:
02888                 {
02889                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02890                 }
02891                 }
02892                 }
02893                 break;
02894             }
02895             case LPAREN:
02896             {
02897                 p = LT(1);
02898                 if ( inputState->guessing == 0 ) {
02899                     p_AST = astFactory->create(p);
02900                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
02901                 }
02902                 match(LPAREN);
02903                 value_s();
02904                 if (inputState->guessing==0) {
02905                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02906                 }
02907                 match(RPAREN);
02908                 if ( inputState->guessing==0 ) {
02909 #line 227 "ada.g"
02910                     Set(p_AST, INDEXED_COMPONENT);
02911 #line 2912 "AdaParser.cpp"
02912                 }
02913                 break;
02914             }
02915             default:
02916             {
02917                 goto _loop70;
02918             }
02919             }
02920         }
02921         _loop70:;
02922         } // ( ... )*
02923         prefix_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02924     }
02925     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02926         if( inputState->guessing == 0 ) {
02927             reportError(ex);
02928             consume();
02929             consumeUntil(_tokenSet_36);
02930         } else {
02931             throw;
02932         }
02933     }
02934     returnAST = prefix_AST;
02935 }
02936 
02937 void AdaParser::parameter_specification() {
02938     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02939     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02940     RefAdaAST parameter_specification_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02941     
02942     try {      // for error handling
02943         def_ids_colon();
02944         if (inputState->guessing==0) {
02945             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02946         }
02947         mode_opt();
02948         if (inputState->guessing==0) {
02949             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02950         }
02951         subtype_mark();
02952         if (inputState->guessing==0) {
02953             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02954         }
02955         init_opt();
02956         if (inputState->guessing==0) {
02957             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02958         }
02959         if ( inputState->guessing==0 ) {
02960             parameter_specification_AST = RefAdaAST(currentAST.root);
02961 #line 239 "ada.g"
02962             parameter_specification_AST =
02963                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(parameter_specification_AST.get()))));
02964 #line 2965 "AdaParser.cpp"
02965             currentAST.root = parameter_specification_AST;
02966             if ( parameter_specification_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
02967                 parameter_specification_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02968                   currentAST.child = parameter_specification_AST->getFirstChild();
02969             else
02970                 currentAST.child = parameter_specification_AST;
02971             currentAST.advanceChildToEnd();
02972         }
02973         parameter_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02974     }
02975     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02976         if( inputState->guessing == 0 ) {
02977             reportError(ex);
02978             consume();
02979             consumeUntil(_tokenSet_37);
02980         } else {
02981             throw;
02982         }
02983     }
02984     returnAST = parameter_specification_AST;
02985 }
02986 
02987 void AdaParser::def_ids_colon() {
02988     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02989     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02990     RefAdaAST def_ids_colon_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02991     
02992     try {      // for error handling
02993         defining_identifier_list();
02994         if (inputState->guessing==0) {
02995             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02996         }
02997         match(COLON);
02998         def_ids_colon_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
02999     }
03000     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03001         if( inputState->guessing == 0 ) {
03002             reportError(ex);
03003             consume();
03004             consumeUntil(_tokenSet_38);
03005         } else {
03006             throw;
03007         }
03008     }
03009     returnAST = def_ids_colon_AST;
03010 }
03011 
03012 void AdaParser::mode_opt() {
03013     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03014     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03015     RefAdaAST mode_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03016     
03017     try {      // for error handling
03018         {
03019         switch ( LA(1)) {
03020         case IN:
03021         {
03022             RefAdaAST tmp81_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03023             if ( inputState->guessing == 0 ) {
03024                 tmp81_AST = astFactory->create(LT(1));
03025                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp81_AST.get()));
03026             }
03027             match(IN);
03028             {
03029             switch ( LA(1)) {
03030             case OUT:
03031             {
03032                 RefAdaAST tmp82_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03033                 if ( inputState->guessing == 0 ) {
03034                     tmp82_AST = astFactory->create(LT(1));
03035                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp82_AST.get()));
03036                 }
03037                 match(OUT);
03038                 break;
03039             }
03040             case IDENTIFIER:
03041             {
03042                 break;
03043             }
03044             default:
03045             {
03046                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03047             }
03048             }
03049             }
03050             break;
03051         }
03052         case OUT:
03053         {
03054             RefAdaAST tmp83_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03055             if ( inputState->guessing == 0 ) {
03056                 tmp83_AST = astFactory->create(LT(1));
03057                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp83_AST.get()));
03058             }
03059             match(OUT);
03060             break;
03061         }
03062         case ACCESS:
03063         {
03064             RefAdaAST tmp84_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03065             if ( inputState->guessing == 0 ) {
03066                 tmp84_AST = astFactory->create(LT(1));
03067                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp84_AST.get()));
03068             }
03069             match(ACCESS);
03070             break;
03071         }
03072         case IDENTIFIER:
03073         {
03074             break;
03075         }
03076         default:
03077         {
03078             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03079         }
03080         }
03081         }
03082         if ( inputState->guessing==0 ) {
03083             mode_opt_AST = RefAdaAST(currentAST.root);
03084 #line 254 "ada.g"
03085             mode_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mode_opt_AST.get()))));
03086 #line 3087 "AdaParser.cpp"
03087             currentAST.root = mode_opt_AST;
03088             if ( mode_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03089                 mode_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03090                   currentAST.child = mode_opt_AST->getFirstChild();
03091             else
03092                 currentAST.child = mode_opt_AST;
03093             currentAST.advanceChildToEnd();
03094         }
03095         mode_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03096     }
03097     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03098         if( inputState->guessing == 0 ) {
03099             reportError(ex);
03100             consume();
03101             consumeUntil(_tokenSet_39);
03102         } else {
03103             throw;
03104         }
03105     }
03106     returnAST = mode_opt_AST;
03107 }
03108 
03109 void AdaParser::init_opt() {
03110     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03111     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03112     RefAdaAST init_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03113     
03114     try {      // for error handling
03115         {
03116         switch ( LA(1)) {
03117         case ASSIGN:
03118         {
03119             match(ASSIGN);
03120             expression();
03121             if (inputState->guessing==0) {
03122                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03123             }
03124             break;
03125         }
03126         case SEMI:
03127         case RPAREN:
03128         {
03129             break;
03130         }
03131         default:
03132         {
03133             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03134         }
03135         }
03136         }
03137         if ( inputState->guessing==0 ) {
03138             init_opt_AST = RefAdaAST(currentAST.root);
03139 #line 460 "ada.g"
03140             init_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(INIT_OPT,"INIT_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(init_opt_AST.get()))));
03141 #line 3142 "AdaParser.cpp"
03142             currentAST.root = init_opt_AST;
03143             if ( init_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03144                 init_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03145                   currentAST.child = init_opt_AST->getFirstChild();
03146             else
03147                 currentAST.child = init_opt_AST;
03148             currentAST.advanceChildToEnd();
03149         }
03150         init_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03151     }
03152     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03153         if( inputState->guessing == 0 ) {
03154             reportError(ex);
03155             consume();
03156             consumeUntil(_tokenSet_37);
03157         } else {
03158             throw;
03159         }
03160     }
03161     returnAST = init_opt_AST;
03162 }
03163 
03164 void AdaParser::defining_identifier_list() {
03165     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03166     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03167     RefAdaAST defining_identifier_list_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03168     
03169     try {      // for error handling
03170         RefAdaAST tmp86_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03171         if ( inputState->guessing == 0 ) {
03172             tmp86_AST = astFactory->create(LT(1));
03173             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp86_AST.get()));
03174         }
03175         match(IDENTIFIER);
03176         { // ( ... )*
03177         for (;;) {
03178             if ((LA(1) == COMMA)) {
03179                 match(COMMA);
03180                 RefAdaAST tmp88_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03181                 if ( inputState->guessing == 0 ) {
03182                     tmp88_AST = astFactory->create(LT(1));
03183                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp88_AST.get()));
03184                 }
03185                 match(IDENTIFIER);
03186             }
03187             else {
03188                 goto _loop79;
03189             }
03190             
03191         }
03192         _loop79:;
03193         } // ( ... )*
03194         if ( inputState->guessing==0 ) {
03195             defining_identifier_list_AST = RefAdaAST(currentAST.root);
03196 #line 248 "ada.g"
03197             defining_identifier_list_AST =
03198                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DEFINING_IDENTIFIER_LIST,"DEFINING_IDENTIFIER_LIST").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(defining_identifier_list_AST.get()))));
03199 #line 3200 "AdaParser.cpp"
03200             currentAST.root = defining_identifier_list_AST;
03201             if ( defining_identifier_list_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03202                 defining_identifier_list_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03203                   currentAST.child = defining_identifier_list_AST->getFirstChild();
03204             else
03205                 currentAST.child = defining_identifier_list_AST;
03206             currentAST.advanceChildToEnd();
03207         }
03208         defining_identifier_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03209     }
03210     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03211         if( inputState->guessing == 0 ) {
03212             reportError(ex);
03213             consume();
03214             consumeUntil(_tokenSet_40);
03215         } else {
03216             throw;
03217         }
03218     }
03219     returnAST = defining_identifier_list_AST;
03220 }
03221 
03222 void AdaParser::name() {
03223     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03224     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03225     RefAdaAST name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03226     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
03227     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03228 #line 264 "ada.g"
03229     RefAdaAST dummy;
03230 #line 3231 "AdaParser.cpp"
03231     
03232     try {      // for error handling
03233         RefAdaAST tmp89_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03234         if ( inputState->guessing == 0 ) {
03235             tmp89_AST = astFactory->create(LT(1));
03236             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp89_AST.get()));
03237         }
03238         match(IDENTIFIER);
03239         { // ( ... )*
03240         for (;;) {
03241             switch ( LA(1)) {
03242             case DOT:
03243             {
03244                 RefAdaAST tmp90_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03245                 if ( inputState->guessing == 0 ) {
03246                     tmp90_AST = astFactory->create(LT(1));
03247                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp90_AST.get()));
03248                 }
03249                 match(DOT);
03250                 {
03251                 switch ( LA(1)) {
03252                 case ALL:
03253                 {
03254                     RefAdaAST tmp91_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03255                     if ( inputState->guessing == 0 ) {
03256                         tmp91_AST = astFactory->create(LT(1));
03257                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp91_AST.get()));
03258                     }
03259                     match(ALL);
03260                     break;
03261                 }
03262                 case IDENTIFIER:
03263                 {
03264                     RefAdaAST tmp92_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03265                     if ( inputState->guessing == 0 ) {
03266                         tmp92_AST = astFactory->create(LT(1));
03267                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp92_AST.get()));
03268                     }
03269                     match(IDENTIFIER);
03270                     break;
03271                 }
03272                 case CHARACTER_LITERAL:
03273                 {
03274                     RefAdaAST tmp93_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03275                     if ( inputState->guessing == 0 ) {
03276                         tmp93_AST = astFactory->create(LT(1));
03277                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp93_AST.get()));
03278                     }
03279                     match(CHARACTER_LITERAL);
03280                     break;
03281                 }
03282                 case CHAR_STRING:
03283                 {
03284                     dummy=is_operator();
03285                     if (inputState->guessing==0) {
03286                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03287                     }
03288                     break;
03289                 }
03290                 default:
03291                 {
03292                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03293                 }
03294                 }
03295                 }
03296                 break;
03297             }
03298             case LPAREN:
03299             {
03300                 p = LT(1);
03301                 if ( inputState->guessing == 0 ) {
03302                     p_AST = astFactory->create(p);
03303                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
03304                 }
03305                 match(LPAREN);
03306                 value_s();
03307                 if (inputState->guessing==0) {
03308                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03309                 }
03310                 match(RPAREN);
03311                 if ( inputState->guessing==0 ) {
03312 #line 272 "ada.g"
03313                     Set(p_AST, INDEXED_COMPONENT);
03314 #line 3315 "AdaParser.cpp"
03315                 }
03316                 break;
03317             }
03318             case TIC:
03319             {
03320                 RefAdaAST tmp95_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03321                 if ( inputState->guessing == 0 ) {
03322                     tmp95_AST = astFactory->create(LT(1));
03323                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp95_AST.get()));
03324                 }
03325                 match(TIC);
03326                 attribute_id();
03327                 if (inputState->guessing==0) {
03328                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03329                 }
03330                 break;
03331             }
03332             default:
03333             {
03334                 goto _loop88;
03335             }
03336             }
03337         }
03338         _loop88:;
03339         } // ( ... )*
03340         name_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03341     }
03342     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03343         if( inputState->guessing == 0 ) {
03344             reportError(ex);
03345             consume();
03346             consumeUntil(_tokenSet_41);
03347         } else {
03348             throw;
03349         }
03350     }
03351     returnAST = name_AST;
03352 }
03353 
03354 RefAdaAST  AdaParser::definable_operator_symbol() {
03355 #line 284 "ada.g"
03356     RefAdaAST d;
03357 #line 3358 "AdaParser.cpp"
03358     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03359     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03360     RefAdaAST definable_operator_symbol_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03361     ANTLR_USE_NAMESPACE(antlr)RefToken  op = ANTLR_USE_NAMESPACE(antlr)nullToken;
03362     RefAdaAST op_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03363     
03364     try {      // for error handling
03365         if (!( definable_operator(LT(1)->getText().c_str()) ))
03366             throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" definable_operator(LT(1)->getText().c_str()) ");
03367         op = LT(1);
03368         if ( inputState->guessing == 0 ) {
03369             op_AST = astFactory->create(op);
03370             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(op_AST.get()));
03371         }
03372         match(CHAR_STRING);
03373         if ( inputState->guessing==0 ) {
03374 #line 286 "ada.g"
03375             op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
03376 #line 3377 "AdaParser.cpp"
03377         }
03378         definable_operator_symbol_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03379     }
03380     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03381         if( inputState->guessing == 0 ) {
03382             reportError(ex);
03383             consume();
03384             consumeUntil(_tokenSet_42);
03385         } else {
03386             throw;
03387         }
03388     }
03389     returnAST = definable_operator_symbol_AST;
03390     return d;
03391 }
03392 
03393 RefAdaAST  AdaParser::is_operator() {
03394 #line 279 "ada.g"
03395     RefAdaAST d;
03396 #line 3397 "AdaParser.cpp"
03397     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03398     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03399     RefAdaAST is_operator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03400     ANTLR_USE_NAMESPACE(antlr)RefToken  op = ANTLR_USE_NAMESPACE(antlr)nullToken;
03401     RefAdaAST op_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03402     
03403     try {      // for error handling
03404         if (!( is_operator_symbol(LT(1)->getText().c_str()) ))
03405             throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(LT(1)->getText().c_str()) ");
03406         op = LT(1);
03407         if ( inputState->guessing == 0 ) {
03408             op_AST = astFactory->create(op);
03409             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(op_AST.get()));
03410         }
03411         match(CHAR_STRING);
03412         if ( inputState->guessing==0 ) {
03413 #line 281 "ada.g"
03414             op_AST->setType(OPERATOR_SYMBOL); d=op_AST;
03415 #line 3416 "AdaParser.cpp"
03416         }
03417         is_operator_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03418     }
03419     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03420         if( inputState->guessing == 0 ) {
03421             reportError(ex);
03422             consume();
03423             consumeUntil(_tokenSet_43);
03424         } else {
03425             throw;
03426         }
03427     }
03428     returnAST = is_operator_AST;
03429     return d;
03430 }
03431 
03432 void AdaParser::parenthesized_primary() {
03433     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03434     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03435     RefAdaAST parenthesized_primary_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03436     ANTLR_USE_NAMESPACE(antlr)RefToken  pp = ANTLR_USE_NAMESPACE(antlr)nullToken;
03437     RefAdaAST pp_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03438     
03439     try {      // for error handling
03440         pp = LT(1);
03441         if ( inputState->guessing == 0 ) {
03442             pp_AST = astFactory->create(pp);
03443             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pp_AST.get()));
03444         }
03445         match(LPAREN);
03446         {
03447         if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
03448             RefAdaAST tmp96_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03449             if ( inputState->guessing == 0 ) {
03450                 tmp96_AST = astFactory->create(LT(1));
03451                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp96_AST.get()));
03452             }
03453             match(NuLL);
03454             match(RECORD);
03455         }
03456         else if ((_tokenSet_44.member(LA(1))) && (_tokenSet_45.member(LA(2)))) {
03457             value_s();
03458             if (inputState->guessing==0) {
03459                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03460             }
03461             extension_opt();
03462             if (inputState->guessing==0) {
03463                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03464             }
03465         }
03466         else {
03467             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03468         }
03469         
03470         }
03471         match(RPAREN);
03472         if ( inputState->guessing==0 ) {
03473 #line 294 "ada.g"
03474             Set(pp_AST, PARENTHESIZED_PRIMARY);
03475 #line 3476 "AdaParser.cpp"
03476         }
03477         parenthesized_primary_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03478     }
03479     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03480         if( inputState->guessing == 0 ) {
03481             reportError(ex);
03482             consume();
03483             consumeUntil(_tokenSet_43);
03484         } else {
03485             throw;
03486         }
03487     }
03488     returnAST = parenthesized_primary_AST;
03489 }
03490 
03491 void AdaParser::extension_opt() {
03492     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03493     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03494     RefAdaAST extension_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03495     
03496     try {      // for error handling
03497         {
03498         switch ( LA(1)) {
03499         case WITH:
03500         {
03501             match(WITH);
03502             {
03503             if ((LA(1) == NuLL) && (LA(2) == RECORD)) {
03504                 RefAdaAST tmp100_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03505                 if ( inputState->guessing == 0 ) {
03506                     tmp100_AST = astFactory->create(LT(1));
03507                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp100_AST.get()));
03508                 }
03509                 match(NuLL);
03510                 match(RECORD);
03511             }
03512             else if ((_tokenSet_44.member(LA(1))) && (_tokenSet_46.member(LA(2)))) {
03513                 value_s();
03514                 if (inputState->guessing==0) {
03515                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03516                 }
03517             }
03518             else {
03519                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03520             }
03521             
03522             }
03523             break;
03524         }
03525         case RPAREN:
03526         {
03527             break;
03528         }
03529         default:
03530         {
03531             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03532         }
03533         }
03534         }
03535         if ( inputState->guessing==0 ) {
03536             extension_opt_AST = RefAdaAST(currentAST.root);
03537 #line 298 "ada.g"
03538             extension_opt_AST =
03539                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXTENSION_OPT,"EXTENSION_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(extension_opt_AST.get()))));
03540 #line 3541 "AdaParser.cpp"
03541             currentAST.root = extension_opt_AST;
03542             if ( extension_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03543                 extension_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03544                   currentAST.child = extension_opt_AST->getFirstChild();
03545             else
03546                 currentAST.child = extension_opt_AST;
03547             currentAST.advanceChildToEnd();
03548         }
03549         extension_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03550     }
03551     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03552         if( inputState->guessing == 0 ) {
03553             reportError(ex);
03554             consume();
03555             consumeUntil(_tokenSet_47);
03556         } else {
03557             throw;
03558         }
03559     }
03560     returnAST = extension_opt_AST;
03561 }
03562 
03563 void AdaParser::separate_or_abstract(
03564     RefAdaAST t
03565 ) {
03566     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03567     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03568     RefAdaAST separate_or_abstract_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03569     
03570     try {      // for error handling
03571         switch ( LA(1)) {
03572         case SEPARATE:
03573         {
03574             match(SEPARATE);
03575             if ( inputState->guessing==0 ) {
03576 #line 314 "ada.g"
03577                 pop_def_id();
03578                           if (t->getType() == AdaTokenTypes::PROCEDURE)
03579                             Set(t, PROCEDURE_BODY_STUB);
03580                           else
03581                             Set(t, FUNCTION_BODY_STUB);
03582                         
03583 #line 3584 "AdaParser.cpp"
03584             }
03585             break;
03586         }
03587         case ABSTRACT:
03588         {
03589             match(ABSTRACT);
03590             if ( inputState->guessing==0 ) {
03591 #line 321 "ada.g"
03592                 pop_def_id();
03593                           if (t->getType() == AdaTokenTypes::PROCEDURE)
03594                             Set(t, ABSTRACT_PROCEDURE_DECLARATION);
03595                           else
03596                             Set(t, ABSTRACT_FUNCTION_DECLARATION);
03597                         
03598 #line 3599 "AdaParser.cpp"
03599             }
03600             break;
03601         }
03602         default:
03603         {
03604             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03605         }
03606         }
03607     }
03608     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03609         if( inputState->guessing == 0 ) {
03610             reportError(ex);
03611             consume();
03612             consumeUntil(_tokenSet_4);
03613         } else {
03614             throw;
03615         }
03616     }
03617     returnAST = separate_or_abstract_AST;
03618 }
03619 
03620 RefAdaAST  AdaParser::designator() {
03621 #line 335 "ada.g"
03622     RefAdaAST d;
03623 #line 3624 "AdaParser.cpp"
03624     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03625     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03626     RefAdaAST designator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03627     ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
03628     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03629 #line 335 "ada.g"
03630     RefAdaAST op;
03631 #line 3632 "AdaParser.cpp"
03632     
03633     try {      // for error handling
03634         switch ( LA(1)) {
03635         case CHAR_STRING:
03636         {
03637             op=definable_operator_symbol();
03638             if (inputState->guessing==0) {
03639                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03640             }
03641             if ( inputState->guessing==0 ) {
03642 #line 337 "ada.g"
03643                 d = op;
03644 #line 3645 "AdaParser.cpp"
03645             }
03646             designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03647             break;
03648         }
03649         case IDENTIFIER:
03650         {
03651             n = LT(1);
03652             if ( inputState->guessing == 0 ) {
03653                 n_AST = astFactory->create(n);
03654                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
03655             }
03656             match(IDENTIFIER);
03657             if ( inputState->guessing==0 ) {
03658 #line 338 "ada.g"
03659                 d = n_AST;
03660 #line 3661 "AdaParser.cpp"
03661             }
03662             designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03663             break;
03664         }
03665         default:
03666         {
03667             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03668         }
03669         }
03670     }
03671     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03672         if( inputState->guessing == 0 ) {
03673             reportError(ex);
03674             consume();
03675             consumeUntil(_tokenSet_26);
03676         } else {
03677             throw;
03678         }
03679     }
03680     returnAST = designator_AST;
03681     return d;
03682 }
03683 
03684 void AdaParser::func_formal_part_opt() {
03685     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03686     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03687     RefAdaAST func_formal_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03688     
03689     try {      // for error handling
03690         {
03691         switch ( LA(1)) {
03692         case LPAREN:
03693         {
03694             match(LPAREN);
03695             func_param();
03696             if (inputState->guessing==0) {
03697                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03698             }
03699             { // ( ... )*
03700             for (;;) {
03701                 if ((LA(1) == SEMI)) {
03702                     match(SEMI);
03703                     func_param();
03704                     if (inputState->guessing==0) {
03705                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03706                     }
03707                 }
03708                 else {
03709                     goto _loop104;
03710                 }
03711                 
03712             }
03713             _loop104:;
03714             } // ( ... )*
03715             match(RPAREN);
03716             break;
03717         }
03718         case RETURN:
03719         {
03720             break;
03721         }
03722         default:
03723         {
03724             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03725         }
03726         }
03727         }
03728         if ( inputState->guessing==0 ) {
03729             func_formal_part_opt_AST = RefAdaAST(currentAST.root);
03730 #line 347 "ada.g"
03731             func_formal_part_opt_AST =
03732                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(func_formal_part_opt_AST.get()))));
03733 #line 3734 "AdaParser.cpp"
03734             currentAST.root = func_formal_part_opt_AST;
03735             if ( func_formal_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03736                 func_formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03737                   currentAST.child = func_formal_part_opt_AST->getFirstChild();
03738             else
03739                 currentAST.child = func_formal_part_opt_AST;
03740             currentAST.advanceChildToEnd();
03741         }
03742         func_formal_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03743     }
03744     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03745         if( inputState->guessing == 0 ) {
03746             reportError(ex);
03747             consume();
03748             consumeUntil(_tokenSet_48);
03749         } else {
03750             throw;
03751         }
03752     }
03753     returnAST = func_formal_part_opt_AST;
03754 }
03755 
03756 void AdaParser::func_param() {
03757     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03758     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03759     RefAdaAST func_param_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03760     
03761     try {      // for error handling
03762         def_ids_colon();
03763         if (inputState->guessing==0) {
03764             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03765         }
03766         in_access_opt();
03767         if (inputState->guessing==0) {
03768             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03769         }
03770         subtype_mark();
03771         if (inputState->guessing==0) {
03772             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03773         }
03774         init_opt();
03775         if (inputState->guessing==0) {
03776             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03777         }
03778         if ( inputState->guessing==0 ) {
03779             func_param_AST = RefAdaAST(currentAST.root);
03780 #line 353 "ada.g"
03781             func_param_AST =
03782                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(func_param_AST.get()))));
03783 #line 3784 "AdaParser.cpp"
03784             currentAST.root = func_param_AST;
03785             if ( func_param_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03786                 func_param_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03787                   currentAST.child = func_param_AST->getFirstChild();
03788             else
03789                 currentAST.child = func_param_AST;
03790             currentAST.advanceChildToEnd();
03791         }
03792         func_param_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03793     }
03794     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03795         if( inputState->guessing == 0 ) {
03796             reportError(ex);
03797             consume();
03798             consumeUntil(_tokenSet_37);
03799         } else {
03800             throw;
03801         }
03802     }
03803     returnAST = func_param_AST;
03804 }
03805 
03806 void AdaParser::in_access_opt() {
03807     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03808     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03809     RefAdaAST in_access_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03810     
03811     try {      // for error handling
03812         {
03813         switch ( LA(1)) {
03814         case IN:
03815         {
03816             match(IN);
03817             break;
03818         }
03819         case ACCESS:
03820         {
03821             RefAdaAST tmp108_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03822             if ( inputState->guessing == 0 ) {
03823                 tmp108_AST = astFactory->create(LT(1));
03824                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp108_AST.get()));
03825             }
03826             match(ACCESS);
03827             break;
03828         }
03829         case IDENTIFIER:
03830         {
03831             break;
03832         }
03833         default:
03834         {
03835             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03836         }
03837         }
03838         }
03839         if ( inputState->guessing==0 ) {
03840             in_access_opt_AST = RefAdaAST(currentAST.root);
03841 #line 359 "ada.g"
03842             in_access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(in_access_opt_AST.get()))));
03843 #line 3844 "AdaParser.cpp"
03844             currentAST.root = in_access_opt_AST;
03845             if ( in_access_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03846                 in_access_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03847                   currentAST.child = in_access_opt_AST->getFirstChild();
03848             else
03849                 currentAST.child = in_access_opt_AST;
03850             currentAST.advanceChildToEnd();
03851         }
03852         in_access_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03853     }
03854     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03855         if( inputState->guessing == 0 ) {
03856             reportError(ex);
03857             consume();
03858             consumeUntil(_tokenSet_39);
03859         } else {
03860             throw;
03861         }
03862     }
03863     returnAST = in_access_opt_AST;
03864 }
03865 
03866 void AdaParser::pkg_spec_part() {
03867     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03868     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03869     RefAdaAST pkg_spec_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03870     
03871     try {      // for error handling
03872         basic_declarative_items_opt();
03873         if (inputState->guessing==0) {
03874             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03875         }
03876         {
03877         switch ( LA(1)) {
03878         case PRIVATE:
03879         {
03880             match(PRIVATE);
03881             basic_declarative_items_opt();
03882             if (inputState->guessing==0) {
03883                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03884             }
03885             break;
03886         }
03887         case END:
03888         {
03889             break;
03890         }
03891         default:
03892         {
03893             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03894         }
03895         }
03896         }
03897         end_id_opt();
03898         pkg_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03899     }
03900     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03901         if( inputState->guessing == 0 ) {
03902             reportError(ex);
03903             consume();
03904             consumeUntil(_tokenSet_4);
03905         } else {
03906             throw;
03907         }
03908     }
03909     returnAST = pkg_spec_part_AST;
03910 }
03911 
03912 void AdaParser::basic_declarative_items_opt() {
03913     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03914     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03915     RefAdaAST basic_declarative_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03916     
03917     try {      // for error handling
03918         { // ( ... )*
03919         for (;;) {
03920             switch ( LA(1)) {
03921             case IDENTIFIER:
03922             case USE:
03923             case TYPE:
03924             case PACKAGE:
03925             case PROCEDURE:
03926             case FUNCTION:
03927             case TASK:
03928             case PROTECTED:
03929             case FOR:
03930             case SUBTYPE:
03931             case GENERIC:
03932             {
03933                 basic_decl_item();
03934                 if (inputState->guessing==0) {
03935                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03936                 }
03937                 break;
03938             }
03939             case PRAGMA:
03940             {
03941                 pragma();
03942                 if (inputState->guessing==0) {
03943                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03944                 }
03945                 break;
03946             }
03947             default:
03948             {
03949                 goto _loop115;
03950             }
03951             }
03952         }
03953         _loop115:;
03954         } // ( ... )*
03955         if ( inputState->guessing==0 ) {
03956             basic_declarative_items_opt_AST = RefAdaAST(currentAST.root);
03957 #line 377 "ada.g"
03958             basic_declarative_items_opt_AST =
03959                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(basic_declarative_items_opt_AST.get()))));
03960 #line 3961 "AdaParser.cpp"
03961             currentAST.root = basic_declarative_items_opt_AST;
03962             if ( basic_declarative_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03963                 basic_declarative_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03964                   currentAST.child = basic_declarative_items_opt_AST->getFirstChild();
03965             else
03966                 currentAST.child = basic_declarative_items_opt_AST;
03967             currentAST.advanceChildToEnd();
03968         }
03969         basic_declarative_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
03970     }
03971     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03972         if( inputState->guessing == 0 ) {
03973             reportError(ex);
03974             consume();
03975             consumeUntil(_tokenSet_49);
03976         } else {
03977             throw;
03978         }
03979     }
03980     returnAST = basic_declarative_items_opt_AST;
03981 }
03982 
03983 void AdaParser::basic_decl_item() {
03984     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03985     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03986     RefAdaAST basic_decl_item_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03987     ANTLR_USE_NAMESPACE(antlr)RefToken  pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
03988     RefAdaAST pkg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03989     ANTLR_USE_NAMESPACE(antlr)RefToken  tsk = ANTLR_USE_NAMESPACE(antlr)nullToken;
03990     RefAdaAST tsk_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03991     ANTLR_USE_NAMESPACE(antlr)RefToken  pro = ANTLR_USE_NAMESPACE(antlr)nullToken;
03992     RefAdaAST pro_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03993     
03994     try {      // for error handling
03995         switch ( LA(1)) {
03996         case PACKAGE:
03997         {
03998             pkg = LT(1);
03999             if ( inputState->guessing == 0 ) {
04000                 pkg_AST = astFactory->create(pkg);
04001                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get()));
04002             }
04003             match(PACKAGE);
04004             def_id(false);
04005             if (inputState->guessing==0) {
04006                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04007             }
04008             spec_decl_part(pkg_AST);
04009             if (inputState->guessing==0) {
04010                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04011             }
04012             basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04013             break;
04014         }
04015         case TASK:
04016         {
04017             tsk = LT(1);
04018             if ( inputState->guessing == 0 ) {
04019                 tsk_AST = astFactory->create(tsk);
04020                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tsk_AST.get()));
04021             }
04022             match(TASK);
04023             task_type_or_single_decl(tsk_AST);
04024             if (inputState->guessing==0) {
04025                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04026             }
04027             basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04028             break;
04029         }
04030         case PROTECTED:
04031         {
04032             pro = LT(1);
04033             if ( inputState->guessing == 0 ) {
04034                 pro_AST = astFactory->create(pro);
04035                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pro_AST.get()));
04036             }
04037             match(PROTECTED);
04038             prot_type_or_single_decl(pro_AST);
04039             if (inputState->guessing==0) {
04040                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04041             }
04042             match(SEMI);
04043             basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04044             break;
04045         }
04046         case PROCEDURE:
04047         case FUNCTION:
04048         {
04049             subprog_decl(false);
04050             if (inputState->guessing==0) {
04051                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04052             }
04053             basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04054             break;
04055         }
04056         case IDENTIFIER:
04057         case USE:
04058         case TYPE:
04059         case FOR:
04060         case SUBTYPE:
04061         case GENERIC:
04062         {
04063             decl_common();
04064             if (inputState->guessing==0) {
04065                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04066             }
04067             basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04068             break;
04069         }
04070         default:
04071         {
04072             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04073         }
04074         }
04075     }
04076     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04077         if( inputState->guessing == 0 ) {
04078             reportError(ex);
04079             consume();
04080             consumeUntil(_tokenSet_23);
04081         } else {
04082             throw;
04083         }
04084     }
04085     returnAST = basic_decl_item_AST;
04086 }
04087 
04088 void AdaParser::basic_declarative_items() {
04089     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04090     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04091     RefAdaAST basic_declarative_items_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04092     
04093     try {      // for error handling
04094         { // ( ... )+
04095         int _cnt118=0;
04096         for (;;) {
04097             switch ( LA(1)) {
04098             case IDENTIFIER:
04099             case USE:
04100             case TYPE:
04101             case PACKAGE:
04102             case PROCEDURE:
04103             case FUNCTION:
04104             case TASK:
04105             case PROTECTED:
04106             case FOR:
04107             case SUBTYPE:
04108             case GENERIC:
04109             {
04110                 basic_decl_item();
04111                 if (inputState->guessing==0) {
04112                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04113                 }
04114                 break;
04115             }
04116             case PRAGMA:
04117             {
04118                 pragma();
04119                 if (inputState->guessing==0) {
04120                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04121                 }
04122                 break;
04123             }
04124             default:
04125             {
04126                 if ( _cnt118>=1 ) { goto _loop118; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
04127             }
04128             }
04129             _cnt118++;
04130         }
04131         _loop118:;
04132         }  // ( ... )+
04133         if ( inputState->guessing==0 ) {
04134             basic_declarative_items_AST = RefAdaAST(currentAST.root);
04135 #line 384 "ada.g"
04136             basic_declarative_items_AST =
04137                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(basic_declarative_items_AST.get()))));
04138 #line 4139 "AdaParser.cpp"
04139             currentAST.root = basic_declarative_items_AST;
04140             if ( basic_declarative_items_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
04141                 basic_declarative_items_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
04142                   currentAST.child = basic_declarative_items_AST->getFirstChild();
04143             else
04144                 currentAST.child = basic_declarative_items_AST;
04145             currentAST.advanceChildToEnd();
04146         }
04147         basic_declarative_items_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04148     }
04149     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04150         if( inputState->guessing == 0 ) {
04151             reportError(ex);
04152             consume();
04153             consumeUntil(_tokenSet_0);
04154         } else {
04155             throw;
04156         }
04157     }
04158     returnAST = basic_declarative_items_AST;
04159 }
04160 
04161 void AdaParser::task_type_or_single_decl(
04162     RefAdaAST tsk
04163 ) {
04164     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04165     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04166     RefAdaAST task_type_or_single_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04167     
04168     try {      // for error handling
04169         switch ( LA(1)) {
04170         case TYPE:
04171         {
04172             match(TYPE);
04173             def_id(false);
04174             if (inputState->guessing==0) {
04175                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04176             }
04177             discrim_part_opt();
04178             if (inputState->guessing==0) {
04179                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04180             }
04181             task_definition_opt();
04182             if (inputState->guessing==0) {
04183                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04184             }
04185             if ( inputState->guessing==0 ) {
04186 #line 400 "ada.g"
04187                 Set(tsk, TASK_TYPE_DECLARATION);
04188 #line 4189 "AdaParser.cpp"
04189             }
04190             task_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04191             break;
04192         }
04193         case IDENTIFIER:
04194         {
04195             def_id(false);
04196             if (inputState->guessing==0) {
04197                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04198             }
04199             task_definition_opt();
04200             if (inputState->guessing==0) {
04201                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04202             }
04203             if ( inputState->guessing==0 ) {
04204 #line 402 "ada.g"
04205                 Set(tsk, SINGLE_TASK_DECLARATION);
04206 #line 4207 "AdaParser.cpp"
04207             }
04208             task_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04209             break;
04210         }
04211         default:
04212         {
04213             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04214         }
04215         }
04216     }
04217     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04218         if( inputState->guessing == 0 ) {
04219             reportError(ex);
04220             consume();
04221             consumeUntil(_tokenSet_18);
04222         } else {
04223             throw;
04224         }
04225     }
04226     returnAST = task_type_or_single_decl_AST;
04227 }
04228 
04229 void AdaParser::prot_type_or_single_decl(
04230     RefAdaAST pro
04231 ) {
04232     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04233     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04234     RefAdaAST prot_type_or_single_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04235     
04236     try {      // for error handling
04237         switch ( LA(1)) {
04238         case TYPE:
04239         {
04240             match(TYPE);
04241             def_id(false);
04242             if (inputState->guessing==0) {
04243                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04244             }
04245             discrim_part_opt();
04246             if (inputState->guessing==0) {
04247                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04248             }
04249             protected_definition();
04250             if (inputState->guessing==0) {
04251                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04252             }
04253             if ( inputState->guessing==0 ) {
04254 #line 531 "ada.g"
04255                 Set(pro, PROTECTED_TYPE_DECLARATION);
04256 #line 4257 "AdaParser.cpp"
04257             }
04258             prot_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04259             break;
04260         }
04261         case IDENTIFIER:
04262         {
04263             def_id(false);
04264             if (inputState->guessing==0) {
04265                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04266             }
04267             protected_definition();
04268             if (inputState->guessing==0) {
04269                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04270             }
04271             if ( inputState->guessing==0 ) {
04272 #line 533 "ada.g"
04273                 Set(pro, SINGLE_PROTECTED_DECLARATION);
04274 #line 4275 "AdaParser.cpp"
04275             }
04276             prot_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04277             break;
04278         }
04279         default:
04280         {
04281             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04282         }
04283         }
04284     }
04285     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04286         if( inputState->guessing == 0 ) {
04287             reportError(ex);
04288             consume();
04289             consumeUntil(_tokenSet_4);
04290         } else {
04291             throw;
04292         }
04293     }
04294     returnAST = prot_type_or_single_decl_AST;
04295 }
04296 
04297 void AdaParser::decl_common() {
04298     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04299     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04300     RefAdaAST decl_common_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04301     ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
04302     RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04303     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
04304     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04305     ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
04306     RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04307     ANTLR_USE_NAMESPACE(antlr)RefToken  erd = ANTLR_USE_NAMESPACE(antlr)nullToken;
04308     RefAdaAST erd_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04309     ANTLR_USE_NAMESPACE(antlr)RefToken  ord = ANTLR_USE_NAMESPACE(antlr)nullToken;
04310     RefAdaAST ord_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04311     ANTLR_USE_NAMESPACE(antlr)RefToken  od = ANTLR_USE_NAMESPACE(antlr)nullToken;
04312     RefAdaAST od_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04313     
04314     try {      // for error handling
04315         switch ( LA(1)) {
04316         case TYPE:
04317         {
04318             t = LT(1);
04319             if ( inputState->guessing == 0 ) {
04320                 t_AST = astFactory->create(t);
04321                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
04322             }
04323             match(TYPE);
04324             RefAdaAST tmp113_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04325             if ( inputState->guessing == 0 ) {
04326                 tmp113_AST = astFactory->create(LT(1));
04327                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp113_AST.get()));
04328             }
04329             match(IDENTIFIER);
04330             {
04331             switch ( LA(1)) {
04332             case IS:
04333             {
04334                 match(IS);
04335                 type_def(t_AST);
04336                 if (inputState->guessing==0) {
04337                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04338                 }
04339                 break;
04340             }
04341             case SEMI:
04342             case LPAREN:
04343             {
04344                 {
04345                 switch ( LA(1)) {
04346                 case LPAREN:
04347                 {
04348                     discrim_part();
04349                     if (inputState->guessing==0) {
04350                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04351                     }
04352                     {
04353                     switch ( LA(1)) {
04354                     case IS:
04355                     {
04356                         match(IS);
04357                         derived_or_private_or_record(t_AST, true);
04358                         if (inputState->guessing==0) {
04359                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04360                         }
04361                         break;
04362                     }
04363                     case SEMI:
04364                     {
04365                         if ( inputState->guessing==0 ) {
04366 #line 573 "ada.g"
04367                             Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
04368 #line 4369 "AdaParser.cpp"
04369                         }
04370                         break;
04371                     }
04372                     default:
04373                     {
04374                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04375                     }
04376                     }
04377                     }
04378                     break;
04379                 }
04380                 case SEMI:
04381                 {
04382                     empty_discrim_opt();
04383                     if (inputState->guessing==0) {
04384                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04385                     }
04386                     if ( inputState->guessing==0 ) {
04387 #line 576 "ada.g"
04388                         Set(t_AST, INCOMPLETE_TYPE_DECLARATION);
04389 #line 4390 "AdaParser.cpp"
04390                     }
04391                     break;
04392                 }
04393                 default:
04394                 {
04395                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04396                 }
04397                 }
04398                 }
04399                 break;
04400             }
04401             default:
04402             {
04403                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04404             }
04405             }
04406             }
04407             match(SEMI);
04408             decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04409             break;
04410         }
04411         case SUBTYPE:
04412         {
04413             s = LT(1);
04414             if ( inputState->guessing == 0 ) {
04415                 s_AST = astFactory->create(s);
04416                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
04417             }
04418             match(SUBTYPE);
04419             RefAdaAST tmp117_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04420             if ( inputState->guessing == 0 ) {
04421                 tmp117_AST = astFactory->create(LT(1));
04422                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp117_AST.get()));
04423             }
04424             match(IDENTIFIER);
04425             match(IS);
04426             subtype_ind();
04427             if (inputState->guessing==0) {
04428                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04429             }
04430             match(SEMI);
04431             if ( inputState->guessing==0 ) {
04432 #line 590 "ada.g"
04433                 Set(s_AST, SUBTYPE_DECLARATION);
04434 #line 4435 "AdaParser.cpp"
04435             }
04436             decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04437             break;
04438         }
04439         case GENERIC:
04440         {
04441             generic_decl(false);
04442             if (inputState->guessing==0) {
04443                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04444             }
04445             decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04446             break;
04447         }
04448         case USE:
04449         {
04450             use_clause();
04451             if (inputState->guessing==0) {
04452                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04453             }
04454             decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04455             break;
04456         }
04457         case FOR:
04458         {
04459             r = LT(1);
04460             if ( inputState->guessing == 0 ) {
04461                 r_AST = astFactory->create(r);
04462                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
04463             }
04464             match(FOR);
04465             {
04466             bool synPredMatched182 = false;
04467             if (((LA(1) == IDENTIFIER) && (LA(2) == USE))) {
04468                 int _m182 = mark();
04469                 synPredMatched182 = true;
04470                 inputState->guessing++;
04471                 try {
04472                     {
04473                     local_enum_name();
04474                     match(USE);
04475                     match(LPAREN);
04476                     }
04477                 }
04478                 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
04479                     synPredMatched182 = false;
04480                 }
04481                 rewind(_m182);
04482                 inputState->guessing--;
04483             }
04484             if ( synPredMatched182 ) {
04485                 local_enum_name();
04486                 if (inputState->guessing==0) {
04487                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04488                 }
04489                 match(USE);
04490                 enumeration_aggregate();
04491                 if (inputState->guessing==0) {
04492                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04493                 }
04494                 if ( inputState->guessing==0 ) {
04495 #line 595 "ada.g"
04496                     Set(r_AST, ENUMERATION_REPESENTATION_CLAUSE);
04497 #line 4498 "AdaParser.cpp"
04498                 }
04499             }
04500             else if ((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == USE || LA(2) == TIC)) {
04501                 subtype_mark();
04502                 if (inputState->guessing==0) {
04503                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04504                 }
04505                 match(USE);
04506                 rep_spec_part(r_AST);
04507                 if (inputState->guessing==0) {
04508                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04509                 }
04510             }
04511             else {
04512                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04513             }
04514             
04515             }
04516             match(SEMI);
04517             decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04518             break;
04519         }
04520         default:
04521             bool synPredMatched184 = false;
04522             if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
04523                 int _m184 = mark();
04524                 synPredMatched184 = true;
04525                 inputState->guessing++;
04526                 try {
04527                     {
04528                     match(IDENTIFIER);
04529                     match(COLON);
04530                     match(EXCEPTION);
04531                     match(RENAMES);
04532                     }
04533                 }
04534                 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
04535                     synPredMatched184 = false;
04536                 }
04537                 rewind(_m184);
04538                 inputState->guessing--;
04539             }
04540             if ( synPredMatched184 ) {
04541                 RefAdaAST tmp123_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04542                 if ( inputState->guessing == 0 ) {
04543                     tmp123_AST = astFactory->create(LT(1));
04544                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp123_AST.get()));
04545                 }
04546                 match(IDENTIFIER);
04547                 erd = LT(1);
04548                 if ( inputState->guessing == 0 ) {
04549                     erd_AST = astFactory->create(erd);
04550                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(erd_AST.get()));
04551                 }
04552                 match(COLON);
04553                 match(EXCEPTION);
04554                 match(RENAMES);
04555                 compound_name();
04556                 if (inputState->guessing==0) {
04557                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04558                 }
04559                 match(SEMI);
04560                 if ( inputState->guessing==0 ) {
04561 #line 601 "ada.g"
04562                     Set(erd_AST, EXCEPTION_RENAMING_DECLARATION);
04563 #line 4564 "AdaParser.cpp"
04564                 }
04565                 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04566             }
04567             else {
04568                 bool synPredMatched186 = false;
04569                 if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) {
04570                     int _m186 = mark();
04571                     synPredMatched186 = true;
04572                     inputState->guessing++;
04573                     try {
04574                         {
04575                         match(IDENTIFIER);
04576                         match(COLON);
04577                         subtype_mark();
04578                         match(RENAMES);
04579                         }
04580                     }
04581                     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
04582                         synPredMatched186 = false;
04583                     }
04584                     rewind(_m186);
04585                     inputState->guessing--;
04586                 }
04587                 if ( synPredMatched186 ) {
04588                     RefAdaAST tmp127_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04589                     if ( inputState->guessing == 0 ) {
04590                         tmp127_AST = astFactory->create(LT(1));
04591                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp127_AST.get()));
04592                     }
04593                     match(IDENTIFIER);
04594                     ord = LT(1);
04595                     if ( inputState->guessing == 0 ) {
04596                         ord_AST = astFactory->create(ord);
04597                         astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(ord_AST.get()));
04598                     }
04599                     match(COLON);
04600                     subtype_mark();
04601                     if (inputState->guessing==0) {
04602                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04603                     }
04604                     match(RENAMES);
04605                     name();
04606                     if (inputState->guessing==0) {
04607                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04608                     }
04609                     match(SEMI);
04610                     if ( inputState->guessing==0 ) {
04611 #line 604 "ada.g"
04612                         Set(ord_AST, OBJECT_RENAMING_DECLARATION);
04613 #line 4614 "AdaParser.cpp"
04614                     }
04615                     decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04616                 }
04617                 else if ((LA(1) == IDENTIFIER) && (LA(2) == COMMA || LA(2) == COLON)) {
04618                     defining_identifier_list();
04619                     if (inputState->guessing==0) {
04620                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04621                     }
04622                     od = LT(1);
04623                     if ( inputState->guessing == 0 ) {
04624                         od_AST = astFactory->create(od);
04625                         astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(od_AST.get()));
04626                     }
04627                     match(COLON);
04628                     {
04629                     if ((LA(1) == EXCEPTION)) {
04630                         match(EXCEPTION);
04631                         if ( inputState->guessing==0 ) {
04632 #line 607 "ada.g"
04633                             Set(od_AST, EXCEPTION_DECLARATION);
04634 #line 4635 "AdaParser.cpp"
04635                         }
04636                     }
04637                     else {
04638                         bool synPredMatched189 = false;
04639                         if (((LA(1) == CONSTANT) && (LA(2) == ASSIGN))) {
04640                             int _m189 = mark();
04641                             synPredMatched189 = true;
04642                             inputState->guessing++;
04643                             try {
04644                                 {
04645                                 match(CONSTANT);
04646                                 match(ASSIGN);
04647                                 }
04648                             }
04649                             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
04650                                 synPredMatched189 = false;
04651                             }
04652                             rewind(_m189);
04653                             inputState->guessing--;
04654                         }
04655                         if ( synPredMatched189 ) {
04656                             match(CONSTANT);
04657                             match(ASSIGN);
04658                             expression();
04659                             if (inputState->guessing==0) {
04660                                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04661                             }
04662                             if ( inputState->guessing==0 ) {
04663 #line 609 "ada.g"
04664                                 Set(od_AST, NUMBER_DECLARATION);
04665 #line 4666 "AdaParser.cpp"
04666                             }
04667                         }
04668                         else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) {
04669                             aliased_constant_opt();
04670                             if (inputState->guessing==0) {
04671                                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04672                             }
04673                             {
04674                             switch ( LA(1)) {
04675                             case ARRAY:
04676                             {
04677                                 array_type_definition(od_AST);
04678                                 if (inputState->guessing==0) {
04679                                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04680                                 }
04681                                 init_opt();
04682                                 if (inputState->guessing==0) {
04683                                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04684                                 }
04685                                 if ( inputState->guessing==0 ) {
04686 #line 612 "ada.g"
04687                                     Set(od_AST, ARRAY_OBJECT_DECLARATION);
04688 #line 4689 "AdaParser.cpp"
04689                                 }
04690                                 break;
04691                             }
04692                             case IDENTIFIER:
04693                             {
04694                                 subtype_ind();
04695                                 if (inputState->guessing==0) {
04696                                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04697                                 }
04698                                 init_opt();
04699                                 if (inputState->guessing==0) {
04700                                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04701                                 }
04702                                 if ( inputState->guessing==0 ) {
04703 #line 616 "ada.g"
04704                                     Set(od_AST, OBJECT_DECLARATION);
04705 #line 4706 "AdaParser.cpp"
04706                                 }
04707                                 break;
04708                             }
04709                             default:
04710                             {
04711                                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04712                             }
04713                             }
04714                             }
04715                         }
04716                     else {
04717                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04718                     }
04719                     }
04720                     }
04721                     match(SEMI);
04722                     decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04723                 }
04724         else {
04725             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04726         }
04727         }}
04728     }
04729     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04730         if( inputState->guessing == 0 ) {
04731             reportError(ex);
04732             consume();
04733             consumeUntil(_tokenSet_18);
04734         } else {
04735             throw;
04736         }
04737     }
04738     returnAST = decl_common_AST;
04739 }
04740 
04741 void AdaParser::discrim_part_opt() {
04742     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04743     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04744     RefAdaAST discrim_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04745     
04746     try {      // for error handling
04747         {
04748         switch ( LA(1)) {
04749         case LPAREN:
04750         {
04751             discrim_part_text();
04752             if (inputState->guessing==0) {
04753                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04754             }
04755             break;
04756         }
04757         case SEMI:
04758         case IS:
04759         {
04760             break;
04761         }
04762         default:
04763         {
04764             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04765         }
04766         }
04767         }
04768         if ( inputState->guessing==0 ) {
04769             discrim_part_opt_AST = RefAdaAST(currentAST.root);
04770 #line 412 "ada.g"
04771             discrim_part_opt_AST =
04772                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrim_part_opt_AST.get()))));
04773 #line 4774 "AdaParser.cpp"
04774             currentAST.root = discrim_part_opt_AST;
04775             if ( discrim_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
04776                 discrim_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
04777                   currentAST.child = discrim_part_opt_AST->getFirstChild();
04778             else
04779                 currentAST.child = discrim_part_opt_AST;
04780             currentAST.advanceChildToEnd();
04781         }
04782         discrim_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04783     }
04784     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04785         if( inputState->guessing == 0 ) {
04786             reportError(ex);
04787             consume();
04788             consumeUntil(_tokenSet_52);
04789         } else {
04790             throw;
04791         }
04792     }
04793     returnAST = discrim_part_opt_AST;
04794 }
04795 
04796 void AdaParser::task_definition_opt() {
04797     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04798     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04799     RefAdaAST task_definition_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04800     
04801     try {      // for error handling
04802         switch ( LA(1)) {
04803         case IS:
04804         {
04805             match(IS);
04806             task_items_opt();
04807             if (inputState->guessing==0) {
04808                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04809             }
04810             private_task_items_opt();
04811             if (inputState->guessing==0) {
04812                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04813             }
04814             end_id_opt();
04815             match(SEMI);
04816             task_definition_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04817             break;
04818         }
04819         case SEMI:
04820         {
04821             match(SEMI);
04822             if ( inputState->guessing==0 ) {
04823 #line 407 "ada.g"
04824                 pop_def_id();
04825 #line 4826 "AdaParser.cpp"
04826             }
04827             task_definition_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04828             break;
04829         }
04830         default:
04831         {
04832             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04833         }
04834         }
04835     }
04836     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04837         if( inputState->guessing == 0 ) {
04838             reportError(ex);
04839             consume();
04840             consumeUntil(_tokenSet_18);
04841         } else {
04842             throw;
04843         }
04844     }
04845     returnAST = task_definition_opt_AST;
04846 }
04847 
04848 void AdaParser::task_items_opt() {
04849     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04850     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04851     RefAdaAST task_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04852     
04853     try {      // for error handling
04854         { // ( ... )*
04855         for (;;) {
04856             if ((LA(1) == PRAGMA)) {
04857                 pragma();
04858                 if (inputState->guessing==0) {
04859                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04860                 }
04861             }
04862             else {
04863                 goto _loop139;
04864             }
04865             
04866         }
04867         _loop139:;
04868         } // ( ... )*
04869         entrydecls_repspecs_opt();
04870         if (inputState->guessing==0) {
04871             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04872         }
04873         if ( inputState->guessing==0 ) {
04874             task_items_opt_AST = RefAdaAST(currentAST.root);
04875 #line 465 "ada.g"
04876             task_items_opt_AST =
04877                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TASK_ITEMS_OPT,"TASK_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(task_items_opt_AST.get()))));
04878 #line 4879 "AdaParser.cpp"
04879             currentAST.root = task_items_opt_AST;
04880             if ( task_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
04881                 task_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
04882                   currentAST.child = task_items_opt_AST->getFirstChild();
04883             else
04884                 currentAST.child = task_items_opt_AST;
04885             currentAST.advanceChildToEnd();
04886         }
04887         task_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04888     }
04889     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04890         if( inputState->guessing == 0 ) {
04891             reportError(ex);
04892             consume();
04893             consumeUntil(_tokenSet_49);
04894         } else {
04895             throw;
04896         }
04897     }
04898     returnAST = task_items_opt_AST;
04899 }
04900 
04901 void AdaParser::private_task_items_opt() {
04902     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04903     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04904     RefAdaAST private_task_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04905     
04906     try {      // for error handling
04907         {
04908         switch ( LA(1)) {
04909         case PRIVATE:
04910         {
04911             match(PRIVATE);
04912             { // ( ... )*
04913             for (;;) {
04914                 if ((LA(1) == PRAGMA)) {
04915                     pragma();
04916                     if (inputState->guessing==0) {
04917                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04918                     }
04919                 }
04920                 else {
04921                     goto _loop164;
04922                 }
04923                 
04924             }
04925             _loop164:;
04926             } // ( ... )*
04927             entrydecls_repspecs_opt();
04928             if (inputState->guessing==0) {
04929                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04930             }
04931             break;
04932         }
04933         case END:
04934         {
04935             break;
04936         }
04937         default:
04938         {
04939             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04940         }
04941         }
04942         }
04943         if ( inputState->guessing==0 ) {
04944             private_task_items_opt_AST = RefAdaAST(currentAST.root);
04945 #line 522 "ada.g"
04946             private_task_items_opt_AST =
04947                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PRIVATE_TASK_ITEMS_OPT,"PRIVATE_TASK_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(private_task_items_opt_AST.get()))));
04948 #line 4949 "AdaParser.cpp"
04949             currentAST.root = private_task_items_opt_AST;
04950             if ( private_task_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
04951                 private_task_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
04952                   currentAST.child = private_task_items_opt_AST->getFirstChild();
04953             else
04954                 currentAST.child = private_task_items_opt_AST;
04955             currentAST.advanceChildToEnd();
04956         }
04957         private_task_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
04958     }
04959     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04960         if( inputState->guessing == 0 ) {
04961             reportError(ex);
04962             consume();
04963             consumeUntil(_tokenSet_21);
04964         } else {
04965             throw;
04966         }
04967     }
04968     returnAST = private_task_items_opt_AST;
04969 }
04970 
04971 void AdaParser::discrim_part_text() {
04972     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04973     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04974     RefAdaAST discrim_part_text_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04975     
04976     try {      // for error handling
04977         match(LPAREN);
04978         {
04979         switch ( LA(1)) {
04980         case BOX:
04981         {
04982             RefAdaAST tmp139_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04983             if ( inputState->guessing == 0 ) {
04984                 tmp139_AST = astFactory->create(LT(1));
04985                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp139_AST.get()));
04986             }
04987             match(BOX);
04988             break;
04989         }
04990         case IDENTIFIER:
04991         {
04992             discriminant_specifications();
04993             if (inputState->guessing==0) {
04994                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04995             }
04996             break;
04997         }
04998         default:
04999         {
05000             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05001         }
05002         }
05003         }
05004         match(RPAREN);
05005         discrim_part_text_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05006     }
05007     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05008         if( inputState->guessing == 0 ) {
05009             reportError(ex);
05010             consume();
05011             consumeUntil(_tokenSet_52);
05012         } else {
05013             throw;
05014         }
05015     }
05016     returnAST = discrim_part_text_AST;
05017 }
05018 
05019 void AdaParser::discriminant_specifications() {
05020     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05021     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05022     RefAdaAST discriminant_specifications_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05023     
05024     try {      // for error handling
05025         discriminant_specification();
05026         if (inputState->guessing==0) {
05027             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05028         }
05029         { // ( ... )*
05030         for (;;) {
05031             if ((LA(1) == SEMI)) {
05032                 match(SEMI);
05033                 discriminant_specification();
05034                 if (inputState->guessing==0) {
05035                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05036                 }
05037             }
05038             else {
05039                 goto _loop131;
05040             }
05041             
05042         }
05043         _loop131:;
05044         } // ( ... )*
05045         if ( inputState->guessing==0 ) {
05046             discriminant_specifications_AST = RefAdaAST(currentAST.root);
05047 #line 442 "ada.g"
05048             discriminant_specifications_AST =
05049                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_SPECIFICATIONS,"DISCRIMINANT_SPECIFICATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_specifications_AST.get()))));
05050 #line 5051 "AdaParser.cpp"
05051             currentAST.root = discriminant_specifications_AST;
05052             if ( discriminant_specifications_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05053                 discriminant_specifications_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05054                   currentAST.child = discriminant_specifications_AST->getFirstChild();
05055             else
05056                 currentAST.child = discriminant_specifications_AST;
05057             currentAST.advanceChildToEnd();
05058         }
05059         discriminant_specifications_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05060     }
05061     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05062         if( inputState->guessing == 0 ) {
05063             reportError(ex);
05064             consume();
05065             consumeUntil(_tokenSet_47);
05066         } else {
05067             throw;
05068         }
05069     }
05070     returnAST = discriminant_specifications_AST;
05071 }
05072 
05073 void AdaParser::known_discrim_part() {
05074     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05075     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05076     RefAdaAST known_discrim_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05077     
05078     try {      // for error handling
05079         match(LPAREN);
05080         discriminant_specifications();
05081         if (inputState->guessing==0) {
05082             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05083         }
05084         match(RPAREN);
05085         if ( inputState->guessing==0 ) {
05086             known_discrim_part_AST = RefAdaAST(currentAST.root);
05087 #line 422 "ada.g"
05088             known_discrim_part_AST =
05089                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(known_discrim_part_AST.get()))));
05090 #line 5091 "AdaParser.cpp"
05091             currentAST.root = known_discrim_part_AST;
05092             if ( known_discrim_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05093                 known_discrim_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05094                   currentAST.child = known_discrim_part_AST->getFirstChild();
05095             else
05096                 currentAST.child = known_discrim_part_AST;
05097             currentAST.advanceChildToEnd();
05098         }
05099         known_discrim_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05100     }
05101     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05102         if( inputState->guessing == 0 ) {
05103             reportError(ex);
05104             consume();
05105             consumeUntil(_tokenSet_0);
05106         } else {
05107             throw;
05108         }
05109     }
05110     returnAST = known_discrim_part_AST;
05111 }
05112 
05113 void AdaParser::empty_discrim_opt() {
05114     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05115     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05116     RefAdaAST empty_discrim_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05117     
05118     try {      // for error handling
05119         if ( inputState->guessing==0 ) {
05120             empty_discrim_opt_AST = RefAdaAST(currentAST.root);
05121 #line 428 "ada.g"
05122             empty_discrim_opt_AST =
05123                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(empty_discrim_opt_AST.get()))));
05124 #line 5125 "AdaParser.cpp"
05125             currentAST.root = empty_discrim_opt_AST;
05126             if ( empty_discrim_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05127                 empty_discrim_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05128                   currentAST.child = empty_discrim_opt_AST->getFirstChild();
05129             else
05130                 currentAST.child = empty_discrim_opt_AST;
05131             currentAST.advanceChildToEnd();
05132         }
05133         empty_discrim_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05134     }
05135     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05136         if( inputState->guessing == 0 ) {
05137             reportError(ex);
05138             consume();
05139             consumeUntil(_tokenSet_53);
05140         } else {
05141             throw;
05142         }
05143     }
05144     returnAST = empty_discrim_opt_AST;
05145 }
05146 
05147 void AdaParser::discrim_part() {
05148     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05149     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05150     RefAdaAST discrim_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05151     
05152     try {      // for error handling
05153         discrim_part_text();
05154         if (inputState->guessing==0) {
05155             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05156         }
05157         if ( inputState->guessing==0 ) {
05158             discrim_part_AST = RefAdaAST(currentAST.root);
05159 #line 435 "ada.g"
05160             discrim_part_AST =
05161                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrim_part_AST.get()))));
05162 #line 5163 "AdaParser.cpp"
05163             currentAST.root = discrim_part_AST;
05164             if ( discrim_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05165                 discrim_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05166                   currentAST.child = discrim_part_AST->getFirstChild();
05167             else
05168                 currentAST.child = discrim_part_AST;
05169             currentAST.advanceChildToEnd();
05170         }
05171         discrim_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05172     }
05173     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05174         if( inputState->guessing == 0 ) {
05175             reportError(ex);
05176             consume();
05177             consumeUntil(_tokenSet_52);
05178         } else {
05179             throw;
05180         }
05181     }
05182     returnAST = discrim_part_AST;
05183 }
05184 
05185 void AdaParser::discriminant_specification() {
05186     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05187     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05188     RefAdaAST discriminant_specification_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05189     
05190     try {      // for error handling
05191         def_ids_colon();
05192         if (inputState->guessing==0) {
05193             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05194         }
05195         access_opt();
05196         if (inputState->guessing==0) {
05197             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05198         }
05199         subtype_mark();
05200         if (inputState->guessing==0) {
05201             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05202         }
05203         init_opt();
05204         if (inputState->guessing==0) {
05205             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05206         }
05207         if ( inputState->guessing==0 ) {
05208             discriminant_specification_AST = RefAdaAST(currentAST.root);
05209 #line 449 "ada.g"
05210             discriminant_specification_AST =
05211                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_SPECIFICATION,"DISCRIMINANT_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_specification_AST.get()))));
05212 #line 5213 "AdaParser.cpp"
05213             currentAST.root = discriminant_specification_AST;
05214             if ( discriminant_specification_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05215                 discriminant_specification_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05216                   currentAST.child = discriminant_specification_AST->getFirstChild();
05217             else
05218                 currentAST.child = discriminant_specification_AST;
05219             currentAST.advanceChildToEnd();
05220         }
05221         discriminant_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05222     }
05223     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05224         if( inputState->guessing == 0 ) {
05225             reportError(ex);
05226             consume();
05227             consumeUntil(_tokenSet_37);
05228         } else {
05229             throw;
05230         }
05231     }
05232     returnAST = discriminant_specification_AST;
05233 }
05234 
05235 void AdaParser::access_opt() {
05236     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05237     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05238     RefAdaAST access_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05239     
05240     try {      // for error handling
05241         {
05242         switch ( LA(1)) {
05243         case ACCESS:
05244         {
05245             RefAdaAST tmp144_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05246             if ( inputState->guessing == 0 ) {
05247                 tmp144_AST = astFactory->create(LT(1));
05248                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp144_AST.get()));
05249             }
05250             match(ACCESS);
05251             break;
05252         }
05253         case IDENTIFIER:
05254         {
05255             break;
05256         }
05257         default:
05258         {
05259             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05260         }
05261         }
05262         }
05263         if ( inputState->guessing==0 ) {
05264             access_opt_AST = RefAdaAST(currentAST.root);
05265 #line 456 "ada.g"
05266             access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(access_opt_AST.get()))));
05267 #line 5268 "AdaParser.cpp"
05268             currentAST.root = access_opt_AST;
05269             if ( access_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05270                 access_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05271                   currentAST.child = access_opt_AST->getFirstChild();
05272             else
05273                 currentAST.child = access_opt_AST;
05274             currentAST.advanceChildToEnd();
05275         }
05276         access_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05277     }
05278     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05279         if( inputState->guessing == 0 ) {
05280             reportError(ex);
05281             consume();
05282             consumeUntil(_tokenSet_39);
05283         } else {
05284             throw;
05285         }
05286     }
05287     returnAST = access_opt_AST;
05288 }
05289 
05290 void AdaParser::entrydecls_repspecs_opt() {
05291     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05292     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05293     RefAdaAST entrydecls_repspecs_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05294     
05295     try {      // for error handling
05296         { // ( ... )*
05297         for (;;) {
05298             if ((LA(1) == ENTRY)) {
05299                 entry_declaration();
05300                 if (inputState->guessing==0) {
05301                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05302                 }
05303                 { // ( ... )*
05304                 for (;;) {
05305                     switch ( LA(1)) {
05306                     case PRAGMA:
05307                     {
05308                         pragma();
05309                         if (inputState->guessing==0) {
05310                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05311                         }
05312                         break;
05313                     }
05314                     case FOR:
05315                     {
05316                         rep_spec();
05317                         if (inputState->guessing==0) {
05318                             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05319                         }
05320                         break;
05321                     }
05322                     default:
05323                     {
05324                         goto _loop143;
05325                     }
05326                     }
05327                 }
05328                 _loop143:;
05329                 } // ( ... )*
05330             }
05331             else {
05332                 goto _loop144;
05333             }
05334             
05335         }
05336         _loop144:;
05337         } // ( ... )*
05338         entrydecls_repspecs_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05339     }
05340     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05341         if( inputState->guessing == 0 ) {
05342             reportError(ex);
05343             consume();
05344             consumeUntil(_tokenSet_49);
05345         } else {
05346             throw;
05347         }
05348     }
05349     returnAST = entrydecls_repspecs_opt_AST;
05350 }
05351 
05352 void AdaParser::entry_declaration() {
05353     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05354     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05355     RefAdaAST entry_declaration_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05356     ANTLR_USE_NAMESPACE(antlr)RefToken  e = ANTLR_USE_NAMESPACE(antlr)nullToken;
05357     RefAdaAST e_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05358     
05359     try {      // for error handling
05360         e = LT(1);
05361         if ( inputState->guessing == 0 ) {
05362             e_AST = astFactory->create(e);
05363             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(e_AST.get()));
05364         }
05365         match(ENTRY);
05366         RefAdaAST tmp145_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05367         if ( inputState->guessing == 0 ) {
05368             tmp145_AST = astFactory->create(LT(1));
05369             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp145_AST.get()));
05370         }
05371         match(IDENTIFIER);
05372         discrete_subtype_def_opt();
05373         if (inputState->guessing==0) {
05374             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05375         }
05376         formal_part_opt();
05377         if (inputState->guessing==0) {
05378             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05379         }
05380         match(SEMI);
05381         if ( inputState->guessing==0 ) {
05382 #line 474 "ada.g"
05383             Set (e_AST, ENTRY_DECLARATION);
05384 #line 5385 "AdaParser.cpp"
05385         }
05386         entry_declaration_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05387     }
05388     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05389         if( inputState->guessing == 0 ) {
05390             reportError(ex);
05391             consume();
05392             consumeUntil(_tokenSet_54);
05393         } else {
05394             throw;
05395         }
05396     }
05397     returnAST = entry_declaration_AST;
05398 }
05399 
05400 void AdaParser::rep_spec() {
05401     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05402     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05403     RefAdaAST rep_spec_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05404     ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
05405     RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05406     
05407     try {      // for error handling
05408         r = LT(1);
05409         if ( inputState->guessing == 0 ) {
05410             r_AST = astFactory->create(r);
05411             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
05412         }
05413         match(FOR);
05414         subtype_mark();
05415         if (inputState->guessing==0) {
05416             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05417         }
05418         match(USE);
05419         rep_spec_part(r_AST);
05420         if (inputState->guessing==0) {
05421             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05422         }
05423         match(SEMI);
05424         rep_spec_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05425     }
05426     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05427         if( inputState->guessing == 0 ) {
05428             reportError(ex);
05429             consume();
05430             consumeUntil(_tokenSet_54);
05431         } else {
05432             throw;
05433         }
05434     }
05435     returnAST = rep_spec_AST;
05436 }
05437 
05438 void AdaParser::discrete_subtype_def_opt() {
05439     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05440     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05441     RefAdaAST discrete_subtype_def_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05442     
05443     try {      // for error handling
05444         {
05445         bool synPredMatched149 = false;
05446         if (((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2))))) {
05447             int _m149 = mark();
05448             synPredMatched149 = true;
05449             inputState->guessing++;
05450             try {
05451                 {
05452                 match(LPAREN);
05453                 discrete_subtype_definition();
05454                 match(RPAREN);
05455                 }
05456             }
05457             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
05458                 synPredMatched149 = false;
05459             }
05460             rewind(_m149);
05461             inputState->guessing--;
05462         }
05463         if ( synPredMatched149 ) {
05464             match(LPAREN);
05465             discrete_subtype_definition();
05466             if (inputState->guessing==0) {
05467                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05468             }
05469             match(RPAREN);
05470         }
05471         else if ((LA(1) == SEMI || LA(1) == LPAREN) && (_tokenSet_54.member(LA(2)))) {
05472         }
05473         else {
05474             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05475         }
05476         
05477         }
05478         if ( inputState->guessing==0 ) {
05479             discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root);
05480 #line 481 "ada.g"
05481             discrete_subtype_def_opt_AST =
05482                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRETE_SUBTYPE_DEF_OPT,"DISCRETE_SUBTYPE_DEF_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrete_subtype_def_opt_AST.get()))));
05483 #line 5484 "AdaParser.cpp"
05484             currentAST.root = discrete_subtype_def_opt_AST;
05485             if ( discrete_subtype_def_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05486                 discrete_subtype_def_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05487                   currentAST.child = discrete_subtype_def_opt_AST->getFirstChild();
05488             else
05489                 currentAST.child = discrete_subtype_def_opt_AST;
05490             currentAST.advanceChildToEnd();
05491         }
05492         discrete_subtype_def_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05493     }
05494     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05495         if( inputState->guessing == 0 ) {
05496             reportError(ex);
05497             consume();
05498             consumeUntil(_tokenSet_55);
05499         } else {
05500             throw;
05501         }
05502     }
05503     returnAST = discrete_subtype_def_opt_AST;
05504 }
05505 
05506 void AdaParser::discrete_subtype_definition() {
05507     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05508     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05509     RefAdaAST discrete_subtype_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05510     
05511     try {      // for error handling
05512         {
05513         bool synPredMatched153 = false;
05514         if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) {
05515             int _m153 = mark();
05516             synPredMatched153 = true;
05517             inputState->guessing++;
05518             try {
05519                 {
05520                 range();
05521                 }
05522             }
05523             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
05524                 synPredMatched153 = false;
05525             }
05526             rewind(_m153);
05527             inputState->guessing--;
05528         }
05529         if ( synPredMatched153 ) {
05530             range();
05531             if (inputState->guessing==0) {
05532                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05533             }
05534         }
05535         else if ((LA(1) == IDENTIFIER) && (_tokenSet_56.member(LA(2)))) {
05536             subtype_ind();
05537             if (inputState->guessing==0) {
05538                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05539             }
05540         }
05541         else {
05542             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05543         }
05544         
05545         }
05546         discrete_subtype_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05547     }
05548     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05549         if( inputState->guessing == 0 ) {
05550             reportError(ex);
05551             consume();
05552             consumeUntil(_tokenSet_57);
05553         } else {
05554             throw;
05555         }
05556     }
05557     returnAST = discrete_subtype_definition_AST;
05558 }
05559 
05560 void AdaParser::subtype_ind() {
05561     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05562     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05563     RefAdaAST subtype_ind_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05564     
05565     try {      // for error handling
05566         subtype_mark();
05567         if (inputState->guessing==0) {
05568             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05569         }
05570         constraint_opt();
05571         if (inputState->guessing==0) {
05572             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05573         }
05574         if ( inputState->guessing==0 ) {
05575             subtype_ind_AST = RefAdaAST(currentAST.root);
05576 #line 679 "ada.g"
05577             subtype_ind_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SUBTYPE_INDICATION,"SUBTYPE_INDICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(subtype_ind_AST.get()))));
05578 #line 5579 "AdaParser.cpp"
05579             currentAST.root = subtype_ind_AST;
05580             if ( subtype_ind_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05581                 subtype_ind_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05582                   currentAST.child = subtype_ind_AST->getFirstChild();
05583             else
05584                 currentAST.child = subtype_ind_AST;
05585             currentAST.advanceChildToEnd();
05586         }
05587         subtype_ind_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05588     }
05589     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05590         if( inputState->guessing == 0 ) {
05591             reportError(ex);
05592             consume();
05593             consumeUntil(_tokenSet_58);
05594         } else {
05595             throw;
05596         }
05597     }
05598     returnAST = subtype_ind_AST;
05599 }
05600 
05601 void AdaParser::rep_spec_part(
05602     RefAdaAST t
05603 ) {
05604     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05605     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05606     RefAdaAST rep_spec_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05607     
05608     try {      // for error handling
05609         switch ( LA(1)) {
05610         case RECORD:
05611         {
05612             match(RECORD);
05613             align_opt();
05614             if (inputState->guessing==0) {
05615                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05616             }
05617             comp_loc_s();
05618             if (inputState->guessing==0) {
05619                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05620             }
05621             match(END);
05622             match(RECORD);
05623             if ( inputState->guessing==0 ) {
05624 #line 504 "ada.g"
05625                 Set(t, RECORD_REPRESENTATION_CLAUSE);
05626 #line 5627 "AdaParser.cpp"
05627             }
05628             rep_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05629             break;
05630         }
05631         case AT:
05632         {
05633             match(AT);
05634             expression();
05635             if (inputState->guessing==0) {
05636                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05637             }
05638             if ( inputState->guessing==0 ) {
05639 #line 506 "ada.g"
05640                 Set(t, AT_CLAUSE);
05641 #line 5642 "AdaParser.cpp"
05642             }
05643             rep_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05644             break;
05645         }
05646         case IDENTIFIER:
05647         case LPAREN:
05648         case NEW:
05649         case CHARACTER_LITERAL:
05650         case CHAR_STRING:
05651         case NuLL:
05652         case NOT:
05653         case PLUS:
05654         case MINUS:
05655         case ABS:
05656         case NUMERIC_LIT:
05657         {
05658             expression();
05659             if (inputState->guessing==0) {
05660                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05661             }
05662             if ( inputState->guessing==0 ) {
05663 #line 509 "ada.g"
05664                 Set(t, ATTRIBUTE_DEFINITION_CLAUSE);
05665 #line 5666 "AdaParser.cpp"
05666             }
05667             rep_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05668             break;
05669         }
05670         default:
05671         {
05672             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05673         }
05674         }
05675     }
05676     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05677         if( inputState->guessing == 0 ) {
05678             reportError(ex);
05679             consume();
05680             consumeUntil(_tokenSet_4);
05681         } else {
05682             throw;
05683         }
05684     }
05685     returnAST = rep_spec_part_AST;
05686 }
05687 
05688 void AdaParser::align_opt() {
05689     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05690     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05691     RefAdaAST align_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05692     
05693     try {      // for error handling
05694         {
05695         switch ( LA(1)) {
05696         case AT:
05697         {
05698             match(AT);
05699             match(MOD);
05700             expression();
05701             if (inputState->guessing==0) {
05702                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05703             }
05704             match(SEMI);
05705             break;
05706         }
05707         case PRAGMA:
05708         case IDENTIFIER:
05709         case END:
05710         {
05711             break;
05712         }
05713         default:
05714         {
05715             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05716         }
05717         }
05718         }
05719         if ( inputState->guessing==0 ) {
05720             align_opt_AST = RefAdaAST(currentAST.root);
05721 #line 513 "ada.g"
05722             align_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MOD_CLAUSE_OPT,"MOD_CLAUSE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(align_opt_AST.get()))));
05723 #line 5724 "AdaParser.cpp"
05724             currentAST.root = align_opt_AST;
05725             if ( align_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05726                 align_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05727                   currentAST.child = align_opt_AST->getFirstChild();
05728             else
05729                 currentAST.child = align_opt_AST;
05730             currentAST.advanceChildToEnd();
05731         }
05732         align_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05733     }
05734     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05735         if( inputState->guessing == 0 ) {
05736             reportError(ex);
05737             consume();
05738             consumeUntil(_tokenSet_59);
05739         } else {
05740             throw;
05741         }
05742     }
05743     returnAST = align_opt_AST;
05744 }
05745 
05746 void AdaParser::comp_loc_s() {
05747     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05748     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05749     RefAdaAST comp_loc_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05750     
05751     try {      // for error handling
05752         { // ( ... )*
05753         for (;;) {
05754             switch ( LA(1)) {
05755             case PRAGMA:
05756             {
05757                 pragma();
05758                 if (inputState->guessing==0) {
05759                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05760                 }
05761                 break;
05762             }
05763             case IDENTIFIER:
05764             {
05765                 subtype_mark();
05766                 if (inputState->guessing==0) {
05767                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05768                 }
05769                 match(AT);
05770                 expression();
05771                 if (inputState->guessing==0) {
05772                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05773                 }
05774                 match(RANGE);
05775                 range();
05776                 if (inputState->guessing==0) {
05777                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05778                 }
05779                 match(SEMI);
05780                 break;
05781             }
05782             default:
05783             {
05784                 goto _loop160;
05785             }
05786             }
05787         }
05788         _loop160:;
05789         } // ( ... )*
05790         if ( inputState->guessing==0 ) {
05791             comp_loc_s_AST = RefAdaAST(currentAST.root);
05792 #line 517 "ada.g"
05793             comp_loc_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_CLAUSES_OPT,"COMPONENT_CLAUSES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(comp_loc_s_AST.get()))));
05794 #line 5795 "AdaParser.cpp"
05795             currentAST.root = comp_loc_s_AST;
05796             if ( comp_loc_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05797                 comp_loc_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05798                   currentAST.child = comp_loc_s_AST->getFirstChild();
05799             else
05800                 currentAST.child = comp_loc_s_AST;
05801             currentAST.advanceChildToEnd();
05802         }
05803         comp_loc_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05804     }
05805     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05806         if( inputState->guessing == 0 ) {
05807             reportError(ex);
05808             consume();
05809             consumeUntil(_tokenSet_21);
05810         } else {
05811             throw;
05812         }
05813     }
05814     returnAST = comp_loc_s_AST;
05815 }
05816 
05817 void AdaParser::protected_definition() {
05818     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05819     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05820     RefAdaAST protected_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05821     
05822     try {      // for error handling
05823         match(IS);
05824         prot_op_decl_s();
05825         if (inputState->guessing==0) {
05826             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05827         }
05828         {
05829         switch ( LA(1)) {
05830         case PRIVATE:
05831         {
05832             match(PRIVATE);
05833             prot_member_decl_s();
05834             if (inputState->guessing==0) {
05835                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05836             }
05837             break;
05838         }
05839         case END:
05840         {
05841             break;
05842         }
05843         default:
05844         {
05845             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05846         }
05847         }
05848         }
05849         end_id_opt();
05850         protected_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05851     }
05852     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05853         if( inputState->guessing == 0 ) {
05854             reportError(ex);
05855             consume();
05856             consumeUntil(_tokenSet_4);
05857         } else {
05858             throw;
05859         }
05860     }
05861     returnAST = protected_definition_AST;
05862 }
05863 
05864 void AdaParser::prot_op_decl_s() {
05865     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05866     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05867     RefAdaAST prot_op_decl_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05868     
05869     try {      // for error handling
05870         { // ( ... )*
05871         for (;;) {
05872             if ((_tokenSet_60.member(LA(1)))) {
05873                 prot_op_decl();
05874                 if (inputState->guessing==0) {
05875                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05876                 }
05877             }
05878             else {
05879                 goto _loop170;
05880             }
05881             
05882         }
05883         _loop170:;
05884         } // ( ... )*
05885         if ( inputState->guessing==0 ) {
05886             prot_op_decl_s_AST = RefAdaAST(currentAST.root);
05887 #line 541 "ada.g"
05888             prot_op_decl_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_OP_DECLARATIONS,"PROT_OP_DECLARATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_op_decl_s_AST.get()))));
05889 #line 5890 "AdaParser.cpp"
05890             currentAST.root = prot_op_decl_s_AST;
05891             if ( prot_op_decl_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05892                 prot_op_decl_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05893                   currentAST.child = prot_op_decl_s_AST->getFirstChild();
05894             else
05895                 currentAST.child = prot_op_decl_s_AST;
05896             currentAST.advanceChildToEnd();
05897         }
05898         prot_op_decl_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05899     }
05900     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05901         if( inputState->guessing == 0 ) {
05902             reportError(ex);
05903             consume();
05904             consumeUntil(_tokenSet_49);
05905         } else {
05906             throw;
05907         }
05908     }
05909     returnAST = prot_op_decl_s_AST;
05910 }
05911 
05912 void AdaParser::prot_member_decl_s() {
05913     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05914     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05915     RefAdaAST prot_member_decl_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05916     
05917     try {      // for error handling
05918         { // ( ... )*
05919         for (;;) {
05920             switch ( LA(1)) {
05921             case PRAGMA:
05922             case PROCEDURE:
05923             case FUNCTION:
05924             case ENTRY:
05925             case FOR:
05926             {
05927                 prot_op_decl();
05928                 if (inputState->guessing==0) {
05929                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05930                 }
05931                 break;
05932             }
05933             case IDENTIFIER:
05934             {
05935                 comp_decl();
05936                 if (inputState->guessing==0) {
05937                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05938                 }
05939                 break;
05940             }
05941             default:
05942             {
05943                 goto _loop174;
05944             }
05945             }
05946         }
05947         _loop174:;
05948         } // ( ... )*
05949         if ( inputState->guessing==0 ) {
05950             prot_member_decl_s_AST = RefAdaAST(currentAST.root);
05951 #line 555 "ada.g"
05952             prot_member_decl_s_AST =
05953                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_MEMBER_DECLARATIONS,"PROT_MEMBER_DECLARATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_member_decl_s_AST.get()))));
05954 #line 5955 "AdaParser.cpp"
05955             currentAST.root = prot_member_decl_s_AST;
05956             if ( prot_member_decl_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
05957                 prot_member_decl_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
05958                   currentAST.child = prot_member_decl_s_AST->getFirstChild();
05959             else
05960                 currentAST.child = prot_member_decl_s_AST;
05961             currentAST.advanceChildToEnd();
05962         }
05963         prot_member_decl_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05964     }
05965     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05966         if( inputState->guessing == 0 ) {
05967             reportError(ex);
05968             consume();
05969             consumeUntil(_tokenSet_21);
05970         } else {
05971             throw;
05972         }
05973     }
05974     returnAST = prot_member_decl_s_AST;
05975 }
05976 
05977 void AdaParser::prot_op_decl() {
05978     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05979     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05980     RefAdaAST prot_op_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05981     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
05982     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05983     ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
05984     RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05985     
05986     try {      // for error handling
05987         switch ( LA(1)) {
05988         case ENTRY:
05989         {
05990             entry_declaration();
05991             if (inputState->guessing==0) {
05992                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05993             }
05994             prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
05995             break;
05996         }
05997         case PROCEDURE:
05998         {
05999             p = LT(1);
06000             if ( inputState->guessing == 0 ) {
06001                 p_AST = astFactory->create(p);
06002                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
06003             }
06004             match(PROCEDURE);
06005             def_id(false);
06006             if (inputState->guessing==0) {
06007                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06008             }
06009             formal_part_opt();
06010             if (inputState->guessing==0) {
06011                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06012             }
06013             match(SEMI);
06014             if ( inputState->guessing==0 ) {
06015 #line 547 "ada.g"
06016                 pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION);
06017 #line 6018 "AdaParser.cpp"
06018             }
06019             prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06020             break;
06021         }
06022         case FUNCTION:
06023         {
06024             f = LT(1);
06025             if ( inputState->guessing == 0 ) {
06026                 f_AST = astFactory->create(f);
06027                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
06028             }
06029             match(FUNCTION);
06030             def_designator(false);
06031             if (inputState->guessing==0) {
06032                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06033             }
06034             function_tail();
06035             if (inputState->guessing==0) {
06036                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06037             }
06038             match(SEMI);
06039             if ( inputState->guessing==0 ) {
06040 #line 549 "ada.g"
06041                 pop_def_id(); Set(f_AST, FUNCTION_DECLARATION);
06042 #line 6043 "AdaParser.cpp"
06043             }
06044             prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06045             break;
06046         }
06047         case FOR:
06048         {
06049             rep_spec();
06050             if (inputState->guessing==0) {
06051                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06052             }
06053             prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06054             break;
06055         }
06056         case PRAGMA:
06057         {
06058             pragma();
06059             if (inputState->guessing==0) {
06060                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06061             }
06062             prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06063             break;
06064         }
06065         default:
06066         {
06067             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06068         }
06069         }
06070     }
06071     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06072         if( inputState->guessing == 0 ) {
06073             reportError(ex);
06074             consume();
06075             consumeUntil(_tokenSet_54);
06076         } else {
06077             throw;
06078         }
06079     }
06080     returnAST = prot_op_decl_AST;
06081 }
06082 
06083 void AdaParser::comp_decl() {
06084     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06085     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06086     RefAdaAST comp_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06087     
06088     try {      // for error handling
06089         def_ids_colon();
06090         if (inputState->guessing==0) {
06091             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06092         }
06093         component_subtype_def();
06094         if (inputState->guessing==0) {
06095             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06096         }
06097         init_opt();
06098         if (inputState->guessing==0) {
06099             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06100         }
06101         match(SEMI);
06102         if ( inputState->guessing==0 ) {
06103             comp_decl_AST = RefAdaAST(currentAST.root);
06104 #line 561 "ada.g"
06105             comp_decl_AST =
06106                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_DECLARATION,"COMPONENT_DECLARATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(comp_decl_AST.get()))));
06107 #line 6108 "AdaParser.cpp"
06108             currentAST.root = comp_decl_AST;
06109             if ( comp_decl_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
06110                 comp_decl_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
06111                   currentAST.child = comp_decl_AST->getFirstChild();
06112             else
06113                 currentAST.child = comp_decl_AST;
06114             currentAST.advanceChildToEnd();
06115         }
06116         comp_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06117     }
06118     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06119         if( inputState->guessing == 0 ) {
06120             reportError(ex);
06121             consume();
06122             consumeUntil(_tokenSet_61);
06123         } else {
06124             throw;
06125         }
06126     }
06127     returnAST = comp_decl_AST;
06128 }
06129 
06130 void AdaParser::component_subtype_def() {
06131     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06132     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06133     RefAdaAST component_subtype_def_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06134     
06135     try {      // for error handling
06136         aliased_opt();
06137         if (inputState->guessing==0) {
06138             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06139         }
06140         subtype_ind();
06141         if (inputState->guessing==0) {
06142             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06143         }
06144         component_subtype_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06145     }
06146     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06147         if( inputState->guessing == 0 ) {
06148             reportError(ex);
06149             consume();
06150             consumeUntil(_tokenSet_62);
06151         } else {
06152             throw;
06153         }
06154     }
06155     returnAST = component_subtype_def_AST;
06156 }
06157 
06158 void AdaParser::type_def(
06159     RefAdaAST t
06160 ) {
06161     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06162     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06163     RefAdaAST type_def_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06164     
06165     try {      // for error handling
06166         switch ( LA(1)) {
06167         case LPAREN:
06168         {
06169             match(LPAREN);
06170             enum_id_s();
06171             if (inputState->guessing==0) {
06172                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06173             }
06174             match(RPAREN);
06175             if ( inputState->guessing==0 ) {
06176 #line 624 "ada.g"
06177                 Set(t, ENUMERATION_TYPE_DECLARATION);
06178 #line 6179 "AdaParser.cpp"
06179             }
06180             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06181             break;
06182         }
06183         case RANGE:
06184         {
06185             match(RANGE);
06186             range();
06187             if (inputState->guessing==0) {
06188                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06189             }
06190             if ( inputState->guessing==0 ) {
06191 #line 626 "ada.g"
06192                 Set(t, SIGNED_INTEGER_TYPE_DECLARATION);
06193 #line 6194 "AdaParser.cpp"
06194             }
06195             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06196             break;
06197         }
06198         case MOD:
06199         {
06200             match(MOD);
06201             expression();
06202             if (inputState->guessing==0) {
06203                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06204             }
06205             if ( inputState->guessing==0 ) {
06206 #line 628 "ada.g"
06207                 Set(t, MODULAR_TYPE_DECLARATION);
06208 #line 6209 "AdaParser.cpp"
06209             }
06210             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06211             break;
06212         }
06213         case DIGITS:
06214         {
06215             match(DIGITS);
06216             expression();
06217             if (inputState->guessing==0) {
06218                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06219             }
06220             range_constraint_opt();
06221             if (inputState->guessing==0) {
06222                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06223             }
06224             if ( inputState->guessing==0 ) {
06225 #line 630 "ada.g"
06226                 Set(t, FLOATING_POINT_DECLARATION);
06227 #line 6228 "AdaParser.cpp"
06228             }
06229             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06230             break;
06231         }
06232         case DELTA:
06233         {
06234             match(DELTA);
06235             expression();
06236             if (inputState->guessing==0) {
06237                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06238             }
06239             {
06240             switch ( LA(1)) {
06241             case RANGE:
06242             {
06243                 match(RANGE);
06244                 range();
06245                 if (inputState->guessing==0) {
06246                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06247                 }
06248                 if ( inputState->guessing==0 ) {
06249 #line 633 "ada.g"
06250                     Set(t, ORDINARY_FIXED_POINT_DECLARATION);
06251 #line 6252 "AdaParser.cpp"
06252                 }
06253                 break;
06254             }
06255             case DIGITS:
06256             {
06257                 match(DIGITS);
06258                 expression();
06259                 if (inputState->guessing==0) {
06260                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06261                 }
06262                 range_constraint_opt();
06263                 if (inputState->guessing==0) {
06264                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06265                 }
06266                 if ( inputState->guessing==0 ) {
06267 #line 635 "ada.g"
06268                     Set(t, DECIMAL_FIXED_POINT_DECLARATION);
06269 #line 6270 "AdaParser.cpp"
06270                 }
06271                 break;
06272             }
06273             default:
06274             {
06275                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06276             }
06277             }
06278             }
06279             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06280             break;
06281         }
06282         case ARRAY:
06283         {
06284             array_type_definition(t);
06285             if (inputState->guessing==0) {
06286                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06287             }
06288             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06289             break;
06290         }
06291         case ACCESS:
06292         {
06293             access_type_definition(t);
06294             if (inputState->guessing==0) {
06295                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06296             }
06297             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06298             break;
06299         }
06300         case PRIVATE:
06301         case NEW:
06302         case NuLL:
06303         case RECORD:
06304         case ABSTRACT:
06305         case TAGGED:
06306         case LIMITED:
06307         {
06308             empty_discrim_opt();
06309             if (inputState->guessing==0) {
06310                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06311             }
06312             derived_or_private_or_record(t, false);
06313             if (inputState->guessing==0) {
06314                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06315             }
06316             type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06317             break;
06318         }
06319         default:
06320         {
06321             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06322         }
06323         }
06324     }
06325     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06326         if( inputState->guessing == 0 ) {
06327             reportError(ex);
06328             consume();
06329             consumeUntil(_tokenSet_4);
06330         } else {
06331             throw;
06332         }
06333     }
06334     returnAST = type_def_AST;
06335 }
06336 
06337 void AdaParser::derived_or_private_or_record(
06338     RefAdaAST t, bool has_discrim
06339 ) {
06340     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06341     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06342     RefAdaAST derived_or_private_or_record_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06343     
06344     try {      // for error handling
06345         bool synPredMatched244 = false;
06346         if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
06347             int _m244 = mark();
06348             synPredMatched244 = true;
06349             inputState->guessing++;
06350             try {
06351                 {
06352                 {
06353                 switch ( LA(1)) {
06354                 case ABSTRACT:
06355                 {
06356                     match(ABSTRACT);
06357                     break;
06358                 }
06359                 case NEW:
06360                 {
06361                     break;
06362                 }
06363                 default:
06364                 {
06365                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06366                 }
06367                 }
06368                 }
06369                 match(NEW);
06370                 subtype_ind();
06371                 match(WITH);
06372                 }
06373             }
06374             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
06375                 synPredMatched244 = false;
06376             }
06377             rewind(_m244);
06378             inputState->guessing--;
06379         }
06380         if ( synPredMatched244 ) {
06381             abstract_opt();
06382             if (inputState->guessing==0) {
06383                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06384             }
06385             match(NEW);
06386             subtype_ind();
06387             if (inputState->guessing==0) {
06388                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06389             }
06390             match(WITH);
06391             {
06392             switch ( LA(1)) {
06393             case PRIVATE:
06394             {
06395                 match(PRIVATE);
06396                 if ( inputState->guessing==0 ) {
06397 #line 758 "ada.g"
06398                     Set(t, PRIVATE_EXTENSION_DECLARATION);
06399 #line 6400 "AdaParser.cpp"
06400                 }
06401                 break;
06402             }
06403             case NuLL:
06404             case RECORD:
06405             {
06406                 record_definition(has_discrim);
06407                 if (inputState->guessing==0) {
06408                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06409                 }
06410                 if ( inputState->guessing==0 ) {
06411 #line 760 "ada.g"
06412                     Set(t, DERIVED_RECORD_EXTENSION);
06413 #line 6414 "AdaParser.cpp"
06414                 }
06415                 break;
06416             }
06417             default:
06418             {
06419                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06420             }
06421             }
06422             }
06423             derived_or_private_or_record_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06424         }
06425         else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
06426             match(NEW);
06427             subtype_ind();
06428             if (inputState->guessing==0) {
06429                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06430             }
06431             if ( inputState->guessing==0 ) {
06432 #line 762 "ada.g"
06433                 Set(t, ORDINARY_DERIVED_TYPE_DECLARATION);
06434 #line 6435 "AdaParser.cpp"
06435             }
06436             derived_or_private_or_record_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06437         }
06438         else if ((_tokenSet_63.member(LA(1))) && (_tokenSet_64.member(LA(2)))) {
06439             abstract_tagged_limited_opt();
06440             if (inputState->guessing==0) {
06441                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06442             }
06443             {
06444             switch ( LA(1)) {
06445             case PRIVATE:
06446             {
06447                 match(PRIVATE);
06448                 if ( inputState->guessing==0 ) {
06449 #line 764 "ada.g"
06450                     Set(t, PRIVATE_TYPE_DECLARATION);
06451 #line 6452 "AdaParser.cpp"
06452                 }
06453                 break;
06454             }
06455             case NuLL:
06456             case RECORD:
06457             {
06458                 record_definition(has_discrim);
06459                 if (inputState->guessing==0) {
06460                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06461                 }
06462                 if ( inputState->guessing==0 ) {
06463 #line 766 "ada.g"
06464                     Set(t, RECORD_TYPE_DECLARATION);
06465 #line 6466 "AdaParser.cpp"
06466                 }
06467                 break;
06468             }
06469             default:
06470             {
06471                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06472             }
06473             }
06474             }
06475             derived_or_private_or_record_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06476         }
06477         else {
06478             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06479         }
06480         
06481     }
06482     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06483         if( inputState->guessing == 0 ) {
06484             reportError(ex);
06485             consume();
06486             consumeUntil(_tokenSet_4);
06487         } else {
06488             throw;
06489         }
06490     }
06491     returnAST = derived_or_private_or_record_AST;
06492 }
06493 
06494 void AdaParser::local_enum_name() {
06495     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06496     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06497     RefAdaAST local_enum_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06498     
06499     try {      // for error handling
06500         RefAdaAST tmp179_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06501         if ( inputState->guessing == 0 ) {
06502             tmp179_AST = astFactory->create(LT(1));
06503             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp179_AST.get()));
06504         }
06505         match(IDENTIFIER);
06506         local_enum_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06507     }
06508     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06509         if( inputState->guessing == 0 ) {
06510             reportError(ex);
06511             consume();
06512             consumeUntil(_tokenSet_65);
06513         } else {
06514             throw;
06515         }
06516     }
06517     returnAST = local_enum_name_AST;
06518 }
06519 
06520 void AdaParser::enumeration_aggregate() {
06521     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06522     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06523     RefAdaAST enumeration_aggregate_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06524     
06525     try {      // for error handling
06526         parenth_values();
06527         if (inputState->guessing==0) {
06528             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06529         }
06530         enumeration_aggregate_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06531     }
06532     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06533         if( inputState->guessing == 0 ) {
06534             reportError(ex);
06535             consume();
06536             consumeUntil(_tokenSet_4);
06537         } else {
06538             throw;
06539         }
06540     }
06541     returnAST = enumeration_aggregate_AST;
06542 }
06543 
06544 void AdaParser::aliased_constant_opt() {
06545     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06546     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06547     RefAdaAST aliased_constant_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06548     
06549     try {      // for error handling
06550         {
06551         switch ( LA(1)) {
06552         case ALIASED:
06553         {
06554             RefAdaAST tmp180_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06555             if ( inputState->guessing == 0 ) {
06556                 tmp180_AST = astFactory->create(LT(1));
06557                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp180_AST.get()));
06558             }
06559             match(ALIASED);
06560             break;
06561         }
06562         case IDENTIFIER:
06563         case CONSTANT:
06564         case ARRAY:
06565         {
06566             break;
06567         }
06568         default:
06569         {
06570             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06571         }
06572         }
06573         }
06574         {
06575         switch ( LA(1)) {
06576         case CONSTANT:
06577         {
06578             RefAdaAST tmp181_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06579             if ( inputState->guessing == 0 ) {
06580                 tmp181_AST = astFactory->create(LT(1));
06581                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp181_AST.get()));
06582             }
06583             match(CONSTANT);
06584             break;
06585         }
06586         case IDENTIFIER:
06587         case ARRAY:
06588         {
06589             break;
06590         }
06591         default:
06592         {
06593             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06594         }
06595         }
06596         }
06597         if ( inputState->guessing==0 ) {
06598             aliased_constant_opt_AST = RefAdaAST(currentAST.root);
06599 #line 844 "ada.g"
06600             aliased_constant_opt_AST =
06601                   RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(aliased_constant_opt_AST.get()))));
06602 #line 6603 "AdaParser.cpp"
06603             currentAST.root = aliased_constant_opt_AST;
06604             if ( aliased_constant_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
06605                 aliased_constant_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
06606                   currentAST.child = aliased_constant_opt_AST->getFirstChild();
06607             else
06608                 currentAST.child = aliased_constant_opt_AST;
06609             currentAST.advanceChildToEnd();
06610         }
06611         aliased_constant_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06612     }
06613     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06614         if( inputState->guessing == 0 ) {
06615             reportError(ex);
06616             consume();
06617             consumeUntil(_tokenSet_66);
06618         } else {
06619             throw;
06620         }
06621     }
06622     returnAST = aliased_constant_opt_AST;
06623 }
06624 
06625 void AdaParser::array_type_definition(
06626     RefAdaAST t
06627 ) {
06628     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06629     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06630     RefAdaAST array_type_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06631     
06632     try {      // for error handling
06633         match(ARRAY);
06634         match(LPAREN);
06635         index_or_discrete_range_s();
06636         if (inputState->guessing==0) {
06637             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06638         }
06639         match(RPAREN);
06640         match(OF);
06641         component_subtype_def();
06642         if (inputState->guessing==0) {
06643             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06644         }
06645         if ( inputState->guessing==0 ) {
06646 #line 655 "ada.g"
06647             Set(t, ARRAY_TYPE_DECLARATION);
06648 #line 6649 "AdaParser.cpp"
06649         }
06650         array_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06651     }
06652     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06653         if( inputState->guessing == 0 ) {
06654             reportError(ex);
06655             consume();
06656             consumeUntil(_tokenSet_62);
06657         } else {
06658             throw;
06659         }
06660     }
06661     returnAST = array_type_definition_AST;
06662 }
06663 
06664 void AdaParser::enum_id_s() {
06665     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06666     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06667     RefAdaAST enum_id_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06668     
06669     try {      // for error handling
06670         enumeration_literal_specification();
06671         if (inputState->guessing==0) {
06672             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06673         }
06674         { // ( ... )*
06675         for (;;) {
06676             if ((LA(1) == COMMA)) {
06677                 match(COMMA);
06678                 enumeration_literal_specification();
06679                 if (inputState->guessing==0) {
06680                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06681                 }
06682             }
06683             else {
06684                 goto _loop195;
06685             }
06686             
06687         }
06688         _loop195:;
06689         } // ( ... )*
06690         enum_id_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06691     }
06692     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06693         if( inputState->guessing == 0 ) {
06694             reportError(ex);
06695             consume();
06696             consumeUntil(_tokenSet_47);
06697         } else {
06698             throw;
06699         }
06700     }
06701     returnAST = enum_id_s_AST;
06702 }
06703 
06704 void AdaParser::range_constraint_opt() {
06705     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06706     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06707     RefAdaAST range_constraint_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06708     
06709     try {      // for error handling
06710         {
06711         switch ( LA(1)) {
06712         case RANGE:
06713         {
06714             range_constraint();
06715             if (inputState->guessing==0) {
06716                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06717             }
06718             break;
06719         }
06720         case SEMI:
06721         case COMMA:
06722         case RPAREN:
06723         case WITH:
06724         case ASSIGN:
06725         case LOOP:
06726         {
06727             break;
06728         }
06729         default:
06730         {
06731             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06732         }
06733         }
06734         }
06735         range_constraint_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06736     }
06737     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06738         if( inputState->guessing == 0 ) {
06739             reportError(ex);
06740             consume();
06741             consumeUntil(_tokenSet_58);
06742         } else {
06743             throw;
06744         }
06745     }
06746     returnAST = range_constraint_opt_AST;
06747 }
06748 
06749 void AdaParser::access_type_definition(
06750     RefAdaAST t
06751 ) {
06752     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06753     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06754     RefAdaAST access_type_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06755     
06756     try {      // for error handling
06757         match(ACCESS);
06758         {
06759         switch ( LA(1)) {
06760         case PROCEDURE:
06761         case FUNCTION:
06762         case PROTECTED:
06763         {
06764             protected_opt();
06765             if (inputState->guessing==0) {
06766                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06767             }
06768             {
06769             switch ( LA(1)) {
06770             case PROCEDURE:
06771             {
06772                 match(PROCEDURE);
06773                 formal_part_opt();
06774                 if (inputState->guessing==0) {
06775                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06776                 }
06777                 if ( inputState->guessing==0 ) {
06778 #line 737 "ada.g"
06779                     Set(t, ACCESS_TO_PROCEDURE_DECLARATION);
06780 #line 6781 "AdaParser.cpp"
06781                 }
06782                 break;
06783             }
06784             case FUNCTION:
06785             {
06786                 match(FUNCTION);
06787                 func_formal_part_opt();
06788                 if (inputState->guessing==0) {
06789                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06790                 }
06791                 match(RETURN);
06792                 subtype_mark();
06793                 if (inputState->guessing==0) {
06794                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06795                 }
06796                 if ( inputState->guessing==0 ) {
06797 #line 739 "ada.g"
06798                     Set(t, ACCESS_TO_FUNCTION_DECLARATION);
06799 #line 6800 "AdaParser.cpp"
06800                 }
06801                 break;
06802             }
06803             default:
06804             {
06805                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06806             }
06807             }
06808             }
06809             break;
06810         }
06811         case IDENTIFIER:
06812         case ALL:
06813         case CONSTANT:
06814         {
06815             constant_all_opt();
06816             if (inputState->guessing==0) {
06817                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06818             }
06819             subtype_ind();
06820             if (inputState->guessing==0) {
06821                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06822             }
06823             if ( inputState->guessing==0 ) {
06824 #line 742 "ada.g"
06825                 Set(t, ACCESS_TO_OBJECT_DECLARATION);
06826 #line 6827 "AdaParser.cpp"
06827             }
06828             break;
06829         }
06830         default:
06831         {
06832             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06833         }
06834         }
06835         }
06836         access_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06837     }
06838     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06839         if( inputState->guessing == 0 ) {
06840             reportError(ex);
06841             consume();
06842             consumeUntil(_tokenSet_4);
06843         } else {
06844             throw;
06845         }
06846     }
06847     returnAST = access_type_definition_AST;
06848 }
06849 
06850 void AdaParser::enumeration_literal_specification() {
06851     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06852     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06853     RefAdaAST enumeration_literal_specification_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06854     
06855     try {      // for error handling
06856         switch ( LA(1)) {
06857         case IDENTIFIER:
06858         {
06859             RefAdaAST tmp191_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06860             if ( inputState->guessing == 0 ) {
06861                 tmp191_AST = astFactory->create(LT(1));
06862                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp191_AST.get()));
06863             }
06864             match(IDENTIFIER);
06865             enumeration_literal_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06866             break;
06867         }
06868         case CHARACTER_LITERAL:
06869         {
06870             RefAdaAST tmp192_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06871             if ( inputState->guessing == 0 ) {
06872                 tmp192_AST = astFactory->create(LT(1));
06873                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp192_AST.get()));
06874             }
06875             match(CHARACTER_LITERAL);
06876             enumeration_literal_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06877             break;
06878         }
06879         default:
06880         {
06881             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06882         }
06883         }
06884     }
06885     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06886         if( inputState->guessing == 0 ) {
06887             reportError(ex);
06888             consume();
06889             consumeUntil(_tokenSet_7);
06890         } else {
06891             throw;
06892         }
06893     }
06894     returnAST = enumeration_literal_specification_AST;
06895 }
06896 
06897 void AdaParser::index_or_discrete_range_s() {
06898     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06899     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06900     RefAdaAST index_or_discrete_range_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06901     
06902     try {      // for error handling
06903         index_or_discrete_range();
06904         if (inputState->guessing==0) {
06905             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06906         }
06907         { // ( ... )*
06908         for (;;) {
06909             if ((LA(1) == COMMA)) {
06910                 RefAdaAST tmp193_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06911                 if ( inputState->guessing == 0 ) {
06912                     tmp193_AST = astFactory->create(LT(1));
06913                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp193_AST.get()));
06914                 }
06915                 match(COMMA);
06916                 index_or_discrete_range();
06917                 if (inputState->guessing==0) {
06918                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06919                 }
06920             }
06921             else {
06922                 goto _loop202;
06923             }
06924             
06925         }
06926         _loop202:;
06927         } // ( ... )*
06928         index_or_discrete_range_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
06929     }
06930     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06931         if( inputState->guessing == 0 ) {
06932             reportError(ex);
06933             consume();
06934             consumeUntil(_tokenSet_47);
06935         } else {
06936             throw;
06937         }
06938     }
06939     returnAST = index_or_discrete_range_s_AST;
06940 }
06941 
06942 void AdaParser::index_or_discrete_range() {
06943     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06944     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06945     RefAdaAST index_or_discrete_range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06946     
06947     try {      // for error handling
06948         simple_expression();
06949         if (inputState->guessing==0) {
06950             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06951         }
06952         {
06953         switch ( LA(1)) {
06954         case DOT_DOT:
06955         {
06956             RefAdaAST tmp194_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06957             if ( inputState->guessing == 0 ) {
06958                 tmp194_AST = astFactory->create(LT(1));
06959                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp194_AST.get()));
06960             }
06961             match(DOT_DOT);
06962             simple_expression();
06963             if (inputState->guessing==0) {
06964                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06965             }
06966             break;
06967         }
06968         case RANGE:
06969         {
06970             RefAdaAST tmp195_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06971             if ( inputState->guessing == 0 ) {
06972                 tmp195_AST = astFactory->create(LT(1));
06973                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp195_AST.get()));
06974             }
06975             match(RANGE);
06976             {
06977             switch ( LA(1)) {
06978             case BOX:
06979             {
06980                 RefAdaAST tmp196_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06981                 if ( inputState->guessing == 0 ) {
06982                     tmp196_AST = astFactory->create(LT(1));
06983                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp196_AST.get()));
06984                 }
06985                 match(BOX);
06986                 break;
06987             }
06988             case IDENTIFIER:
06989             case LPAREN:
06990             case NEW:
06991             case CHARACTER_LITERAL:
06992             case CHAR_STRING:
06993             case NuLL:
06994             case NOT:
06995             case PLUS:
06996             case MINUS:
06997             case ABS:
06998             case NUMERIC_LIT:
06999             {
07000                 range();
07001                 if (inputState->guessing==0) {
07002                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07003                 }
07004                 break;
07005             }
07006             default:
07007             {
07008                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07009             }
07010             }
07011             }
07012             break;
07013         }
07014         case COMMA:
07015         case RPAREN:
07016         {
07017             break;
07018         }
07019         default:
07020         {
07021             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07022         }
07023         }
07024         }
07025         index_or_discrete_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07026     }
07027     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07028         if( inputState->guessing == 0 ) {
07029             reportError(ex);
07030             consume();
07031             consumeUntil(_tokenSet_7);
07032         } else {
07033             throw;
07034         }
07035     }
07036     returnAST = index_or_discrete_range_AST;
07037 }
07038 
07039 void AdaParser::aliased_opt() {
07040     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07041     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07042     RefAdaAST aliased_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07043     
07044     try {      // for error handling
07045         {
07046         switch ( LA(1)) {
07047         case ALIASED:
07048         {
07049             RefAdaAST tmp197_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07050             if ( inputState->guessing == 0 ) {
07051                 tmp197_AST = astFactory->create(LT(1));
07052                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp197_AST.get()));
07053             }
07054             match(ALIASED);
07055             break;
07056         }
07057         case IDENTIFIER:
07058         {
07059             break;
07060         }
07061         default:
07062         {
07063             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07064         }
07065         }
07066         }
07067         if ( inputState->guessing==0 ) {
07068             aliased_opt_AST = RefAdaAST(currentAST.root);
07069 #line 675 "ada.g"
07070             aliased_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(aliased_opt_AST.get()))));
07071 #line 7072 "AdaParser.cpp"
07072             currentAST.root = aliased_opt_AST;
07073             if ( aliased_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07074                 aliased_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07075                   currentAST.child = aliased_opt_AST->getFirstChild();
07076             else
07077                 currentAST.child = aliased_opt_AST;
07078             currentAST.advanceChildToEnd();
07079         }
07080         aliased_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07081     }
07082     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07083         if( inputState->guessing == 0 ) {
07084             reportError(ex);
07085             consume();
07086             consumeUntil(_tokenSet_39);
07087         } else {
07088             throw;
07089         }
07090     }
07091     returnAST = aliased_opt_AST;
07092 }
07093 
07094 void AdaParser::constraint_opt() {
07095     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07096     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07097     RefAdaAST constraint_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07098     
07099     try {      // for error handling
07100         {
07101         switch ( LA(1)) {
07102         case RANGE:
07103         {
07104             range_constraint();
07105             if (inputState->guessing==0) {
07106                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07107             }
07108             break;
07109         }
07110         case DIGITS:
07111         {
07112             digits_constraint();
07113             if (inputState->guessing==0) {
07114                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07115             }
07116             break;
07117         }
07118         case DELTA:
07119         {
07120             delta_constraint();
07121             if (inputState->guessing==0) {
07122                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07123             }
07124             break;
07125         }
07126         case SEMI:
07127         case COMMA:
07128         case RPAREN:
07129         case WITH:
07130         case ASSIGN:
07131         case LOOP:
07132         {
07133             break;
07134         }
07135         default:
07136             bool synPredMatched213 = false;
07137             if (((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2))))) {
07138                 int _m213 = mark();
07139                 synPredMatched213 = true;
07140                 inputState->guessing++;
07141                 try {
07142                     {
07143                     index_constraint();
07144                     }
07145                 }
07146                 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
07147                     synPredMatched213 = false;
07148                 }
07149                 rewind(_m213);
07150                 inputState->guessing--;
07151             }
07152             if ( synPredMatched213 ) {
07153                 index_constraint();
07154                 if (inputState->guessing==0) {
07155                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07156                 }
07157             }
07158             else if ((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2)))) {
07159                 discriminant_constraint();
07160                 if (inputState->guessing==0) {
07161                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07162                 }
07163             }
07164         else {
07165             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07166         }
07167         }
07168         }
07169         constraint_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07170     }
07171     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07172         if( inputState->guessing == 0 ) {
07173             reportError(ex);
07174             consume();
07175             consumeUntil(_tokenSet_58);
07176         } else {
07177             throw;
07178         }
07179     }
07180     returnAST = constraint_opt_AST;
07181 }
07182 
07183 void AdaParser::digits_constraint() {
07184     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07185     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07186     RefAdaAST digits_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07187     ANTLR_USE_NAMESPACE(antlr)RefToken  d = ANTLR_USE_NAMESPACE(antlr)nullToken;
07188     RefAdaAST d_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07189     
07190     try {      // for error handling
07191         d = LT(1);
07192         if ( inputState->guessing == 0 ) {
07193             d_AST = astFactory->create(d);
07194             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get()));
07195         }
07196         match(DIGITS);
07197         expression();
07198         if (inputState->guessing==0) {
07199             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07200         }
07201         range_constraint_opt();
07202         if (inputState->guessing==0) {
07203             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07204         }
07205         if ( inputState->guessing==0 ) {
07206 #line 692 "ada.g"
07207             Set(d_AST, DIGITS_CONSTRAINT);
07208 #line 7209 "AdaParser.cpp"
07209         }
07210         digits_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07211     }
07212     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07213         if( inputState->guessing == 0 ) {
07214             reportError(ex);
07215             consume();
07216             consumeUntil(_tokenSet_58);
07217         } else {
07218             throw;
07219         }
07220     }
07221     returnAST = digits_constraint_AST;
07222 }
07223 
07224 void AdaParser::delta_constraint() {
07225     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07226     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07227     RefAdaAST delta_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07228     ANTLR_USE_NAMESPACE(antlr)RefToken  d = ANTLR_USE_NAMESPACE(antlr)nullToken;
07229     RefAdaAST d_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07230     
07231     try {      // for error handling
07232         d = LT(1);
07233         if ( inputState->guessing == 0 ) {
07234             d_AST = astFactory->create(d);
07235             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get()));
07236         }
07237         match(DELTA);
07238         expression();
07239         if (inputState->guessing==0) {
07240             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07241         }
07242         range_constraint_opt();
07243         if (inputState->guessing==0) {
07244             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07245         }
07246         if ( inputState->guessing==0 ) {
07247 #line 696 "ada.g"
07248             Set(d_AST, DELTA_CONSTRAINT);
07249 #line 7250 "AdaParser.cpp"
07250         }
07251         delta_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07252     }
07253     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07254         if( inputState->guessing == 0 ) {
07255             reportError(ex);
07256             consume();
07257             consumeUntil(_tokenSet_58);
07258         } else {
07259             throw;
07260         }
07261     }
07262     returnAST = delta_constraint_AST;
07263 }
07264 
07265 void AdaParser::index_constraint() {
07266     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07267     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07268     RefAdaAST index_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07269     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
07270     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07271     
07272     try {      // for error handling
07273         p = LT(1);
07274         if ( inputState->guessing == 0 ) {
07275             p_AST = astFactory->create(p);
07276             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
07277         }
07278         match(LPAREN);
07279         discrete_range();
07280         if (inputState->guessing==0) {
07281             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07282         }
07283         { // ( ... )*
07284         for (;;) {
07285             if ((LA(1) == COMMA)) {
07286                 match(COMMA);
07287                 discrete_range();
07288                 if (inputState->guessing==0) {
07289                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07290                 }
07291             }
07292             else {
07293                 goto _loop218;
07294             }
07295             
07296         }
07297         _loop218:;
07298         } // ( ... )*
07299         match(RPAREN);
07300         if ( inputState->guessing==0 ) {
07301 #line 700 "ada.g"
07302             Set(p_AST, INDEX_CONSTRAINT);
07303 #line 7304 "AdaParser.cpp"
07304         }
07305         index_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07306     }
07307     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07308         if( inputState->guessing == 0 ) {
07309             reportError(ex);
07310             consume();
07311             consumeUntil(_tokenSet_58);
07312         } else {
07313             throw;
07314         }
07315     }
07316     returnAST = index_constraint_AST;
07317 }
07318 
07319 void AdaParser::discriminant_constraint() {
07320     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07321     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07322     RefAdaAST discriminant_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07323     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
07324     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07325     
07326     try {      // for error handling
07327         p = LT(1);
07328         if ( inputState->guessing == 0 ) {
07329             p_AST = astFactory->create(p);
07330             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
07331         }
07332         match(LPAREN);
07333         discriminant_association();
07334         if (inputState->guessing==0) {
07335             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07336         }
07337         { // ( ... )*
07338         for (;;) {
07339             if ((LA(1) == COMMA)) {
07340                 match(COMMA);
07341                 discriminant_association();
07342                 if (inputState->guessing==0) {
07343                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07344                 }
07345             }
07346             else {
07347                 goto _loop224;
07348             }
07349             
07350         }
07351         _loop224:;
07352         } // ( ... )*
07353         match(RPAREN);
07354         if ( inputState->guessing==0 ) {
07355 #line 710 "ada.g"
07356             Set(p_AST, DISCRIMINANT_CONSTRAINT);
07357 #line 7358 "AdaParser.cpp"
07358         }
07359         discriminant_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07360     }
07361     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07362         if( inputState->guessing == 0 ) {
07363             reportError(ex);
07364             consume();
07365             consumeUntil(_tokenSet_58);
07366         } else {
07367             throw;
07368         }
07369     }
07370     returnAST = discriminant_constraint_AST;
07371 }
07372 
07373 void AdaParser::discrete_range() {
07374     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07375     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07376     RefAdaAST discrete_range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07377     
07378     try {      // for error handling
07379         bool synPredMatched221 = false;
07380         if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) {
07381             int _m221 = mark();
07382             synPredMatched221 = true;
07383             inputState->guessing++;
07384             try {
07385                 {
07386                 range();
07387                 }
07388             }
07389             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
07390                 synPredMatched221 = false;
07391             }
07392             rewind(_m221);
07393             inputState->guessing--;
07394         }
07395         if ( synPredMatched221 ) {
07396             range();
07397             if (inputState->guessing==0) {
07398                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07399             }
07400             discrete_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07401         }
07402         else if ((LA(1) == IDENTIFIER) && (_tokenSet_67.member(LA(2)))) {
07403             subtype_ind();
07404             if (inputState->guessing==0) {
07405                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07406             }
07407             discrete_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07408         }
07409         else {
07410             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07411         }
07412         
07413     }
07414     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07415         if( inputState->guessing == 0 ) {
07416             reportError(ex);
07417             consume();
07418             consumeUntil(_tokenSet_7);
07419         } else {
07420             throw;
07421         }
07422     }
07423     returnAST = discrete_range_AST;
07424 }
07425 
07426 void AdaParser::discriminant_association() {
07427     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07428     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07429     RefAdaAST discriminant_association_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07430     
07431     try {      // for error handling
07432         selector_names_opt();
07433         if (inputState->guessing==0) {
07434             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07435         }
07436         expression();
07437         if (inputState->guessing==0) {
07438             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07439         }
07440         if ( inputState->guessing==0 ) {
07441             discriminant_association_AST = RefAdaAST(currentAST.root);
07442 #line 714 "ada.g"
07443             discriminant_association_AST =
07444                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_ASSOCIATION,"DISCRIMINANT_ASSOCIATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_association_AST.get()))));
07445 #line 7446 "AdaParser.cpp"
07446             currentAST.root = discriminant_association_AST;
07447             if ( discriminant_association_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07448                 discriminant_association_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07449                   currentAST.child = discriminant_association_AST->getFirstChild();
07450             else
07451                 currentAST.child = discriminant_association_AST;
07452             currentAST.advanceChildToEnd();
07453         }
07454         discriminant_association_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07455     }
07456     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07457         if( inputState->guessing == 0 ) {
07458             reportError(ex);
07459             consume();
07460             consumeUntil(_tokenSet_7);
07461         } else {
07462             throw;
07463         }
07464     }
07465     returnAST = discriminant_association_AST;
07466 }
07467 
07468 void AdaParser::selector_names_opt() {
07469     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07470     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07471     RefAdaAST selector_names_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07472     
07473     try {      // for error handling
07474         {
07475         bool synPredMatched229 = false;
07476         if (((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT || LA(2) == PIPE))) {
07477             int _m229 = mark();
07478             synPredMatched229 = true;
07479             inputState->guessing++;
07480             try {
07481                 {
07482                 association_head();
07483                 }
07484             }
07485             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
07486                 synPredMatched229 = false;
07487             }
07488             rewind(_m229);
07489             inputState->guessing--;
07490         }
07491         if ( synPredMatched229 ) {
07492             association_head();
07493             if (inputState->guessing==0) {
07494                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07495             }
07496         }
07497         else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) {
07498         }
07499         else {
07500             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07501         }
07502         
07503         }
07504         if ( inputState->guessing==0 ) {
07505             selector_names_opt_AST = RefAdaAST(currentAST.root);
07506 #line 722 "ada.g"
07507             selector_names_opt_AST =
07508                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SELECTOR_NAMES_OPT,"SELECTOR_NAMES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(selector_names_opt_AST.get()))));
07509 #line 7510 "AdaParser.cpp"
07510             currentAST.root = selector_names_opt_AST;
07511             if ( selector_names_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07512                 selector_names_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07513                   currentAST.child = selector_names_opt_AST->getFirstChild();
07514             else
07515                 currentAST.child = selector_names_opt_AST;
07516             currentAST.advanceChildToEnd();
07517         }
07518         selector_names_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07519     }
07520     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07521         if( inputState->guessing == 0 ) {
07522             reportError(ex);
07523             consume();
07524             consumeUntil(_tokenSet_5);
07525         } else {
07526             throw;
07527         }
07528     }
07529     returnAST = selector_names_opt_AST;
07530 }
07531 
07532 void AdaParser::association_head() {
07533     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07534     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07535     RefAdaAST association_head_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07536     
07537     try {      // for error handling
07538         selector_name();
07539         if (inputState->guessing==0) {
07540             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07541         }
07542         { // ( ... )*
07543         for (;;) {
07544             if ((LA(1) == PIPE)) {
07545                 match(PIPE);
07546                 selector_name();
07547                 if (inputState->guessing==0) {
07548                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07549                 }
07550             }
07551             else {
07552                 goto _loop232;
07553             }
07554             
07555         }
07556         _loop232:;
07557         } // ( ... )*
07558         match(RIGHT_SHAFT);
07559         association_head_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07560     }
07561     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07562         if( inputState->guessing == 0 ) {
07563             reportError(ex);
07564             consume();
07565             consumeUntil(_tokenSet_5);
07566         } else {
07567             throw;
07568         }
07569     }
07570     returnAST = association_head_AST;
07571 }
07572 
07573 void AdaParser::selector_name() {
07574     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07575     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07576     RefAdaAST selector_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07577     
07578     try {      // for error handling
07579         RefAdaAST tmp204_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07580         if ( inputState->guessing == 0 ) {
07581             tmp204_AST = astFactory->create(LT(1));
07582             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp204_AST.get()));
07583         }
07584         match(IDENTIFIER);
07585         selector_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07586     }
07587     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07588         if( inputState->guessing == 0 ) {
07589             reportError(ex);
07590             consume();
07591             consumeUntil(_tokenSet_68);
07592         } else {
07593             throw;
07594         }
07595     }
07596     returnAST = selector_name_AST;
07597 }
07598 
07599 void AdaParser::protected_opt() {
07600     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07601     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07602     RefAdaAST protected_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07603     
07604     try {      // for error handling
07605         {
07606         switch ( LA(1)) {
07607         case PROTECTED:
07608         {
07609             RefAdaAST tmp205_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07610             if ( inputState->guessing == 0 ) {
07611                 tmp205_AST = astFactory->create(LT(1));
07612                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp205_AST.get()));
07613             }
07614             match(PROTECTED);
07615             break;
07616         }
07617         case PROCEDURE:
07618         case FUNCTION:
07619         {
07620             break;
07621         }
07622         default:
07623         {
07624             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07625         }
07626         }
07627         }
07628         if ( inputState->guessing==0 ) {
07629             protected_opt_AST = RefAdaAST(currentAST.root);
07630 #line 747 "ada.g"
07631             protected_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(protected_opt_AST.get()))));
07632 #line 7633 "AdaParser.cpp"
07633             currentAST.root = protected_opt_AST;
07634             if ( protected_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07635                 protected_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07636                   currentAST.child = protected_opt_AST->getFirstChild();
07637             else
07638                 currentAST.child = protected_opt_AST;
07639             currentAST.advanceChildToEnd();
07640         }
07641         protected_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07642     }
07643     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07644         if( inputState->guessing == 0 ) {
07645             reportError(ex);
07646             consume();
07647             consumeUntil(_tokenSet_69);
07648         } else {
07649             throw;
07650         }
07651     }
07652     returnAST = protected_opt_AST;
07653 }
07654 
07655 void AdaParser::constant_all_opt() {
07656     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07657     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07658     RefAdaAST constant_all_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07659     
07660     try {      // for error handling
07661         {
07662         switch ( LA(1)) {
07663         case CONSTANT:
07664         {
07665             RefAdaAST tmp206_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07666             if ( inputState->guessing == 0 ) {
07667                 tmp206_AST = astFactory->create(LT(1));
07668                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp206_AST.get()));
07669             }
07670             match(CONSTANT);
07671             break;
07672         }
07673         case ALL:
07674         {
07675             RefAdaAST tmp207_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07676             if ( inputState->guessing == 0 ) {
07677                 tmp207_AST = astFactory->create(LT(1));
07678                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp207_AST.get()));
07679             }
07680             match(ALL);
07681             break;
07682         }
07683         case IDENTIFIER:
07684         {
07685             break;
07686         }
07687         default:
07688         {
07689             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07690         }
07691         }
07692         }
07693         if ( inputState->guessing==0 ) {
07694             constant_all_opt_AST = RefAdaAST(currentAST.root);
07695 #line 751 "ada.g"
07696             constant_all_opt_AST =
07697                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(constant_all_opt_AST.get()))));
07698 #line 7699 "AdaParser.cpp"
07699             currentAST.root = constant_all_opt_AST;
07700             if ( constant_all_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07701                 constant_all_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07702                   currentAST.child = constant_all_opt_AST->getFirstChild();
07703             else
07704                 currentAST.child = constant_all_opt_AST;
07705             currentAST.advanceChildToEnd();
07706         }
07707         constant_all_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07708     }
07709     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07710         if( inputState->guessing == 0 ) {
07711             reportError(ex);
07712             consume();
07713             consumeUntil(_tokenSet_39);
07714         } else {
07715             throw;
07716         }
07717     }
07718     returnAST = constant_all_opt_AST;
07719 }
07720 
07721 void AdaParser::abstract_opt() {
07722     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07723     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07724     RefAdaAST abstract_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07725     
07726     try {      // for error handling
07727         {
07728         switch ( LA(1)) {
07729         case ABSTRACT:
07730         {
07731             RefAdaAST tmp208_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07732             if ( inputState->guessing == 0 ) {
07733                 tmp208_AST = astFactory->create(LT(1));
07734                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp208_AST.get()));
07735             }
07736             match(ABSTRACT);
07737             break;
07738         }
07739         case NEW:
07740         {
07741             break;
07742         }
07743         default:
07744         {
07745             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07746         }
07747         }
07748         }
07749         if ( inputState->guessing==0 ) {
07750             abstract_opt_AST = RefAdaAST(currentAST.root);
07751 #line 771 "ada.g"
07752             abstract_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abstract_opt_AST.get()))));
07753 #line 7754 "AdaParser.cpp"
07754             currentAST.root = abstract_opt_AST;
07755             if ( abstract_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07756                 abstract_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07757                   currentAST.child = abstract_opt_AST->getFirstChild();
07758             else
07759                 currentAST.child = abstract_opt_AST;
07760             currentAST.advanceChildToEnd();
07761         }
07762         abstract_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07763     }
07764     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07765         if( inputState->guessing == 0 ) {
07766             reportError(ex);
07767             consume();
07768             consumeUntil(_tokenSet_70);
07769         } else {
07770             throw;
07771         }
07772     }
07773     returnAST = abstract_opt_AST;
07774 }
07775 
07776 void AdaParser::record_definition(
07777     bool has_discrim
07778 ) {
07779     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07780     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07781     RefAdaAST record_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07782     
07783     try {      // for error handling
07784         switch ( LA(1)) {
07785         case RECORD:
07786         {
07787             match(RECORD);
07788             component_list(has_discrim);
07789             if (inputState->guessing==0) {
07790                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07791             }
07792             match(END);
07793             match(RECORD);
07794             record_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07795             break;
07796         }
07797         case NuLL:
07798         {
07799             match(NuLL);
07800             match(RECORD);
07801             record_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07802             break;
07803         }
07804         default:
07805         {
07806             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07807         }
07808         }
07809     }
07810     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07811         if( inputState->guessing == 0 ) {
07812             reportError(ex);
07813             consume();
07814             consumeUntil(_tokenSet_4);
07815         } else {
07816             throw;
07817         }
07818     }
07819     returnAST = record_definition_AST;
07820 }
07821 
07822 void AdaParser::abstract_tagged_limited_opt() {
07823     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07824     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07825     RefAdaAST abstract_tagged_limited_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07826     
07827     try {      // for error handling
07828         {
07829         switch ( LA(1)) {
07830         case ABSTRACT:
07831         {
07832             RefAdaAST tmp214_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07833             if ( inputState->guessing == 0 ) {
07834                 tmp214_AST = astFactory->create(LT(1));
07835                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp214_AST.get()));
07836             }
07837             match(ABSTRACT);
07838             match(TAGGED);
07839             break;
07840         }
07841         case TAGGED:
07842         {
07843             RefAdaAST tmp216_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07844             if ( inputState->guessing == 0 ) {
07845                 tmp216_AST = astFactory->create(LT(1));
07846                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp216_AST.get()));
07847             }
07848             match(TAGGED);
07849             break;
07850         }
07851         case PRIVATE:
07852         case NuLL:
07853         case RECORD:
07854         case LIMITED:
07855         {
07856             break;
07857         }
07858         default:
07859         {
07860             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07861         }
07862         }
07863         }
07864         {
07865         switch ( LA(1)) {
07866         case LIMITED:
07867         {
07868             RefAdaAST tmp217_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07869             if ( inputState->guessing == 0 ) {
07870                 tmp217_AST = astFactory->create(LT(1));
07871                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp217_AST.get()));
07872             }
07873             match(LIMITED);
07874             break;
07875         }
07876         case PRIVATE:
07877         case NuLL:
07878         case RECORD:
07879         {
07880             break;
07881         }
07882         default:
07883         {
07884             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07885         }
07886         }
07887         }
07888         if ( inputState->guessing==0 ) {
07889             abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root);
07890 #line 833 "ada.g"
07891             abstract_tagged_limited_opt_AST =
07892                   RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abstract_tagged_limited_opt_AST.get()))));
07893 #line 7894 "AdaParser.cpp"
07894             currentAST.root = abstract_tagged_limited_opt_AST;
07895             if ( abstract_tagged_limited_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
07896                 abstract_tagged_limited_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
07897                   currentAST.child = abstract_tagged_limited_opt_AST->getFirstChild();
07898             else
07899                 currentAST.child = abstract_tagged_limited_opt_AST;
07900             currentAST.advanceChildToEnd();
07901         }
07902         abstract_tagged_limited_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07903     }
07904     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07905         if( inputState->guessing == 0 ) {
07906             reportError(ex);
07907             consume();
07908             consumeUntil(_tokenSet_71);
07909         } else {
07910             throw;
07911         }
07912     }
07913     returnAST = abstract_tagged_limited_opt_AST;
07914 }
07915 
07916 void AdaParser::component_list(
07917     bool has_discrim
07918 ) {
07919     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07920     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07921     RefAdaAST component_list_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07922     
07923     try {      // for error handling
07924         switch ( LA(1)) {
07925         case NuLL:
07926         {
07927             match(NuLL);
07928             match(SEMI);
07929             component_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07930             break;
07931         }
07932         case PRAGMA:
07933         case IDENTIFIER:
07934         {
07935             component_items();
07936             if (inputState->guessing==0) {
07937                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07938             }
07939             {
07940             switch ( LA(1)) {
07941             case CASE:
07942             {
07943                 variant_part();
07944                 if (inputState->guessing==0) {
07945                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07946                 }
07947                 if (!( has_discrim ))
07948                     throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim ");
07949                 break;
07950             }
07951             case END:
07952             case WHEN:
07953             {
07954                 break;
07955             }
07956             default:
07957             {
07958                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07959             }
07960             }
07961             }
07962             component_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07963             break;
07964         }
07965         case CASE:
07966         {
07967             empty_component_items();
07968             if (inputState->guessing==0) {
07969                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07970             }
07971             variant_part();
07972             if (inputState->guessing==0) {
07973                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07974             }
07975             if (!( has_discrim ))
07976                 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim ");
07977             component_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
07978             break;
07979         }
07980         default:
07981         {
07982             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07983         }
07984         }
07985     }
07986     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07987         if( inputState->guessing == 0 ) {
07988             reportError(ex);
07989             consume();
07990             consumeUntil(_tokenSet_72);
07991         } else {
07992             throw;
07993         }
07994     }
07995     returnAST = component_list_AST;
07996 }
07997 
07998 void AdaParser::component_items() {
07999     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08000     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08001     RefAdaAST component_items_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08002     
08003     try {      // for error handling
08004         { // ( ... )+
08005         int _cnt254=0;
08006         for (;;) {
08007             switch ( LA(1)) {
08008             case PRAGMA:
08009             {
08010                 pragma();
08011                 if (inputState->guessing==0) {
08012                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08013                 }
08014                 break;
08015             }
08016             case IDENTIFIER:
08017             {
08018                 comp_decl();
08019                 if (inputState->guessing==0) {
08020                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08021                 }
08022                 break;
08023             }
08024             default:
08025             {
08026                 if ( _cnt254>=1 ) { goto _loop254; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
08027             }
08028             }
08029             _cnt254++;
08030         }
08031         _loop254:;
08032         }  // ( ... )+
08033         if ( inputState->guessing==0 ) {
08034             component_items_AST = RefAdaAST(currentAST.root);
08035 #line 786 "ada.g"
08036             component_items_AST =
08037                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(component_items_AST.get()))));
08038 #line 8039 "AdaParser.cpp"
08039             currentAST.root = component_items_AST;
08040             if ( component_items_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
08041                 component_items_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
08042                   currentAST.child = component_items_AST->getFirstChild();
08043             else
08044                 currentAST.child = component_items_AST;
08045             currentAST.advanceChildToEnd();
08046         }
08047         component_items_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08048     }
08049     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08050         if( inputState->guessing == 0 ) {
08051             reportError(ex);
08052             consume();
08053             consumeUntil(_tokenSet_73);
08054         } else {
08055             throw;
08056         }
08057     }
08058     returnAST = component_items_AST;
08059 }
08060 
08061 void AdaParser::variant_part() {
08062     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08063     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08064     RefAdaAST variant_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08065     ANTLR_USE_NAMESPACE(antlr)RefToken  c = ANTLR_USE_NAMESPACE(antlr)nullToken;
08066     RefAdaAST c_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08067     
08068     try {      // for error handling
08069         c = LT(1);
08070         if ( inputState->guessing == 0 ) {
08071             c_AST = astFactory->create(c);
08072             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get()));
08073         }
08074         match(CASE);
08075         discriminant_direct_name();
08076         if (inputState->guessing==0) {
08077             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08078         }
08079         match(IS);
08080         variant_s();
08081         if (inputState->guessing==0) {
08082             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08083         }
08084         match(END);
08085         match(CASE);
08086         match(SEMI);
08087         if ( inputState->guessing==0 ) {
08088 #line 798 "ada.g"
08089             Set (c_AST, VARIANT_PART);
08090 #line 8091 "AdaParser.cpp"
08091         }
08092         variant_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08093     }
08094     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08095         if( inputState->guessing == 0 ) {
08096             reportError(ex);
08097             consume();
08098             consumeUntil(_tokenSet_72);
08099         } else {
08100             throw;
08101         }
08102     }
08103     returnAST = variant_part_AST;
08104 }
08105 
08106 void AdaParser::empty_component_items() {
08107     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08108     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08109     RefAdaAST empty_component_items_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08110     
08111     try {      // for error handling
08112         if ( inputState->guessing==0 ) {
08113             empty_component_items_AST = RefAdaAST(currentAST.root);
08114 #line 792 "ada.g"
08115             empty_component_items_AST =
08116                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(empty_component_items_AST.get()))));
08117 #line 8118 "AdaParser.cpp"
08118             currentAST.root = empty_component_items_AST;
08119             if ( empty_component_items_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
08120                 empty_component_items_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
08121                   currentAST.child = empty_component_items_AST->getFirstChild();
08122             else
08123                 currentAST.child = empty_component_items_AST;
08124             currentAST.advanceChildToEnd();
08125         }
08126         empty_component_items_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08127     }
08128     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08129         if( inputState->guessing == 0 ) {
08130             reportError(ex);
08131             consume();
08132             consumeUntil(_tokenSet_74);
08133         } else {
08134             throw;
08135         }
08136     }
08137     returnAST = empty_component_items_AST;
08138 }
08139 
08140 void AdaParser::discriminant_direct_name() {
08141     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08142     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08143     RefAdaAST discriminant_direct_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08144     
08145     try {      // for error handling
08146         RefAdaAST tmp224_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08147         if ( inputState->guessing == 0 ) {
08148             tmp224_AST = astFactory->create(LT(1));
08149             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp224_AST.get()));
08150         }
08151         match(IDENTIFIER);
08152         discriminant_direct_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08153     }
08154     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08155         if( inputState->guessing == 0 ) {
08156             reportError(ex);
08157             consume();
08158             consumeUntil(_tokenSet_75);
08159         } else {
08160             throw;
08161         }
08162     }
08163     returnAST = discriminant_direct_name_AST;
08164 }
08165 
08166 void AdaParser::variant_s() {
08167     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08168     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08169     RefAdaAST variant_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08170     
08171     try {      // for error handling
08172         { // ( ... )+
08173         int _cnt260=0;
08174         for (;;) {
08175             if ((LA(1) == WHEN)) {
08176                 variant();
08177                 if (inputState->guessing==0) {
08178                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08179                 }
08180             }
08181             else {
08182                 if ( _cnt260>=1 ) { goto _loop260; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
08183             }
08184             
08185             _cnt260++;
08186         }
08187         _loop260:;
08188         }  // ( ... )+
08189         if ( inputState->guessing==0 ) {
08190             variant_s_AST = RefAdaAST(currentAST.root);
08191 #line 805 "ada.g"
08192             variant_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VARIANTS,"VARIANTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(variant_s_AST.get()))));
08193 #line 8194 "AdaParser.cpp"
08194             currentAST.root = variant_s_AST;
08195             if ( variant_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
08196                 variant_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
08197                   currentAST.child = variant_s_AST->getFirstChild();
08198             else
08199                 currentAST.child = variant_s_AST;
08200             currentAST.advanceChildToEnd();
08201         }
08202         variant_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08203     }
08204     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08205         if( inputState->guessing == 0 ) {
08206             reportError(ex);
08207             consume();
08208             consumeUntil(_tokenSet_21);
08209         } else {
08210             throw;
08211         }
08212     }
08213     returnAST = variant_s_AST;
08214 }
08215 
08216 void AdaParser::variant() {
08217     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08218     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08219     RefAdaAST variant_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08220     ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
08221     RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08222     
08223     try {      // for error handling
08224         w = LT(1);
08225         if ( inputState->guessing == 0 ) {
08226             w_AST = astFactory->create(w);
08227             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
08228         }
08229         match(WHEN);
08230         choice_s();
08231         if (inputState->guessing==0) {
08232             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08233         }
08234         match(RIGHT_SHAFT);
08235         component_list(true);
08236         if (inputState->guessing==0) {
08237             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08238         }
08239         if ( inputState->guessing==0 ) {
08240 #line 809 "ada.g"
08241             Set (w_AST, VARIANT);
08242 #line 8243 "AdaParser.cpp"
08243         }
08244         variant_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08245     }
08246     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08247         if( inputState->guessing == 0 ) {
08248             reportError(ex);
08249             consume();
08250             consumeUntil(_tokenSet_72);
08251         } else {
08252             throw;
08253         }
08254     }
08255     returnAST = variant_AST;
08256 }
08257 
08258 void AdaParser::choice_s() {
08259     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08260     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08261     RefAdaAST choice_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08262     
08263     try {      // for error handling
08264         choice();
08265         if (inputState->guessing==0) {
08266             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08267         }
08268         { // ( ... )*
08269         for (;;) {
08270             if ((LA(1) == PIPE)) {
08271                 RefAdaAST tmp226_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08272                 if ( inputState->guessing == 0 ) {
08273                     tmp226_AST = astFactory->create(LT(1));
08274                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp226_AST.get()));
08275                 }
08276                 match(PIPE);
08277                 choice();
08278                 if (inputState->guessing==0) {
08279                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08280                 }
08281             }
08282             else {
08283                 goto _loop264;
08284             }
08285             
08286         }
08287         _loop264:;
08288         } // ( ... )*
08289         choice_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08290     }
08291     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08292         if( inputState->guessing == 0 ) {
08293             reportError(ex);
08294             consume();
08295             consumeUntil(_tokenSet_76);
08296         } else {
08297             throw;
08298         }
08299     }
08300     returnAST = choice_s_AST;
08301 }
08302 
08303 void AdaParser::choice() {
08304     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08305     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08306     RefAdaAST choice_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08307     
08308     try {      // for error handling
08309         if ((LA(1) == OTHERS)) {
08310             RefAdaAST tmp227_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08311             if ( inputState->guessing == 0 ) {
08312                 tmp227_AST = astFactory->create(LT(1));
08313                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp227_AST.get()));
08314             }
08315             match(OTHERS);
08316             choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08317         }
08318         else {
08319             bool synPredMatched267 = false;
08320             if (((_tokenSet_5.member(LA(1))) && (_tokenSet_77.member(LA(2))))) {
08321                 int _m267 = mark();
08322                 synPredMatched267 = true;
08323                 inputState->guessing++;
08324                 try {
08325                     {
08326                     discrete_with_range();
08327                     }
08328                 }
08329                 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
08330                     synPredMatched267 = false;
08331                 }
08332                 rewind(_m267);
08333                 inputState->guessing--;
08334             }
08335             if ( synPredMatched267 ) {
08336                 discrete_with_range();
08337                 if (inputState->guessing==0) {
08338                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08339                 }
08340                 choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08341             }
08342             else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_78.member(LA(2)))) {
08343                 expression();
08344                 if (inputState->guessing==0) {
08345                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08346                 }
08347                 choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08348             }
08349         else {
08350             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08351         }
08352         }
08353     }
08354     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08355         if( inputState->guessing == 0 ) {
08356             reportError(ex);
08357             consume();
08358             consumeUntil(_tokenSet_68);
08359         } else {
08360             throw;
08361         }
08362     }
08363     returnAST = choice_AST;
08364 }
08365 
08366 void AdaParser::discrete_with_range() {
08367     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08368     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08369     RefAdaAST discrete_with_range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08370     
08371     try {      // for error handling
08372         bool synPredMatched270 = false;
08373         if (((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == TIC || LA(2) == RANGE))) {
08374             int _m270 = mark();
08375             synPredMatched270 = true;
08376             inputState->guessing++;
08377             try {
08378                 {
08379                 mark_with_constraint();
08380                 }
08381             }
08382             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
08383                 synPredMatched270 = false;
08384             }
08385             rewind(_m270);
08386             inputState->guessing--;
08387         }
08388         if ( synPredMatched270 ) {
08389             mark_with_constraint();
08390             if (inputState->guessing==0) {
08391                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08392             }
08393             discrete_with_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08394         }
08395         else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2)))) {
08396             range();
08397             if (inputState->guessing==0) {
08398                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08399             }
08400             discrete_with_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08401         }
08402         else {
08403             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08404         }
08405         
08406     }
08407     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08408         if( inputState->guessing == 0 ) {
08409             reportError(ex);
08410             consume();
08411             consumeUntil(_tokenSet_68);
08412         } else {
08413             throw;
08414         }
08415     }
08416     returnAST = discrete_with_range_AST;
08417 }
08418 
08419 void AdaParser::mark_with_constraint() {
08420     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08421     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08422     RefAdaAST mark_with_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08423     
08424     try {      // for error handling
08425         subtype_mark();
08426         if (inputState->guessing==0) {
08427             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08428         }
08429         range_constraint();
08430         if (inputState->guessing==0) {
08431             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08432         }
08433         if ( inputState->guessing==0 ) {
08434             mark_with_constraint_AST = RefAdaAST(currentAST.root);
08435 #line 825 "ada.g"
08436             mark_with_constraint_AST =
08437                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MARK_WITH_CONSTRAINT,"MARK_WITH_CONSTRAINT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mark_with_constraint_AST.get()))));
08438 #line 8439 "AdaParser.cpp"
08439             currentAST.root = mark_with_constraint_AST;
08440             if ( mark_with_constraint_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
08441                 mark_with_constraint_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
08442                   currentAST.child = mark_with_constraint_AST->getFirstChild();
08443             else
08444                 currentAST.child = mark_with_constraint_AST;
08445             currentAST.advanceChildToEnd();
08446         }
08447         mark_with_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08448     }
08449     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08450         if( inputState->guessing == 0 ) {
08451             reportError(ex);
08452             consume();
08453             consumeUntil(_tokenSet_68);
08454         } else {
08455             throw;
08456         }
08457     }
08458     returnAST = mark_with_constraint_AST;
08459 }
08460 
08461 void AdaParser::generic_formal_part_opt() {
08462     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08463     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08464     RefAdaAST generic_formal_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08465     
08466     try {      // for error handling
08467         { // ( ... )*
08468         for (;;) {
08469             switch ( LA(1)) {
08470             case USE:
08471             {
08472                 use_clause();
08473                 if (inputState->guessing==0) {
08474                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08475                 }
08476                 break;
08477             }
08478             case PRAGMA:
08479             {
08480                 pragma();
08481                 if (inputState->guessing==0) {
08482                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08483                 }
08484                 break;
08485             }
08486             case IDENTIFIER:
08487             case WITH:
08488             case TYPE:
08489             {
08490                 generic_formal_parameter();
08491                 if (inputState->guessing==0) {
08492                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08493                 }
08494                 break;
08495             }
08496             default:
08497             {
08498                 goto _loop287;
08499             }
08500             }
08501         }
08502         _loop287:;
08503         } // ( ... )*
08504         if ( inputState->guessing==0 ) {
08505             generic_formal_part_opt_AST = RefAdaAST(currentAST.root);
08506 #line 871 "ada.g"
08507             generic_formal_part_opt_AST =
08508                         RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(GENERIC_FORMAL_PART,"GENERIC_FORMAL_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(generic_formal_part_opt_AST.get()))));
08509 #line 8510 "AdaParser.cpp"
08510             currentAST.root = generic_formal_part_opt_AST;
08511             if ( generic_formal_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
08512                 generic_formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
08513                   currentAST.child = generic_formal_part_opt_AST->getFirstChild();
08514             else
08515                 currentAST.child = generic_formal_part_opt_AST;
08516             currentAST.advanceChildToEnd();
08517         }
08518         generic_formal_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08519     }
08520     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08521         if( inputState->guessing == 0 ) {
08522             reportError(ex);
08523             consume();
08524             consumeUntil(_tokenSet_79);
08525         } else {
08526             throw;
08527         }
08528     }
08529     returnAST = generic_formal_part_opt_AST;
08530 }
08531 
08532 void AdaParser::generic_formal_parameter() {
08533     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08534     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08535     RefAdaAST generic_formal_parameter_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08536     ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
08537     RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08538     ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
08539     RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08540     
08541     try {      // for error handling
08542         {
08543         switch ( LA(1)) {
08544         case TYPE:
08545         {
08546             t = LT(1);
08547             if ( inputState->guessing == 0 ) {
08548                 t_AST = astFactory->create(t);
08549                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
08550             }
08551             match(TYPE);
08552             def_id(false);
08553             if (inputState->guessing==0) {
08554                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08555             }
08556             {
08557             switch ( LA(1)) {
08558             case IS:
08559             {
08560                 match(IS);
08561                 {
08562                 switch ( LA(1)) {
08563                 case LPAREN:
08564                 {
08565                     match(LPAREN);
08566                     match(BOX);
08567                     match(RPAREN);
08568                     if ( inputState->guessing==0 ) {
08569 #line 881 "ada.g"
08570                         Set (t_AST, FORMAL_DISCRETE_TYPE_DECLARATION);
08571 #line 8572 "AdaParser.cpp"
08572                     }
08573                     break;
08574                 }
08575                 case RANGE:
08576                 {
08577                     match(RANGE);
08578                     match(BOX);
08579                     if ( inputState->guessing==0 ) {
08580 #line 883 "ada.g"
08581                         Set (t_AST, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION);
08582 #line 8583 "AdaParser.cpp"
08583                     }
08584                     break;
08585                 }
08586                 case MOD:
08587                 {
08588                     match(MOD);
08589                     match(BOX);
08590                     if ( inputState->guessing==0 ) {
08591 #line 885 "ada.g"
08592                         Set (t_AST, FORMAL_MODULAR_TYPE_DECLARATION);
08593 #line 8594 "AdaParser.cpp"
08594                     }
08595                     break;
08596                 }
08597                 case DELTA:
08598                 {
08599                     match(DELTA);
08600                     match(BOX);
08601                     {
08602                     switch ( LA(1)) {
08603                     case DIGITS:
08604                     {
08605                         match(DIGITS);
08606                         match(BOX);
08607                         if ( inputState->guessing==0 ) {
08608 #line 888 "ada.g"
08609                             Set (t_AST, FORMAL_DECIMAL_FIXED_POINT_DECLARATION);
08610 #line 8611 "AdaParser.cpp"
08611                         }
08612                         break;
08613                     }
08614                     case SEMI:
08615                     {
08616                         if ( inputState->guessing==0 ) {
08617 #line 889 "ada.g"
08618                             Set (t_AST, FORMAL_ORDINARY_FIXED_POINT_DECLARATION);
08619 #line 8620 "AdaParser.cpp"
08620                         }
08621                         break;
08622                     }
08623                     default:
08624                     {
08625                         throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08626                     }
08627                     }
08628                     }
08629                     break;
08630                 }
08631                 case DIGITS:
08632                 {
08633                     match(DIGITS);
08634                     match(BOX);
08635                     if ( inputState->guessing==0 ) {
08636 #line 892 "ada.g"
08637                         Set (t_AST, FORMAL_FLOATING_POINT_DECLARATION);
08638 #line 8639 "AdaParser.cpp"
08639                     }
08640                     break;
08641                 }
08642                 case ARRAY:
08643                 {
08644                     array_type_definition(t_AST);
08645                     if (inputState->guessing==0) {
08646                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08647                     }
08648                     break;
08649                 }
08650                 case ACCESS:
08651                 {
08652                     access_type_definition(t_AST);
08653                     if (inputState->guessing==0) {
08654                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08655                     }
08656                     break;
08657                 }
08658                 case PRIVATE:
08659                 case NEW:
08660                 case ABSTRACT:
08661                 case TAGGED:
08662                 case LIMITED:
08663                 {
08664                     empty_discrim_opt();
08665                     if (inputState->guessing==0) {
08666                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08667                     }
08668                     discriminable_type_definition(t_AST);
08669                     if (inputState->guessing==0) {
08670                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08671                     }
08672                     break;
08673                 }
08674                 default:
08675                 {
08676                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08677                 }
08678                 }
08679                 }
08680                 break;
08681             }
08682             case LPAREN:
08683             {
08684                 discrim_part();
08685                 if (inputState->guessing==0) {
08686                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08687                 }
08688                 match(IS);
08689                 discriminable_type_definition(t_AST);
08690                 if (inputState->guessing==0) {
08691                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08692                 }
08693                 break;
08694             }
08695             default:
08696             {
08697                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08698             }
08699             }
08700             }
08701             if ( inputState->guessing==0 ) {
08702 #line 899 "ada.g"
08703                 pop_def_id();
08704 #line 8705 "AdaParser.cpp"
08705             }
08706             break;
08707         }
08708         case WITH:
08709         {
08710             w = LT(1);
08711             if ( inputState->guessing == 0 ) {
08712                 w_AST = astFactory->create(w);
08713                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
08714             }
08715             match(WITH);
08716             {
08717             switch ( LA(1)) {
08718             case PROCEDURE:
08719             {
08720                 match(PROCEDURE);
08721                 def_id(false);
08722                 if (inputState->guessing==0) {
08723                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08724                 }
08725                 formal_part_opt();
08726                 if (inputState->guessing==0) {
08727                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08728                 }
08729                 subprogram_default_opt();
08730                 if (inputState->guessing==0) {
08731                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08732                 }
08733                 if ( inputState->guessing==0 ) {
08734 #line 901 "ada.g"
08735                     Set(w_AST, FORMAL_PROCEDURE_DECLARATION);
08736 #line 8737 "AdaParser.cpp"
08737                 }
08738                 break;
08739             }
08740             case FUNCTION:
08741             {
08742                 match(FUNCTION);
08743                 def_designator(false);
08744                 if (inputState->guessing==0) {
08745                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08746                 }
08747                 function_tail();
08748                 if (inputState->guessing==0) {
08749                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08750                 }
08751                 subprogram_default_opt();
08752                 if (inputState->guessing==0) {
08753                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08754                 }
08755                 if ( inputState->guessing==0 ) {
08756 #line 903 "ada.g"
08757                     Set(w_AST, FORMAL_FUNCTION_DECLARATION);
08758 #line 8759 "AdaParser.cpp"
08759                 }
08760                 break;
08761             }
08762             case PACKAGE:
08763             {
08764                 match(PACKAGE);
08765                 def_id(false);
08766                 if (inputState->guessing==0) {
08767                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08768                 }
08769                 match(IS);
08770                 match(NEW);
08771                 compound_name();
08772                 if (inputState->guessing==0) {
08773                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08774                 }
08775                 formal_package_actual_part_opt();
08776                 if (inputState->guessing==0) {
08777                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08778                 }
08779                 if ( inputState->guessing==0 ) {
08780 #line 905 "ada.g"
08781                     Set(w_AST, FORMAL_PACKAGE_DECLARATION);
08782 #line 8783 "AdaParser.cpp"
08783                 }
08784                 break;
08785             }
08786             default:
08787             {
08788                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08789             }
08790             }
08791             }
08792             if ( inputState->guessing==0 ) {
08793 #line 907 "ada.g"
08794                 pop_def_id();
08795 #line 8796 "AdaParser.cpp"
08796             }
08797             break;
08798         }
08799         case IDENTIFIER:
08800         {
08801             parameter_specification();
08802             if (inputState->guessing==0) {
08803                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08804             }
08805             break;
08806         }
08807         default:
08808         {
08809             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08810         }
08811         }
08812         }
08813         match(SEMI);
08814         generic_formal_parameter_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08815     }
08816     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08817         if( inputState->guessing == 0 ) {
08818             reportError(ex);
08819             consume();
08820             consumeUntil(_tokenSet_80);
08821         } else {
08822             throw;
08823         }
08824     }
08825     returnAST = generic_formal_parameter_AST;
08826 }
08827 
08828 void AdaParser::discriminable_type_definition(
08829     RefAdaAST t
08830 ) {
08831     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08832     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08833     RefAdaAST discriminable_type_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08834     
08835     try {      // for error handling
08836         bool synPredMatched297 = false;
08837         if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) {
08838             int _m297 = mark();
08839             synPredMatched297 = true;
08840             inputState->guessing++;
08841             try {
08842                 {
08843                 {
08844                 switch ( LA(1)) {
08845                 case ABSTRACT:
08846                 {
08847                     match(ABSTRACT);
08848                     break;
08849                 }
08850                 case NEW:
08851                 {
08852                     break;
08853                 }
08854                 default:
08855                 {
08856                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08857                 }
08858                 }
08859                 }
08860                 match(NEW);
08861                 subtype_ind();
08862                 match(WITH);
08863                 }
08864             }
08865             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
08866                 synPredMatched297 = false;
08867             }
08868             rewind(_m297);
08869             inputState->guessing--;
08870         }
08871         if ( synPredMatched297 ) {
08872             abstract_opt();
08873             if (inputState->guessing==0) {
08874                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08875             }
08876             match(NEW);
08877             subtype_ind();
08878             if (inputState->guessing==0) {
08879                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08880             }
08881             match(WITH);
08882             match(PRIVATE);
08883             if ( inputState->guessing==0 ) {
08884 #line 916 "ada.g"
08885                 Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION);
08886 #line 8887 "AdaParser.cpp"
08887             }
08888             discriminable_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08889         }
08890         else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) {
08891             match(NEW);
08892             subtype_ind();
08893             if (inputState->guessing==0) {
08894                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08895             }
08896             if ( inputState->guessing==0 ) {
08897 #line 918 "ada.g"
08898                 Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION);
08899 #line 8900 "AdaParser.cpp"
08900             }
08901             discriminable_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08902         }
08903         else if ((_tokenSet_81.member(LA(1))) && (_tokenSet_82.member(LA(2)))) {
08904             abstract_tagged_limited_opt();
08905             if (inputState->guessing==0) {
08906                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08907             }
08908             match(PRIVATE);
08909             if ( inputState->guessing==0 ) {
08910 #line 920 "ada.g"
08911                 Set (t, FORMAL_PRIVATE_TYPE_DECLARATION);
08912 #line 8913 "AdaParser.cpp"
08913             }
08914             discriminable_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08915         }
08916         else {
08917             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08918         }
08919         
08920     }
08921     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08922         if( inputState->guessing == 0 ) {
08923             reportError(ex);
08924             consume();
08925             consumeUntil(_tokenSet_4);
08926         } else {
08927             throw;
08928         }
08929     }
08930     returnAST = discriminable_type_definition_AST;
08931 }
08932 
08933 void AdaParser::subprogram_default_opt() {
08934     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08935     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08936     RefAdaAST subprogram_default_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08937     
08938     try {      // for error handling
08939         {
08940         switch ( LA(1)) {
08941         case IS:
08942         {
08943             match(IS);
08944             {
08945             switch ( LA(1)) {
08946             case BOX:
08947             {
08948                 RefAdaAST tmp255_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08949                 if ( inputState->guessing == 0 ) {
08950                     tmp255_AST = astFactory->create(LT(1));
08951                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp255_AST.get()));
08952                 }
08953                 match(BOX);
08954                 break;
08955             }
08956             case IDENTIFIER:
08957             {
08958                 name();
08959                 if (inputState->guessing==0) {
08960                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08961                 }
08962                 break;
08963             }
08964             default:
08965             {
08966                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08967             }
08968             }
08969             }
08970             break;
08971         }
08972         case SEMI:
08973         {
08974             break;
08975         }
08976         default:
08977         {
08978             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08979         }
08980         }
08981         }
08982         subprogram_default_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
08983     }
08984     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08985         if( inputState->guessing == 0 ) {
08986             reportError(ex);
08987             consume();
08988             consumeUntil(_tokenSet_4);
08989         } else {
08990             throw;
08991         }
08992     }
08993     returnAST = subprogram_default_opt_AST;
08994 }
08995 
08996 void AdaParser::formal_package_actual_part_opt() {
08997     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08998     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08999     RefAdaAST formal_package_actual_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09000     
09001     try {      // for error handling
09002         {
09003         switch ( LA(1)) {
09004         case LPAREN:
09005         {
09006             match(LPAREN);
09007             {
09008             switch ( LA(1)) {
09009             case BOX:
09010             {
09011                 RefAdaAST tmp257_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09012                 if ( inputState->guessing == 0 ) {
09013                     tmp257_AST = astFactory->create(LT(1));
09014                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp257_AST.get()));
09015                 }
09016                 match(BOX);
09017                 break;
09018             }
09019             case IDENTIFIER:
09020             {
09021                 defining_identifier_list();
09022                 if (inputState->guessing==0) {
09023                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09024                 }
09025                 break;
09026             }
09027             default:
09028             {
09029                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09030             }
09031             }
09032             }
09033             match(RPAREN);
09034             break;
09035         }
09036         case SEMI:
09037         {
09038             break;
09039         }
09040         default:
09041         {
09042             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09043         }
09044         }
09045         }
09046         formal_package_actual_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09047     }
09048     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09049         if( inputState->guessing == 0 ) {
09050             reportError(ex);
09051             consume();
09052             consumeUntil(_tokenSet_4);
09053         } else {
09054             throw;
09055         }
09056     }
09057     returnAST = formal_package_actual_part_opt_AST;
09058 }
09059 
09060 void AdaParser::body_part() {
09061     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09062     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09063     RefAdaAST body_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09064     
09065     try {      // for error handling
09066         declarative_part();
09067         if (inputState->guessing==0) {
09068             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09069         }
09070         block_body();
09071         if (inputState->guessing==0) {
09072             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09073         }
09074         end_id_opt();
09075         body_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09076     }
09077     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09078         if( inputState->guessing == 0 ) {
09079             reportError(ex);
09080             consume();
09081             consumeUntil(_tokenSet_4);
09082         } else {
09083             throw;
09084         }
09085     }
09086     returnAST = body_part_AST;
09087 }
09088 
09089 void AdaParser::declarative_part() {
09090     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09091     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09092     RefAdaAST declarative_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09093     
09094     try {      // for error handling
09095         { // ( ... )*
09096         for (;;) {
09097             switch ( LA(1)) {
09098             case PRAGMA:
09099             {
09100                 pragma();
09101                 if (inputState->guessing==0) {
09102                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09103                 }
09104                 break;
09105             }
09106             case IDENTIFIER:
09107             case USE:
09108             case TYPE:
09109             case PACKAGE:
09110             case PROCEDURE:
09111             case FUNCTION:
09112             case TASK:
09113             case PROTECTED:
09114             case FOR:
09115             case SUBTYPE:
09116             case GENERIC:
09117             {
09118                 declarative_item();
09119                 if (inputState->guessing==0) {
09120                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09121                 }
09122                 break;
09123             }
09124             default:
09125             {
09126                 goto _loop314;
09127             }
09128             }
09129         }
09130         _loop314:;
09131         } // ( ... )*
09132         if ( inputState->guessing==0 ) {
09133             declarative_part_AST = RefAdaAST(currentAST.root);
09134 #line 964 "ada.g"
09135             declarative_part_AST =
09136                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DECLARATIVE_PART,"DECLARATIVE_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(declarative_part_AST.get()))));
09137 #line 9138 "AdaParser.cpp"
09138             currentAST.root = declarative_part_AST;
09139             if ( declarative_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
09140                 declarative_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
09141                   currentAST.child = declarative_part_AST->getFirstChild();
09142             else
09143                 currentAST.child = declarative_part_AST;
09144             currentAST.advanceChildToEnd();
09145         }
09146         declarative_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09147     }
09148     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09149         if( inputState->guessing == 0 ) {
09150             reportError(ex);
09151             consume();
09152             consumeUntil(_tokenSet_83);
09153         } else {
09154             throw;
09155         }
09156     }
09157     returnAST = declarative_part_AST;
09158 }
09159 
09160 void AdaParser::block_body() {
09161     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09162     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09163     RefAdaAST block_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09164     ANTLR_USE_NAMESPACE(antlr)RefToken  b = ANTLR_USE_NAMESPACE(antlr)nullToken;
09165     RefAdaAST b_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09166     
09167     try {      // for error handling
09168         b = LT(1);
09169         if ( inputState->guessing == 0 ) {
09170             b_AST = astFactory->create(b);
09171             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(b_AST.get()));
09172         }
09173         match(BEGIN);
09174         handled_stmt_s();
09175         if (inputState->guessing==0) {
09176             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09177         }
09178         if ( inputState->guessing==0 ) {
09179 #line 1044 "ada.g"
09180             Set(b_AST, BLOCK_BODY);
09181 #line 9182 "AdaParser.cpp"
09182         }
09183         block_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09184     }
09185     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09186         if( inputState->guessing == 0 ) {
09187             reportError(ex);
09188             consume();
09189             consumeUntil(_tokenSet_21);
09190         } else {
09191             throw;
09192         }
09193     }
09194     returnAST = block_body_AST;
09195 }
09196 
09197 void AdaParser::declarative_item() {
09198     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09199     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09200     RefAdaAST declarative_item_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09201     ANTLR_USE_NAMESPACE(antlr)RefToken  pkg = ANTLR_USE_NAMESPACE(antlr)nullToken;
09202     RefAdaAST pkg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09203     ANTLR_USE_NAMESPACE(antlr)RefToken  tsk = ANTLR_USE_NAMESPACE(antlr)nullToken;
09204     RefAdaAST tsk_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09205     ANTLR_USE_NAMESPACE(antlr)RefToken  pro = ANTLR_USE_NAMESPACE(antlr)nullToken;
09206     RefAdaAST pro_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09207     
09208     try {      // for error handling
09209         {
09210         switch ( LA(1)) {
09211         case PACKAGE:
09212         {
09213             pkg = LT(1);
09214             if ( inputState->guessing == 0 ) {
09215                 pkg_AST = astFactory->create(pkg);
09216                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get()));
09217             }
09218             match(PACKAGE);
09219             {
09220             switch ( LA(1)) {
09221             case BODY:
09222             {
09223                 body_is();
09224                 if (inputState->guessing==0) {
09225                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09226                 }
09227                 {
09228                 switch ( LA(1)) {
09229                 case SEPARATE:
09230                 {
09231                     separate();
09232                     if (inputState->guessing==0) {
09233                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09234                     }
09235                     if ( inputState->guessing==0 ) {
09236 #line 972 "ada.g"
09237                         Set(pkg_AST, PACKAGE_BODY_STUB);
09238 #line 9239 "AdaParser.cpp"
09239                     }
09240                     break;
09241                 }
09242                 case PRAGMA:
09243                 case IDENTIFIER:
09244                 case USE:
09245                 case TYPE:
09246                 case PACKAGE:
09247                 case PROCEDURE:
09248                 case FUNCTION:
09249                 case TASK:
09250                 case PROTECTED:
09251                 case FOR:
09252                 case END:
09253                 case SUBTYPE:
09254                 case GENERIC:
09255                 case BEGIN:
09256                 {
09257                     pkg_body_part();
09258                     if (inputState->guessing==0) {
09259                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09260                     }
09261                     end_id_opt();
09262                     if ( inputState->guessing==0 ) {
09263 #line 974 "ada.g"
09264                         Set(pkg_AST, PACKAGE_BODY);
09265 #line 9266 "AdaParser.cpp"
09266                     }
09267                     break;
09268                 }
09269                 default:
09270                 {
09271                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09272                 }
09273                 }
09274                 }
09275                 match(SEMI);
09276                 break;
09277             }
09278             case IDENTIFIER:
09279             {
09280                 def_id(false);
09281                 if (inputState->guessing==0) {
09282                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09283                 }
09284                 spec_decl_part(pkg_AST);
09285                 if (inputState->guessing==0) {
09286                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09287                 }
09288                 break;
09289             }
09290             default:
09291             {
09292                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09293             }
09294             }
09295             }
09296             break;
09297         }
09298         case TASK:
09299         {
09300             tsk = LT(1);
09301             if ( inputState->guessing == 0 ) {
09302                 tsk_AST = astFactory->create(tsk);
09303                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tsk_AST.get()));
09304             }
09305             match(TASK);
09306             {
09307             switch ( LA(1)) {
09308             case BODY:
09309             {
09310                 body_is();
09311                 if (inputState->guessing==0) {
09312                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09313                 }
09314                 {
09315                 switch ( LA(1)) {
09316                 case SEPARATE:
09317                 {
09318                     separate();
09319                     if (inputState->guessing==0) {
09320                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09321                     }
09322                     if ( inputState->guessing==0 ) {
09323 #line 980 "ada.g"
09324                         Set(tsk_AST, TASK_BODY_STUB);
09325 #line 9326 "AdaParser.cpp"
09326                     }
09327                     break;
09328                 }
09329                 case PRAGMA:
09330                 case IDENTIFIER:
09331                 case USE:
09332                 case TYPE:
09333                 case PACKAGE:
09334                 case PROCEDURE:
09335                 case FUNCTION:
09336                 case TASK:
09337                 case PROTECTED:
09338                 case FOR:
09339                 case SUBTYPE:
09340                 case GENERIC:
09341                 case BEGIN:
09342                 {
09343                     body_part();
09344                     if (inputState->guessing==0) {
09345                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09346                     }
09347                     if ( inputState->guessing==0 ) {
09348 #line 981 "ada.g"
09349                         Set(tsk_AST, TASK_BODY);
09350 #line 9351 "AdaParser.cpp"
09351                     }
09352                     break;
09353                 }
09354                 default:
09355                 {
09356                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09357                 }
09358                 }
09359                 }
09360                 match(SEMI);
09361                 break;
09362             }
09363             case IDENTIFIER:
09364             case TYPE:
09365             {
09366                 task_type_or_single_decl(tsk_AST);
09367                 if (inputState->guessing==0) {
09368                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09369                 }
09370                 break;
09371             }
09372             default:
09373             {
09374                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09375             }
09376             }
09377             }
09378             break;
09379         }
09380         case PROTECTED:
09381         {
09382             pro = LT(1);
09383             if ( inputState->guessing == 0 ) {
09384                 pro_AST = astFactory->create(pro);
09385                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pro_AST.get()));
09386             }
09387             match(PROTECTED);
09388             {
09389             switch ( LA(1)) {
09390             case BODY:
09391             {
09392                 body_is();
09393                 if (inputState->guessing==0) {
09394                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09395                 }
09396                 {
09397                 switch ( LA(1)) {
09398                 case SEPARATE:
09399                 {
09400                     separate();
09401                     if (inputState->guessing==0) {
09402                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09403                     }
09404                     if ( inputState->guessing==0 ) {
09405 #line 988 "ada.g"
09406                         Set(pro_AST, PROTECTED_BODY_STUB);
09407 #line 9408 "AdaParser.cpp"
09408                     }
09409                     break;
09410                 }
09411                 case PRAGMA:
09412                 case PROCEDURE:
09413                 case FUNCTION:
09414                 case ENTRY:
09415                 case END:
09416                 {
09417                     prot_op_bodies_opt();
09418                     if (inputState->guessing==0) {
09419                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09420                     }
09421                     end_id_opt();
09422                     if ( inputState->guessing==0 ) {
09423 #line 990 "ada.g"
09424                         Set(pro_AST, PROTECTED_BODY);
09425 #line 9426 "AdaParser.cpp"
09426                     }
09427                     break;
09428                 }
09429                 default:
09430                 {
09431                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09432                 }
09433                 }
09434                 }
09435                 break;
09436             }
09437             case IDENTIFIER:
09438             case TYPE:
09439             {
09440                 prot_type_or_single_decl(pro_AST);
09441                 if (inputState->guessing==0) {
09442                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09443                 }
09444                 break;
09445             }
09446             default:
09447             {
09448                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09449             }
09450             }
09451             }
09452             match(SEMI);
09453             break;
09454         }
09455         case PROCEDURE:
09456         case FUNCTION:
09457         {
09458             subprog_decl_or_rename_or_inst_or_body(false);
09459             if (inputState->guessing==0) {
09460                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09461             }
09462             break;
09463         }
09464         case IDENTIFIER:
09465         case USE:
09466         case TYPE:
09467         case FOR:
09468         case SUBTYPE:
09469         case GENERIC:
09470         {
09471             decl_common();
09472             if (inputState->guessing==0) {
09473                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09474             }
09475             break;
09476         }
09477         default:
09478         {
09479             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09480         }
09481         }
09482         }
09483         declarative_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09484     }
09485     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09486         if( inputState->guessing == 0 ) {
09487             reportError(ex);
09488             consume();
09489             consumeUntil(_tokenSet_84);
09490         } else {
09491             throw;
09492         }
09493     }
09494     returnAST = declarative_item_AST;
09495 }
09496 
09497 void AdaParser::body_is() {
09498     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09499     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09500     RefAdaAST body_is_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09501     
09502     try {      // for error handling
09503         match(BODY);
09504         def_id(false);
09505         if (inputState->guessing==0) {
09506             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09507         }
09508         match(IS);
09509         body_is_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09510     }
09511     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09512         if( inputState->guessing == 0 ) {
09513             reportError(ex);
09514             consume();
09515             consumeUntil(_tokenSet_85);
09516         } else {
09517             throw;
09518         }
09519     }
09520     returnAST = body_is_AST;
09521 }
09522 
09523 void AdaParser::separate() {
09524     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09525     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09526     RefAdaAST separate_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09527     
09528     try {      // for error handling
09529         match(SEPARATE);
09530         if ( inputState->guessing==0 ) {
09531 #line 1009 "ada.g"
09532             pop_def_id();
09533 #line 9534 "AdaParser.cpp"
09534         }
09535         separate_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09536     }
09537     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09538         if( inputState->guessing == 0 ) {
09539             reportError(ex);
09540             consume();
09541             consumeUntil(_tokenSet_4);
09542         } else {
09543             throw;
09544         }
09545     }
09546     returnAST = separate_AST;
09547 }
09548 
09549 void AdaParser::prot_op_bodies_opt() {
09550     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09551     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09552     RefAdaAST prot_op_bodies_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09553     
09554     try {      // for error handling
09555         { // ( ... )*
09556         for (;;) {
09557             switch ( LA(1)) {
09558             case ENTRY:
09559             {
09560                 entry_body();
09561                 if (inputState->guessing==0) {
09562                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09563                 }
09564                 break;
09565             }
09566             case PROCEDURE:
09567             case FUNCTION:
09568             {
09569                 subprog_decl_or_body();
09570                 if (inputState->guessing==0) {
09571                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09572                 }
09573                 break;
09574             }
09575             case PRAGMA:
09576             {
09577                 pragma();
09578                 if (inputState->guessing==0) {
09579                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09580                 }
09581                 break;
09582             }
09583             default:
09584             {
09585                 goto _loop330;
09586             }
09587             }
09588         }
09589         _loop330:;
09590         } // ( ... )*
09591         if ( inputState->guessing==0 ) {
09592             prot_op_bodies_opt_AST = RefAdaAST(currentAST.root);
09593 #line 1025 "ada.g"
09594             prot_op_bodies_opt_AST =
09595                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_OP_BODIES_OPT,"PROT_OP_BODIES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_op_bodies_opt_AST.get()))));
09596 #line 9597 "AdaParser.cpp"
09597             currentAST.root = prot_op_bodies_opt_AST;
09598             if ( prot_op_bodies_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
09599                 prot_op_bodies_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
09600                   currentAST.child = prot_op_bodies_opt_AST->getFirstChild();
09601             else
09602                 currentAST.child = prot_op_bodies_opt_AST;
09603             currentAST.advanceChildToEnd();
09604         }
09605         prot_op_bodies_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09606     }
09607     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09608         if( inputState->guessing == 0 ) {
09609             reportError(ex);
09610             consume();
09611             consumeUntil(_tokenSet_21);
09612         } else {
09613             throw;
09614         }
09615     }
09616     returnAST = prot_op_bodies_opt_AST;
09617 }
09618 
09619 void AdaParser::block_body_opt() {
09620     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09621     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09622     RefAdaAST block_body_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09623     
09624     try {      // for error handling
09625         {
09626         switch ( LA(1)) {
09627         case BEGIN:
09628         {
09629             match(BEGIN);
09630             handled_stmt_s();
09631             if (inputState->guessing==0) {
09632                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09633             }
09634             break;
09635         }
09636         case END:
09637         {
09638             break;
09639         }
09640         default:
09641         {
09642             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09643         }
09644         }
09645         }
09646         if ( inputState->guessing==0 ) {
09647             block_body_opt_AST = RefAdaAST(currentAST.root);
09648 #line 1016 "ada.g"
09649             block_body_opt_AST =
09650                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BLOCK_BODY_OPT,"BLOCK_BODY_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(block_body_opt_AST.get()))));
09651 #line 9652 "AdaParser.cpp"
09652             currentAST.root = block_body_opt_AST;
09653             if ( block_body_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
09654                 block_body_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
09655                   currentAST.child = block_body_opt_AST->getFirstChild();
09656             else
09657                 currentAST.child = block_body_opt_AST;
09658             currentAST.advanceChildToEnd();
09659         }
09660         block_body_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09661     }
09662     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09663         if( inputState->guessing == 0 ) {
09664             reportError(ex);
09665             consume();
09666             consumeUntil(_tokenSet_21);
09667         } else {
09668             throw;
09669         }
09670     }
09671     returnAST = block_body_opt_AST;
09672 }
09673 
09674 void AdaParser::handled_stmt_s() {
09675     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09676     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09677     RefAdaAST handled_stmt_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09678     
09679     try {      // for error handling
09680         statements();
09681         if (inputState->guessing==0) {
09682             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09683         }
09684         except_handler_part_opt();
09685         if (inputState->guessing==0) {
09686             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09687         }
09688         if ( inputState->guessing==0 ) {
09689             handled_stmt_s_AST = RefAdaAST(currentAST.root);
09690 #line 1048 "ada.g"
09691             handled_stmt_s_AST =
09692                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(HANDLED_SEQUENCE_OF_STATEMENTS,"HANDLED_SEQUENCE_OF_STATEMENTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(handled_stmt_s_AST.get()))));
09693 #line 9694 "AdaParser.cpp"
09694             currentAST.root = handled_stmt_s_AST;
09695             if ( handled_stmt_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
09696                 handled_stmt_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
09697                   currentAST.child = handled_stmt_s_AST->getFirstChild();
09698             else
09699                 currentAST.child = handled_stmt_s_AST;
09700             currentAST.advanceChildToEnd();
09701         }
09702         handled_stmt_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09703     }
09704     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09705         if( inputState->guessing == 0 ) {
09706             reportError(ex);
09707             consume();
09708             consumeUntil(_tokenSet_21);
09709         } else {
09710             throw;
09711         }
09712     }
09713     returnAST = handled_stmt_s_AST;
09714 }
09715 
09716 void AdaParser::entry_body() {
09717     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09718     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09719     RefAdaAST entry_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09720     ANTLR_USE_NAMESPACE(antlr)RefToken  e = ANTLR_USE_NAMESPACE(antlr)nullToken;
09721     RefAdaAST e_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09722     
09723     try {      // for error handling
09724         e = LT(1);
09725         if ( inputState->guessing == 0 ) {
09726             e_AST = astFactory->create(e);
09727             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(e_AST.get()));
09728         }
09729         match(ENTRY);
09730         def_id(false);
09731         if (inputState->guessing==0) {
09732             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09733         }
09734         entry_body_formal_part();
09735         if (inputState->guessing==0) {
09736             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09737         }
09738         entry_barrier();
09739         if (inputState->guessing==0) {
09740             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09741         }
09742         match(IS);
09743         body_part();
09744         if (inputState->guessing==0) {
09745             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09746         }
09747         match(SEMI);
09748         if ( inputState->guessing==0 ) {
09749 #line 1211 "ada.g"
09750             Set (e_AST, ENTRY_BODY);
09751 #line 9752 "AdaParser.cpp"
09752         }
09753         entry_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09754     }
09755     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09756         if( inputState->guessing == 0 ) {
09757             reportError(ex);
09758             consume();
09759             consumeUntil(_tokenSet_86);
09760         } else {
09761             throw;
09762         }
09763     }
09764     returnAST = entry_body_AST;
09765 }
09766 
09767 void AdaParser::subprog_decl_or_body() {
09768     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09769     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09770     RefAdaAST subprog_decl_or_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09771     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
09772     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09773     ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
09774     RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09775     
09776     try {      // for error handling
09777         switch ( LA(1)) {
09778         case PROCEDURE:
09779         {
09780             p = LT(1);
09781             if ( inputState->guessing == 0 ) {
09782                 p_AST = astFactory->create(p);
09783                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
09784             }
09785             match(PROCEDURE);
09786             def_id(false);
09787             if (inputState->guessing==0) {
09788                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09789             }
09790             formal_part_opt();
09791             if (inputState->guessing==0) {
09792                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09793             }
09794             {
09795             switch ( LA(1)) {
09796             case IS:
09797             {
09798                 match(IS);
09799                 body_part();
09800                 if (inputState->guessing==0) {
09801                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09802                 }
09803                 if ( inputState->guessing==0 ) {
09804 #line 1032 "ada.g"
09805                     Set(p_AST, PROCEDURE_BODY);
09806 #line 9807 "AdaParser.cpp"
09807                 }
09808                 break;
09809             }
09810             case SEMI:
09811             {
09812                 if ( inputState->guessing==0 ) {
09813 #line 1033 "ada.g"
09814                     pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION);
09815 #line 9816 "AdaParser.cpp"
09816                 }
09817                 break;
09818             }
09819             default:
09820             {
09821                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09822             }
09823             }
09824             }
09825             match(SEMI);
09826             subprog_decl_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09827             break;
09828         }
09829         case FUNCTION:
09830         {
09831             f = LT(1);
09832             if ( inputState->guessing == 0 ) {
09833                 f_AST = astFactory->create(f);
09834                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
09835             }
09836             match(FUNCTION);
09837             def_designator(false);
09838             if (inputState->guessing==0) {
09839                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09840             }
09841             function_tail();
09842             if (inputState->guessing==0) {
09843                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09844             }
09845             {
09846             switch ( LA(1)) {
09847             case IS:
09848             {
09849                 match(IS);
09850                 body_part();
09851                 if (inputState->guessing==0) {
09852                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09853                 }
09854                 if ( inputState->guessing==0 ) {
09855 #line 1037 "ada.g"
09856                     Set(f_AST, FUNCTION_BODY);
09857 #line 9858 "AdaParser.cpp"
09858                 }
09859                 break;
09860             }
09861             case SEMI:
09862             {
09863                 if ( inputState->guessing==0 ) {
09864 #line 1038 "ada.g"
09865                     pop_def_id(); Set(f_AST, FUNCTION_DECLARATION);
09866 #line 9867 "AdaParser.cpp"
09867                 }
09868                 break;
09869             }
09870             default:
09871             {
09872                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09873             }
09874             }
09875             }
09876             match(SEMI);
09877             subprog_decl_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09878             break;
09879         }
09880         default:
09881         {
09882             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09883         }
09884         }
09885     }
09886     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09887         if( inputState->guessing == 0 ) {
09888             reportError(ex);
09889             consume();
09890             consumeUntil(_tokenSet_86);
09891         } else {
09892             throw;
09893         }
09894     }
09895     returnAST = subprog_decl_or_body_AST;
09896 }
09897 
09898 void AdaParser::statements() {
09899     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09900     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09901     RefAdaAST statements_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09902     
09903     try {      // for error handling
09904         { // ( ... )+
09905         int _cnt338=0;
09906         for (;;) {
09907             switch ( LA(1)) {
09908             case PRAGMA:
09909             {
09910                 pragma();
09911                 if (inputState->guessing==0) {
09912                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09913                 }
09914                 break;
09915             }
09916             case IDENTIFIER:
09917             case NuLL:
09918             case RETURN:
09919             case FOR:
09920             case CASE:
09921             case BEGIN:
09922             case LT_LT:
09923             case IF:
09924             case LOOP:
09925             case WHILE:
09926             case DECLARE:
09927             case EXIT:
09928             case GOTO:
09929             case ACCEPT:
09930             case DELAY:
09931             case SELECT:
09932             case ABORT:
09933             case RAISE:
09934             case REQUEUE:
09935             {
09936                 statement();
09937                 if (inputState->guessing==0) {
09938                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09939                 }
09940                 break;
09941             }
09942             default:
09943             {
09944                 if ( _cnt338>=1 ) { goto _loop338; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
09945             }
09946             }
09947             _cnt338++;
09948         }
09949         _loop338:;
09950         }  // ( ... )+
09951         if ( inputState->guessing==0 ) {
09952             statements_AST = RefAdaAST(currentAST.root);
09953 #line 1054 "ada.g"
09954             statements_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SEQUENCE_OF_STATEMENTS,"SEQUENCE_OF_STATEMENTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(statements_AST.get()))));
09955 #line 9956 "AdaParser.cpp"
09956             currentAST.root = statements_AST;
09957             if ( statements_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
09958                 statements_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
09959                   currentAST.child = statements_AST->getFirstChild();
09960             else
09961                 currentAST.child = statements_AST;
09962             currentAST.advanceChildToEnd();
09963         }
09964         statements_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
09965     }
09966     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09967         if( inputState->guessing == 0 ) {
09968             reportError(ex);
09969             consume();
09970             consumeUntil(_tokenSet_87);
09971         } else {
09972             throw;
09973         }
09974     }
09975     returnAST = statements_AST;
09976 }
09977 
09978 void AdaParser::except_handler_part_opt() {
09979     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09980     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09981     RefAdaAST except_handler_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09982     
09983     try {      // for error handling
09984         {
09985         switch ( LA(1)) {
09986         case EXCEPTION:
09987         {
09988             match(EXCEPTION);
09989             { // ( ... )+
09990             int _cnt424=0;
09991             for (;;) {
09992                 if ((LA(1) == WHEN)) {
09993                     exception_handler();
09994                     if (inputState->guessing==0) {
09995                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09996                     }
09997                 }
09998                 else {
09999                     if ( _cnt424>=1 ) { goto _loop424; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
10000                 }
10001                 
10002                 _cnt424++;
10003             }
10004             _loop424:;
10005             }  // ( ... )+
10006             break;
10007         }
10008         case END:
10009         {
10010             break;
10011         }
10012         default:
10013         {
10014             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10015         }
10016         }
10017         }
10018         if ( inputState->guessing==0 ) {
10019             except_handler_part_opt_AST = RefAdaAST(currentAST.root);
10020 #line 1340 "ada.g"
10021             except_handler_part_opt_AST =
10022                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXCEPT_HANDLER_PART_OPT,"EXCEPT_HANDLER_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(except_handler_part_opt_AST.get()))));
10023 #line 10024 "AdaParser.cpp"
10024             currentAST.root = except_handler_part_opt_AST;
10025             if ( except_handler_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
10026                 except_handler_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
10027                   currentAST.child = except_handler_part_opt_AST->getFirstChild();
10028             else
10029                 currentAST.child = except_handler_part_opt_AST;
10030             currentAST.advanceChildToEnd();
10031         }
10032         except_handler_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10033     }
10034     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10035         if( inputState->guessing == 0 ) {
10036             reportError(ex);
10037             consume();
10038             consumeUntil(_tokenSet_21);
10039         } else {
10040             throw;
10041         }
10042     }
10043     returnAST = except_handler_part_opt_AST;
10044 }
10045 
10046 void AdaParser::statement() {
10047     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10048     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10049     RefAdaAST statement_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10050     
10051     try {      // for error handling
10052         def_label_opt();
10053         if (inputState->guessing==0) {
10054             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10055         }
10056         {
10057         switch ( LA(1)) {
10058         case NuLL:
10059         {
10060             null_stmt();
10061             if (inputState->guessing==0) {
10062                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10063             }
10064             break;
10065         }
10066         case EXIT:
10067         {
10068             exit_stmt();
10069             if (inputState->guessing==0) {
10070                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10071             }
10072             break;
10073         }
10074         case RETURN:
10075         {
10076             return_stmt();
10077             if (inputState->guessing==0) {
10078                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10079             }
10080             break;
10081         }
10082         case GOTO:
10083         {
10084             goto_stmt();
10085             if (inputState->guessing==0) {
10086                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10087             }
10088             break;
10089         }
10090         case DELAY:
10091         {
10092             delay_stmt();
10093             if (inputState->guessing==0) {
10094                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10095             }
10096             break;
10097         }
10098         case ABORT:
10099         {
10100             abort_stmt();
10101             if (inputState->guessing==0) {
10102                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10103             }
10104             break;
10105         }
10106         case RAISE:
10107         {
10108             raise_stmt();
10109             if (inputState->guessing==0) {
10110                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10111             }
10112             break;
10113         }
10114         case REQUEUE:
10115         {
10116             requeue_stmt();
10117             if (inputState->guessing==0) {
10118                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10119             }
10120             break;
10121         }
10122         case ACCEPT:
10123         {
10124             accept_stmt();
10125             if (inputState->guessing==0) {
10126                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10127             }
10128             break;
10129         }
10130         case SELECT:
10131         {
10132             select_stmt();
10133             if (inputState->guessing==0) {
10134                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10135             }
10136             break;
10137         }
10138         case IF:
10139         {
10140             if_stmt();
10141             if (inputState->guessing==0) {
10142                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10143             }
10144             break;
10145         }
10146         case CASE:
10147         {
10148             case_stmt();
10149             if (inputState->guessing==0) {
10150                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10151             }
10152             break;
10153         }
10154         case FOR:
10155         case LOOP:
10156         case WHILE:
10157         {
10158             loop_stmt();
10159             if (inputState->guessing==0) {
10160                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10161             }
10162             match(SEMI);
10163             break;
10164         }
10165         case BEGIN:
10166         case DECLARE:
10167         {
10168             block();
10169             if (inputState->guessing==0) {
10170                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10171             }
10172             match(END);
10173             match(SEMI);
10174             break;
10175         }
10176         default:
10177             if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
10178                 statement_identifier();
10179                 if (inputState->guessing==0) {
10180                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10181                 }
10182                 {
10183                 switch ( LA(1)) {
10184                 case FOR:
10185                 case LOOP:
10186                 case WHILE:
10187                 {
10188                     loop_stmt();
10189                     if (inputState->guessing==0) {
10190                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10191                     }
10192                     id_opt();
10193                     match(SEMI);
10194                     break;
10195                 }
10196                 case BEGIN:
10197                 case DECLARE:
10198                 {
10199                     block();
10200                     if (inputState->guessing==0) {
10201                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10202                     }
10203                     end_id_opt();
10204                     match(SEMI);
10205                     break;
10206                 }
10207                 default:
10208                 {
10209                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10210                 }
10211                 }
10212                 }
10213             }
10214             else if ((LA(1) == IDENTIFIER) && (_tokenSet_88.member(LA(2)))) {
10215                 call_or_assignment();
10216                 if (inputState->guessing==0) {
10217                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10218                 }
10219             }
10220         else {
10221             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10222         }
10223         }
10224         }
10225         if ( inputState->guessing==0 ) {
10226             statement_AST = RefAdaAST(currentAST.root);
10227 #line 1080 "ada.g"
10228             statement_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(STATEMENT,"STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(statement_AST.get()))));
10229 #line 10230 "AdaParser.cpp"
10230             currentAST.root = statement_AST;
10231             if ( statement_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
10232                 statement_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
10233                   currentAST.child = statement_AST->getFirstChild();
10234             else
10235                 currentAST.child = statement_AST;
10236             currentAST.advanceChildToEnd();
10237         }
10238         statement_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10239     }
10240     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10241         if( inputState->guessing == 0 ) {
10242             reportError(ex);
10243             consume();
10244             consumeUntil(_tokenSet_89);
10245         } else {
10246             throw;
10247         }
10248     }
10249     returnAST = statement_AST;
10250 }
10251 
10252 void AdaParser::def_label_opt() {
10253     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10254     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10255     RefAdaAST def_label_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10256     
10257     try {      // for error handling
10258         {
10259         switch ( LA(1)) {
10260         case LT_LT:
10261         {
10262             match(LT_LT);
10263             RefAdaAST tmp279_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10264             if ( inputState->guessing == 0 ) {
10265                 tmp279_AST = astFactory->create(LT(1));
10266                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp279_AST.get()));
10267             }
10268             match(IDENTIFIER);
10269             match(GT_GT);
10270             break;
10271         }
10272         case IDENTIFIER:
10273         case NuLL:
10274         case RETURN:
10275         case FOR:
10276         case CASE:
10277         case BEGIN:
10278         case IF:
10279         case LOOP:
10280         case WHILE:
10281         case DECLARE:
10282         case EXIT:
10283         case GOTO:
10284         case ACCEPT:
10285         case DELAY:
10286         case SELECT:
10287         case ABORT:
10288         case RAISE:
10289         case REQUEUE:
10290         {
10291             break;
10292         }
10293         default:
10294         {
10295             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10296         }
10297         }
10298         }
10299         if ( inputState->guessing==0 ) {
10300             def_label_opt_AST = RefAdaAST(currentAST.root);
10301 #line 1084 "ada.g"
10302             def_label_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LABEL_OPT,"LABEL_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(def_label_opt_AST.get()))));
10303 #line 10304 "AdaParser.cpp"
10304             currentAST.root = def_label_opt_AST;
10305             if ( def_label_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
10306                 def_label_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
10307                   currentAST.child = def_label_opt_AST->getFirstChild();
10308             else
10309                 currentAST.child = def_label_opt_AST;
10310             currentAST.advanceChildToEnd();
10311         }
10312         def_label_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10313     }
10314     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10315         if( inputState->guessing == 0 ) {
10316             reportError(ex);
10317             consume();
10318             consumeUntil(_tokenSet_90);
10319         } else {
10320             throw;
10321         }
10322     }
10323     returnAST = def_label_opt_AST;
10324 }
10325 
10326 void AdaParser::null_stmt() {
10327     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10328     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10329     RefAdaAST null_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10330     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
10331     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10332     
10333     try {      // for error handling
10334         s = LT(1);
10335         if ( inputState->guessing == 0 ) {
10336             s_AST = astFactory->create(s);
10337             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10338         }
10339         match(NuLL);
10340         match(SEMI);
10341         if ( inputState->guessing==0 ) {
10342 #line 1088 "ada.g"
10343             Set(s_AST, NULL_STATEMENT);
10344 #line 10345 "AdaParser.cpp"
10345         }
10346         null_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10347     }
10348     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10349         if( inputState->guessing == 0 ) {
10350             reportError(ex);
10351             consume();
10352             consumeUntil(_tokenSet_89);
10353         } else {
10354             throw;
10355         }
10356     }
10357     returnAST = null_stmt_AST;
10358 }
10359 
10360 void AdaParser::exit_stmt() {
10361     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10362     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10363     RefAdaAST exit_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10364     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
10365     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10366     
10367     try {      // for error handling
10368         s = LT(1);
10369         if ( inputState->guessing == 0 ) {
10370             s_AST = astFactory->create(s);
10371             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10372         }
10373         match(EXIT);
10374         {
10375         switch ( LA(1)) {
10376         case IDENTIFIER:
10377         {
10378             label_name();
10379             if (inputState->guessing==0) {
10380                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10381             }
10382             break;
10383         }
10384         case SEMI:
10385         case WHEN:
10386         {
10387             break;
10388         }
10389         default:
10390         {
10391             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10392         }
10393         }
10394         }
10395         {
10396         switch ( LA(1)) {
10397         case WHEN:
10398         {
10399             RefAdaAST tmp282_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10400             if ( inputState->guessing == 0 ) {
10401                 tmp282_AST = astFactory->create(LT(1));
10402                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp282_AST.get()));
10403             }
10404             match(WHEN);
10405             condition();
10406             if (inputState->guessing==0) {
10407                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10408             }
10409             break;
10410         }
10411         case SEMI:
10412         {
10413             break;
10414         }
10415         default:
10416         {
10417             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10418         }
10419         }
10420         }
10421         match(SEMI);
10422         if ( inputState->guessing==0 ) {
10423 #line 1181 "ada.g"
10424             Set(s_AST, EXIT_STATEMENT);
10425 #line 10426 "AdaParser.cpp"
10426         }
10427         exit_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10428     }
10429     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10430         if( inputState->guessing == 0 ) {
10431             reportError(ex);
10432             consume();
10433             consumeUntil(_tokenSet_89);
10434         } else {
10435             throw;
10436         }
10437     }
10438     returnAST = exit_stmt_AST;
10439 }
10440 
10441 void AdaParser::return_stmt() {
10442     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10443     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10444     RefAdaAST return_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10445     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
10446     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10447     
10448     try {      // for error handling
10449         s = LT(1);
10450         if ( inputState->guessing == 0 ) {
10451             s_AST = astFactory->create(s);
10452             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10453         }
10454         match(RETURN);
10455         {
10456         switch ( LA(1)) {
10457         case IDENTIFIER:
10458         case LPAREN:
10459         case NEW:
10460         case CHARACTER_LITERAL:
10461         case CHAR_STRING:
10462         case NuLL:
10463         case NOT:
10464         case PLUS:
10465         case MINUS:
10466         case ABS:
10467         case NUMERIC_LIT:
10468         {
10469             expression();
10470             if (inputState->guessing==0) {
10471                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10472             }
10473             break;
10474         }
10475         case SEMI:
10476         {
10477             break;
10478         }
10479         default:
10480         {
10481             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10482         }
10483         }
10484         }
10485         match(SEMI);
10486         if ( inputState->guessing==0 ) {
10487 #line 1188 "ada.g"
10488             Set(s_AST, RETURN_STATEMENT);
10489 #line 10490 "AdaParser.cpp"
10490         }
10491         return_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10492     }
10493     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10494         if( inputState->guessing == 0 ) {
10495             reportError(ex);
10496             consume();
10497             consumeUntil(_tokenSet_89);
10498         } else {
10499             throw;
10500         }
10501     }
10502     returnAST = return_stmt_AST;
10503 }
10504 
10505 void AdaParser::goto_stmt() {
10506     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10507     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10508     RefAdaAST goto_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10509     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
10510     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10511     
10512     try {      // for error handling
10513         s = LT(1);
10514         if ( inputState->guessing == 0 ) {
10515             s_AST = astFactory->create(s);
10516             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10517         }
10518         match(GOTO);
10519         label_name();
10520         if (inputState->guessing==0) {
10521             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10522         }
10523         match(SEMI);
10524         if ( inputState->guessing==0 ) {
10525 #line 1192 "ada.g"
10526             Set(s_AST, GOTO_STATEMENT);
10527 #line 10528 "AdaParser.cpp"
10528         }
10529         goto_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10530     }
10531     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10532         if( inputState->guessing == 0 ) {
10533             reportError(ex);
10534             consume();
10535             consumeUntil(_tokenSet_89);
10536         } else {
10537             throw;
10538         }
10539     }
10540     returnAST = goto_stmt_AST;
10541 }
10542 
10543 void AdaParser::delay_stmt() {
10544     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10545     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10546     RefAdaAST delay_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10547     ANTLR_USE_NAMESPACE(antlr)RefToken  d = ANTLR_USE_NAMESPACE(antlr)nullToken;
10548     RefAdaAST d_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10549     
10550     try {      // for error handling
10551         d = LT(1);
10552         if ( inputState->guessing == 0 ) {
10553             d_AST = astFactory->create(d);
10554             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get()));
10555         }
10556         match(DELAY);
10557         until_opt();
10558         if (inputState->guessing==0) {
10559             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10560         }
10561         expression();
10562         if (inputState->guessing==0) {
10563             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10564         }
10565         match(SEMI);
10566         if ( inputState->guessing==0 ) {
10567 #line 1257 "ada.g"
10568             Set (d_AST, DELAY_STATEMENT);
10569 #line 10570 "AdaParser.cpp"
10570         }
10571         delay_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10572     }
10573     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10574         if( inputState->guessing == 0 ) {
10575             reportError(ex);
10576             consume();
10577             consumeUntil(_tokenSet_89);
10578         } else {
10579             throw;
10580         }
10581     }
10582     returnAST = delay_stmt_AST;
10583 }
10584 
10585 void AdaParser::abort_stmt() {
10586     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10587     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10588     RefAdaAST abort_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10589     ANTLR_USE_NAMESPACE(antlr)RefToken  a = ANTLR_USE_NAMESPACE(antlr)nullToken;
10590     RefAdaAST a_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10591     
10592     try {      // for error handling
10593         a = LT(1);
10594         if ( inputState->guessing == 0 ) {
10595             a_AST = astFactory->create(a);
10596             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get()));
10597         }
10598         match(ABORT);
10599         name();
10600         if (inputState->guessing==0) {
10601             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10602         }
10603         { // ( ... )*
10604         for (;;) {
10605             if ((LA(1) == COMMA)) {
10606                 match(COMMA);
10607                 name();
10608                 if (inputState->guessing==0) {
10609                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10610                 }
10611             }
10612             else {
10613                 goto _loop420;
10614             }
10615             
10616         }
10617         _loop420:;
10618         } // ( ... )*
10619         match(SEMI);
10620         if ( inputState->guessing==0 ) {
10621 #line 1336 "ada.g"
10622             Set (a_AST, ABORT_STATEMENT);
10623 #line 10624 "AdaParser.cpp"
10624         }
10625         abort_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10626     }
10627     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10628         if( inputState->guessing == 0 ) {
10629             reportError(ex);
10630             consume();
10631             consumeUntil(_tokenSet_89);
10632         } else {
10633             throw;
10634         }
10635     }
10636     returnAST = abort_stmt_AST;
10637 }
10638 
10639 void AdaParser::raise_stmt() {
10640     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10641     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10642     RefAdaAST raise_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10643     ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
10644     RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10645     
10646     try {      // for error handling
10647         r = LT(1);
10648         if ( inputState->guessing == 0 ) {
10649             r_AST = astFactory->create(r);
10650             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
10651         }
10652         match(RAISE);
10653         {
10654         switch ( LA(1)) {
10655         case IDENTIFIER:
10656         {
10657             compound_name();
10658             if (inputState->guessing==0) {
10659                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10660             }
10661             break;
10662         }
10663         case SEMI:
10664         {
10665             break;
10666         }
10667         default:
10668         {
10669             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10670         }
10671         }
10672         }
10673         match(SEMI);
10674         if ( inputState->guessing==0 ) {
10675 #line 1364 "ada.g"
10676             Set (r_AST, RAISE_STATEMENT);
10677 #line 10678 "AdaParser.cpp"
10678         }
10679         raise_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10680     }
10681     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10682         if( inputState->guessing == 0 ) {
10683             reportError(ex);
10684             consume();
10685             consumeUntil(_tokenSet_89);
10686         } else {
10687             throw;
10688         }
10689     }
10690     returnAST = raise_stmt_AST;
10691 }
10692 
10693 void AdaParser::requeue_stmt() {
10694     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10695     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10696     RefAdaAST requeue_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10697     ANTLR_USE_NAMESPACE(antlr)RefToken  r = ANTLR_USE_NAMESPACE(antlr)nullToken;
10698     RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10699     
10700     try {      // for error handling
10701         r = LT(1);
10702         if ( inputState->guessing == 0 ) {
10703             r_AST = astFactory->create(r);
10704             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get()));
10705         }
10706         match(REQUEUE);
10707         name();
10708         if (inputState->guessing==0) {
10709             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10710         }
10711         {
10712         switch ( LA(1)) {
10713         case WITH:
10714         {
10715             match(WITH);
10716             RefAdaAST tmp291_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10717             if ( inputState->guessing == 0 ) {
10718                 tmp291_AST = astFactory->create(LT(1));
10719                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp291_AST.get()));
10720             }
10721             match(ABORT);
10722             break;
10723         }
10724         case SEMI:
10725         {
10726             break;
10727         }
10728         default:
10729         {
10730             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10731         }
10732         }
10733         }
10734         match(SEMI);
10735         if ( inputState->guessing==0 ) {
10736 #line 1368 "ada.g"
10737             Set (r_AST, REQUEUE_STATEMENT);
10738 #line 10739 "AdaParser.cpp"
10739         }
10740         requeue_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10741     }
10742     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10743         if( inputState->guessing == 0 ) {
10744             reportError(ex);
10745             consume();
10746             consumeUntil(_tokenSet_89);
10747         } else {
10748             throw;
10749         }
10750     }
10751     returnAST = requeue_stmt_AST;
10752 }
10753 
10754 void AdaParser::accept_stmt() {
10755     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10756     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10757     RefAdaAST accept_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10758     ANTLR_USE_NAMESPACE(antlr)RefToken  a = ANTLR_USE_NAMESPACE(antlr)nullToken;
10759     RefAdaAST a_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10760     
10761     try {      // for error handling
10762         a = LT(1);
10763         if ( inputState->guessing == 0 ) {
10764             a_AST = astFactory->create(a);
10765             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get()));
10766         }
10767         match(ACCEPT);
10768         def_id(false);
10769         if (inputState->guessing==0) {
10770             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10771         }
10772         entry_index_opt();
10773         if (inputState->guessing==0) {
10774             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10775         }
10776         formal_part_opt();
10777         if (inputState->guessing==0) {
10778             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10779         }
10780         {
10781         switch ( LA(1)) {
10782         case DO:
10783         {
10784             match(DO);
10785             handled_stmt_s();
10786             if (inputState->guessing==0) {
10787                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10788             }
10789             end_id_opt();
10790             match(SEMI);
10791             break;
10792         }
10793         case SEMI:
10794         {
10795             match(SEMI);
10796             if ( inputState->guessing==0 ) {
10797 #line 1239 "ada.g"
10798                 pop_def_id();
10799 #line 10800 "AdaParser.cpp"
10800             }
10801             break;
10802         }
10803         default:
10804         {
10805             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10806         }
10807         }
10808         }
10809         if ( inputState->guessing==0 ) {
10810 #line 1241 "ada.g"
10811             Set (a_AST, ACCEPT_STATEMENT);
10812 #line 10813 "AdaParser.cpp"
10813         }
10814         accept_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10815     }
10816     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10817         if( inputState->guessing == 0 ) {
10818             reportError(ex);
10819             consume();
10820             consumeUntil(_tokenSet_89);
10821         } else {
10822             throw;
10823         }
10824     }
10825     returnAST = accept_stmt_AST;
10826 }
10827 
10828 void AdaParser::select_stmt() {
10829     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10830     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10831     RefAdaAST select_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10832     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
10833     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10834     
10835     try {      // for error handling
10836         s = LT(1);
10837         if ( inputState->guessing == 0 ) {
10838             s_AST = astFactory->create(s);
10839             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10840         }
10841         match(SELECT);
10842         {
10843         bool synPredMatched398 = false;
10844         if (((LA(1) == IDENTIFIER || LA(1) == DELAY) && (_tokenSet_91.member(LA(2))))) {
10845             int _m398 = mark();
10846             synPredMatched398 = true;
10847             inputState->guessing++;
10848             try {
10849                 {
10850                 triggering_alternative();
10851                 match(THEN);
10852                 match(ABORT);
10853                 }
10854             }
10855             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
10856                 synPredMatched398 = false;
10857             }
10858             rewind(_m398);
10859             inputState->guessing--;
10860         }
10861         if ( synPredMatched398 ) {
10862             triggering_alternative();
10863             if (inputState->guessing==0) {
10864                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10865             }
10866             match(THEN);
10867             match(ABORT);
10868             abortable_part();
10869             if (inputState->guessing==0) {
10870                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10871             }
10872             if ( inputState->guessing==0 ) {
10873 #line 1272 "ada.g"
10874                 Set (s_AST, ASYNCHRONOUS_SELECT);
10875 #line 10876 "AdaParser.cpp"
10876             }
10877         }
10878         else if ((_tokenSet_92.member(LA(1))) && (_tokenSet_93.member(LA(2)))) {
10879             selective_accept();
10880             if (inputState->guessing==0) {
10881                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10882             }
10883             if ( inputState->guessing==0 ) {
10884 #line 1274 "ada.g"
10885                 Set (s_AST, SELECTIVE_ACCEPT);
10886 #line 10887 "AdaParser.cpp"
10887             }
10888         }
10889         else if ((LA(1) == IDENTIFIER) && (_tokenSet_94.member(LA(2)))) {
10890             entry_call_alternative();
10891             if (inputState->guessing==0) {
10892                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10893             }
10894             {
10895             switch ( LA(1)) {
10896             case OR:
10897             {
10898                 match(OR);
10899                 delay_alternative();
10900                 if (inputState->guessing==0) {
10901                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10902                 }
10903                 if ( inputState->guessing==0 ) {
10904 #line 1276 "ada.g"
10905                     Set (s_AST, TIMED_ENTRY_CALL);
10906 #line 10907 "AdaParser.cpp"
10907                 }
10908                 break;
10909             }
10910             case ELSE:
10911             {
10912                 match(ELSE);
10913                 statements();
10914                 if (inputState->guessing==0) {
10915                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10916                 }
10917                 if ( inputState->guessing==0 ) {
10918 #line 1277 "ada.g"
10919                     Set (s_AST, CONDITIONAL_ENTRY_CALL);
10920 #line 10921 "AdaParser.cpp"
10921                 }
10922                 break;
10923             }
10924             default:
10925             {
10926                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10927             }
10928             }
10929             }
10930         }
10931         else {
10932             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
10933         }
10934         
10935         }
10936         match(END);
10937         match(SELECT);
10938         match(SEMI);
10939         select_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10940     }
10941     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10942         if( inputState->guessing == 0 ) {
10943             reportError(ex);
10944             consume();
10945             consumeUntil(_tokenSet_89);
10946         } else {
10947             throw;
10948         }
10949     }
10950     returnAST = select_stmt_AST;
10951 }
10952 
10953 void AdaParser::if_stmt() {
10954     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10955     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
10956     RefAdaAST if_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10957     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
10958     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
10959     
10960     try {      // for error handling
10961         s = LT(1);
10962         if ( inputState->guessing == 0 ) {
10963             s_AST = astFactory->create(s);
10964             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
10965         }
10966         match(IF);
10967         cond_clause();
10968         if (inputState->guessing==0) {
10969             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10970         }
10971         elsifs_opt();
10972         if (inputState->guessing==0) {
10973             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10974         }
10975         else_opt();
10976         if (inputState->guessing==0) {
10977             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
10978         }
10979         match(END);
10980         match(IF);
10981         match(SEMI);
10982         if ( inputState->guessing==0 ) {
10983 #line 1094 "ada.g"
10984             Set(s_AST, IF_STATEMENT);
10985 #line 10986 "AdaParser.cpp"
10986         }
10987         if_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
10988     }
10989     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
10990         if( inputState->guessing == 0 ) {
10991             reportError(ex);
10992             consume();
10993             consumeUntil(_tokenSet_89);
10994         } else {
10995             throw;
10996         }
10997     }
10998     returnAST = if_stmt_AST;
10999 }
11000 
11001 void AdaParser::case_stmt() {
11002     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11003     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11004     RefAdaAST case_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11005     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
11006     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11007     
11008     try {      // for error handling
11009         s = LT(1);
11010         if ( inputState->guessing == 0 ) {
11011             s_AST = astFactory->create(s);
11012             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
11013         }
11014         match(CASE);
11015         expression();
11016         if (inputState->guessing==0) {
11017             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11018         }
11019         match(IS);
11020         alternative_s();
11021         if (inputState->guessing==0) {
11022             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11023         }
11024         match(END);
11025         match(CASE);
11026         match(SEMI);
11027         if ( inputState->guessing==0 ) {
11028 #line 1114 "ada.g"
11029             Set(s_AST, CASE_STATEMENT);
11030 #line 11031 "AdaParser.cpp"
11031         }
11032         case_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11033     }
11034     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11035         if( inputState->guessing == 0 ) {
11036             reportError(ex);
11037             consume();
11038             consumeUntil(_tokenSet_89);
11039         } else {
11040             throw;
11041         }
11042     }
11043     returnAST = case_stmt_AST;
11044 }
11045 
11046 void AdaParser::loop_stmt() {
11047     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11048     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11049     RefAdaAST loop_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11050     
11051     try {      // for error handling
11052         iteration_scheme_opt();
11053         if (inputState->guessing==0) {
11054             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11055         }
11056         match(LOOP);
11057         statements();
11058         if (inputState->guessing==0) {
11059             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11060         }
11061         match(END);
11062         match(LOOP);
11063         if ( inputState->guessing==0 ) {
11064             loop_stmt_AST = RefAdaAST(currentAST.root);
11065 #line 1126 "ada.g"
11066             loop_stmt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LOOP_STATEMENT,"LOOP_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(loop_stmt_AST.get()))));
11067 #line 11068 "AdaParser.cpp"
11068             currentAST.root = loop_stmt_AST;
11069             if ( loop_stmt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11070                 loop_stmt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11071                   currentAST.child = loop_stmt_AST->getFirstChild();
11072             else
11073                 currentAST.child = loop_stmt_AST;
11074             currentAST.advanceChildToEnd();
11075         }
11076         loop_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11077     }
11078     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11079         if( inputState->guessing == 0 ) {
11080             reportError(ex);
11081             consume();
11082             consumeUntil(_tokenSet_95);
11083         } else {
11084             throw;
11085         }
11086     }
11087     returnAST = loop_stmt_AST;
11088 }
11089 
11090 void AdaParser::block() {
11091     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11092     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11093     RefAdaAST block_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11094     
11095     try {      // for error handling
11096         declare_opt();
11097         if (inputState->guessing==0) {
11098             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11099         }
11100         block_body();
11101         if (inputState->guessing==0) {
11102             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11103         }
11104         if ( inputState->guessing==0 ) {
11105             block_AST = RefAdaAST(currentAST.root);
11106 #line 1173 "ada.g"
11107             block_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BLOCK_STATEMENT,"BLOCK_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(block_AST.get()))));
11108 #line 11109 "AdaParser.cpp"
11109             currentAST.root = block_AST;
11110             if ( block_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11111                 block_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11112                   currentAST.child = block_AST->getFirstChild();
11113             else
11114                 currentAST.child = block_AST;
11115             currentAST.advanceChildToEnd();
11116         }
11117         block_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11118     }
11119     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11120         if( inputState->guessing == 0 ) {
11121             reportError(ex);
11122             consume();
11123             consumeUntil(_tokenSet_21);
11124         } else {
11125             throw;
11126         }
11127     }
11128     returnAST = block_AST;
11129 }
11130 
11131 void AdaParser::statement_identifier() {
11132     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11133     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11134     RefAdaAST statement_identifier_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11135     ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
11136     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11137     
11138     try {      // for error handling
11139         n = LT(1);
11140         if ( inputState->guessing == 0 ) {
11141             n_AST = astFactory->create(n);
11142         }
11143         match(IDENTIFIER);
11144         match(COLON);
11145         if ( inputState->guessing==0 ) {
11146 #line 1161 "ada.g"
11147             push_def_id(n_AST);
11148 #line 11149 "AdaParser.cpp"
11149         }
11150     }
11151     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11152         if( inputState->guessing == 0 ) {
11153             reportError(ex);
11154             consume();
11155             consumeUntil(_tokenSet_96);
11156         } else {
11157             throw;
11158         }
11159     }
11160     returnAST = statement_identifier_AST;
11161 }
11162 
11163 void AdaParser::id_opt() {
11164     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11165     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11166     RefAdaAST id_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11167     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11168 #line 1141 "ada.g"
11169     RefAdaAST endid;
11170 #line 11171 "AdaParser.cpp"
11171     
11172     try {      // for error handling
11173         switch ( LA(1)) {
11174         case CHAR_STRING:
11175         {
11176             endid=definable_operator_symbol();
11177             if (inputState->guessing==0) {
11178                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11179             }
11180             if (!( end_id_matches_def_id (endid) ))
11181                 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (endid) ");
11182             id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11183             break;
11184         }
11185         case IDENTIFIER:
11186         {
11187             compound_name();
11188             if (inputState->guessing==0) {
11189                 n_AST = returnAST;
11190                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11191             }
11192             if (!( end_id_matches_def_id (n_AST) ))
11193                 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (n_AST) ");
11194             id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11195             break;
11196         }
11197         case SEMI:
11198         {
11199             if ( inputState->guessing==0 ) {
11200 #line 1148 "ada.g"
11201                 pop_def_id();
11202 #line 11203 "AdaParser.cpp"
11203             }
11204             id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11205             break;
11206         }
11207         default:
11208         {
11209             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11210         }
11211         }
11212     }
11213     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11214         if( inputState->guessing == 0 ) {
11215             reportError(ex);
11216             consume();
11217             consumeUntil(_tokenSet_4);
11218         } else {
11219             throw;
11220         }
11221     }
11222     returnAST = id_opt_AST;
11223 }
11224 
11225 void AdaParser::call_or_assignment() {
11226     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11227     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11228     RefAdaAST call_or_assignment_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11229     
11230     try {      // for error handling
11231         name();
11232         if (inputState->guessing==0) {
11233             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11234         }
11235         {
11236         switch ( LA(1)) {
11237         case ASSIGN:
11238         {
11239             match(ASSIGN);
11240             expression();
11241             if (inputState->guessing==0) {
11242                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11243             }
11244             if ( inputState->guessing==0 ) {
11245                 call_or_assignment_AST = RefAdaAST(currentAST.root);
11246 #line 1197 "ada.g"
11247                 call_or_assignment_AST =
11248                             RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ASSIGNMENT_STATEMENT,"ASSIGNMENT_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(call_or_assignment_AST.get()))));
11249 #line 11250 "AdaParser.cpp"
11250                 currentAST.root = call_or_assignment_AST;
11251                 if ( call_or_assignment_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11252                     call_or_assignment_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11253                       currentAST.child = call_or_assignment_AST->getFirstChild();
11254                 else
11255                     currentAST.child = call_or_assignment_AST;
11256                 currentAST.advanceChildToEnd();
11257             }
11258             break;
11259         }
11260         case SEMI:
11261         {
11262             if ( inputState->guessing==0 ) {
11263                 call_or_assignment_AST = RefAdaAST(currentAST.root);
11264 #line 1200 "ada.g"
11265                 call_or_assignment_AST =
11266                             RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CALL_STATEMENT,"CALL_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(call_or_assignment_AST.get()))));
11267 #line 11268 "AdaParser.cpp"
11268                 currentAST.root = call_or_assignment_AST;
11269                 if ( call_or_assignment_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11270                     call_or_assignment_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11271                       currentAST.child = call_or_assignment_AST->getFirstChild();
11272                 else
11273                     currentAST.child = call_or_assignment_AST;
11274                 currentAST.advanceChildToEnd();
11275             }
11276             break;
11277         }
11278         default:
11279         {
11280             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11281         }
11282         }
11283         }
11284         match(SEMI);
11285         call_or_assignment_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11286     }
11287     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11288         if( inputState->guessing == 0 ) {
11289             reportError(ex);
11290             consume();
11291             consumeUntil(_tokenSet_89);
11292         } else {
11293             throw;
11294         }
11295     }
11296     returnAST = call_or_assignment_AST;
11297 }
11298 
11299 void AdaParser::cond_clause() {
11300     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11301     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11302     RefAdaAST cond_clause_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11303     ANTLR_USE_NAMESPACE(antlr)RefToken  c = ANTLR_USE_NAMESPACE(antlr)nullToken;
11304     RefAdaAST c_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11305     
11306     try {      // for error handling
11307         condition();
11308         if (inputState->guessing==0) {
11309             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11310         }
11311         c = LT(1);
11312         if ( inputState->guessing == 0 ) {
11313             c_AST = astFactory->create(c);
11314             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get()));
11315         }
11316         match(THEN);
11317         statements();
11318         if (inputState->guessing==0) {
11319             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11320         }
11321         if ( inputState->guessing==0 ) {
11322 #line 1098 "ada.g"
11323             Set(c_AST, COND_CLAUSE);
11324 #line 11325 "AdaParser.cpp"
11325         }
11326         cond_clause_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11327     }
11328     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11329         if( inputState->guessing == 0 ) {
11330             reportError(ex);
11331             consume();
11332             consumeUntil(_tokenSet_97);
11333         } else {
11334             throw;
11335         }
11336     }
11337     returnAST = cond_clause_AST;
11338 }
11339 
11340 void AdaParser::elsifs_opt() {
11341     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11342     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11343     RefAdaAST elsifs_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11344     
11345     try {      // for error handling
11346         { // ( ... )*
11347         for (;;) {
11348             if ((LA(1) == ELSIF)) {
11349                 match(ELSIF);
11350                 cond_clause();
11351                 if (inputState->guessing==0) {
11352                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11353                 }
11354             }
11355             else {
11356                 goto _loop350;
11357             }
11358             
11359         }
11360         _loop350:;
11361         } // ( ... )*
11362         if ( inputState->guessing==0 ) {
11363             elsifs_opt_AST = RefAdaAST(currentAST.root);
11364 #line 1106 "ada.g"
11365             elsifs_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELSIFS_OPT,"ELSIFS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(elsifs_opt_AST.get()))));
11366 #line 11367 "AdaParser.cpp"
11367             currentAST.root = elsifs_opt_AST;
11368             if ( elsifs_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11369                 elsifs_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11370                   currentAST.child = elsifs_opt_AST->getFirstChild();
11371             else
11372                 currentAST.child = elsifs_opt_AST;
11373             currentAST.advanceChildToEnd();
11374         }
11375         elsifs_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11376     }
11377     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11378         if( inputState->guessing == 0 ) {
11379             reportError(ex);
11380             consume();
11381             consumeUntil(_tokenSet_98);
11382         } else {
11383             throw;
11384         }
11385     }
11386     returnAST = elsifs_opt_AST;
11387 }
11388 
11389 void AdaParser::else_opt() {
11390     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11391     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11392     RefAdaAST else_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11393     
11394     try {      // for error handling
11395         {
11396         switch ( LA(1)) {
11397         case ELSE:
11398         {
11399             match(ELSE);
11400             statements();
11401             if (inputState->guessing==0) {
11402                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11403             }
11404             break;
11405         }
11406         case END:
11407         {
11408             break;
11409         }
11410         default:
11411         {
11412             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11413         }
11414         }
11415         }
11416         if ( inputState->guessing==0 ) {
11417             else_opt_AST = RefAdaAST(currentAST.root);
11418 #line 1110 "ada.g"
11419             else_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELSE_OPT,"ELSE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(else_opt_AST.get()))));
11420 #line 11421 "AdaParser.cpp"
11421             currentAST.root = else_opt_AST;
11422             if ( else_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11423                 else_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11424                   currentAST.child = else_opt_AST->getFirstChild();
11425             else
11426                 currentAST.child = else_opt_AST;
11427             currentAST.advanceChildToEnd();
11428         }
11429         else_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11430     }
11431     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11432         if( inputState->guessing == 0 ) {
11433             reportError(ex);
11434             consume();
11435             consumeUntil(_tokenSet_21);
11436         } else {
11437             throw;
11438         }
11439     }
11440     returnAST = else_opt_AST;
11441 }
11442 
11443 void AdaParser::condition() {
11444     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11445     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11446     RefAdaAST condition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11447     
11448     try {      // for error handling
11449         expression();
11450         if (inputState->guessing==0) {
11451             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11452         }
11453         condition_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11454     }
11455     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11456         if( inputState->guessing == 0 ) {
11457             reportError(ex);
11458             consume();
11459             consumeUntil(_tokenSet_99);
11460         } else {
11461             throw;
11462         }
11463     }
11464     returnAST = condition_AST;
11465 }
11466 
11467 void AdaParser::alternative_s() {
11468     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11469     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11470     RefAdaAST alternative_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11471     
11472     try {      // for error handling
11473         { // ( ... )+
11474         int _cnt356=0;
11475         for (;;) {
11476             if ((LA(1) == WHEN)) {
11477                 case_statement_alternative();
11478                 if (inputState->guessing==0) {
11479                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11480                 }
11481             }
11482             else {
11483                 if ( _cnt356>=1 ) { goto _loop356; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
11484             }
11485             
11486             _cnt356++;
11487         }
11488         _loop356:;
11489         }  // ( ... )+
11490         alternative_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11491     }
11492     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11493         if( inputState->guessing == 0 ) {
11494             reportError(ex);
11495             consume();
11496             consumeUntil(_tokenSet_21);
11497         } else {
11498             throw;
11499         }
11500     }
11501     returnAST = alternative_s_AST;
11502 }
11503 
11504 void AdaParser::case_statement_alternative() {
11505     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11506     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11507     RefAdaAST case_statement_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11508     ANTLR_USE_NAMESPACE(antlr)RefToken  s = ANTLR_USE_NAMESPACE(antlr)nullToken;
11509     RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11510     
11511     try {      // for error handling
11512         s = LT(1);
11513         if ( inputState->guessing == 0 ) {
11514             s_AST = astFactory->create(s);
11515             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()));
11516         }
11517         match(WHEN);
11518         choice_s();
11519         if (inputState->guessing==0) {
11520             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11521         }
11522         match(RIGHT_SHAFT);
11523         statements();
11524         if (inputState->guessing==0) {
11525             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11526         }
11527         if ( inputState->guessing==0 ) {
11528 #line 1121 "ada.g"
11529             Set(s_AST, CASE_STATEMENT_ALTERNATIVE);
11530 #line 11531 "AdaParser.cpp"
11531         }
11532         case_statement_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11533     }
11534     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11535         if( inputState->guessing == 0 ) {
11536             reportError(ex);
11537             consume();
11538             consumeUntil(_tokenSet_72);
11539         } else {
11540             throw;
11541         }
11542     }
11543     returnAST = case_statement_alternative_AST;
11544 }
11545 
11546 void AdaParser::iteration_scheme_opt() {
11547     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11548     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11549     RefAdaAST iteration_scheme_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11550     
11551     try {      // for error handling
11552         {
11553         switch ( LA(1)) {
11554         case WHILE:
11555         {
11556             RefAdaAST tmp319_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11557             if ( inputState->guessing == 0 ) {
11558                 tmp319_AST = astFactory->create(LT(1));
11559                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp319_AST.get()));
11560             }
11561             match(WHILE);
11562             condition();
11563             if (inputState->guessing==0) {
11564                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11565             }
11566             break;
11567         }
11568         case FOR:
11569         {
11570             RefAdaAST tmp320_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11571             if ( inputState->guessing == 0 ) {
11572                 tmp320_AST = astFactory->create(LT(1));
11573                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp320_AST.get()));
11574             }
11575             match(FOR);
11576             RefAdaAST tmp321_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11577             if ( inputState->guessing == 0 ) {
11578                 tmp321_AST = astFactory->create(LT(1));
11579                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp321_AST.get()));
11580             }
11581             match(IDENTIFIER);
11582             match(IN);
11583             reverse_opt();
11584             if (inputState->guessing==0) {
11585                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11586             }
11587             discrete_subtype_definition();
11588             if (inputState->guessing==0) {
11589                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11590             }
11591             break;
11592         }
11593         case LOOP:
11594         {
11595             break;
11596         }
11597         default:
11598         {
11599             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11600         }
11601         }
11602         }
11603         if ( inputState->guessing==0 ) {
11604             iteration_scheme_opt_AST = RefAdaAST(currentAST.root);
11605 #line 1132 "ada.g"
11606             iteration_scheme_opt_AST =
11607                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ITERATION_SCHEME_OPT,"ITERATION_SCHEME_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(iteration_scheme_opt_AST.get()))));
11608 #line 11609 "AdaParser.cpp"
11609             currentAST.root = iteration_scheme_opt_AST;
11610             if ( iteration_scheme_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11611                 iteration_scheme_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11612                   currentAST.child = iteration_scheme_opt_AST->getFirstChild();
11613             else
11614                 currentAST.child = iteration_scheme_opt_AST;
11615             currentAST.advanceChildToEnd();
11616         }
11617         iteration_scheme_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11618     }
11619     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11620         if( inputState->guessing == 0 ) {
11621             reportError(ex);
11622             consume();
11623             consumeUntil(_tokenSet_100);
11624         } else {
11625             throw;
11626         }
11627     }
11628     returnAST = iteration_scheme_opt_AST;
11629 }
11630 
11631 void AdaParser::reverse_opt() {
11632     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11633     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11634     RefAdaAST reverse_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11635     
11636     try {      // for error handling
11637         {
11638         switch ( LA(1)) {
11639         case REVERSE:
11640         {
11641             RefAdaAST tmp323_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11642             if ( inputState->guessing == 0 ) {
11643                 tmp323_AST = astFactory->create(LT(1));
11644                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp323_AST.get()));
11645             }
11646             match(REVERSE);
11647             break;
11648         }
11649         case IDENTIFIER:
11650         case LPAREN:
11651         case NEW:
11652         case CHARACTER_LITERAL:
11653         case CHAR_STRING:
11654         case NuLL:
11655         case NOT:
11656         case PLUS:
11657         case MINUS:
11658         case ABS:
11659         case NUMERIC_LIT:
11660         {
11661             break;
11662         }
11663         default:
11664         {
11665             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11666         }
11667         }
11668         }
11669         if ( inputState->guessing==0 ) {
11670             reverse_opt_AST = RefAdaAST(currentAST.root);
11671 #line 1138 "ada.g"
11672             reverse_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(reverse_opt_AST.get()))));
11673 #line 11674 "AdaParser.cpp"
11674             currentAST.root = reverse_opt_AST;
11675             if ( reverse_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11676                 reverse_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11677                   currentAST.child = reverse_opt_AST->getFirstChild();
11678             else
11679                 currentAST.child = reverse_opt_AST;
11680             currentAST.advanceChildToEnd();
11681         }
11682         reverse_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11683     }
11684     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11685         if( inputState->guessing == 0 ) {
11686             reportError(ex);
11687             consume();
11688             consumeUntil(_tokenSet_5);
11689         } else {
11690             throw;
11691         }
11692     }
11693     returnAST = reverse_opt_AST;
11694 }
11695 
11696 void AdaParser::declare_opt() {
11697     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11698     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11699     RefAdaAST declare_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11700     
11701     try {      // for error handling
11702         {
11703         switch ( LA(1)) {
11704         case DECLARE:
11705         {
11706             match(DECLARE);
11707             declarative_part();
11708             if (inputState->guessing==0) {
11709                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11710             }
11711             break;
11712         }
11713         case BEGIN:
11714         {
11715             break;
11716         }
11717         default:
11718         {
11719             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11720         }
11721         }
11722         }
11723         if ( inputState->guessing==0 ) {
11724             declare_opt_AST = RefAdaAST(currentAST.root);
11725 #line 1177 "ada.g"
11726             declare_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DECLARE_OPT,"DECLARE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(declare_opt_AST.get()))));
11727 #line 11728 "AdaParser.cpp"
11728             currentAST.root = declare_opt_AST;
11729             if ( declare_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11730                 declare_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11731                   currentAST.child = declare_opt_AST->getFirstChild();
11732             else
11733                 currentAST.child = declare_opt_AST;
11734             currentAST.advanceChildToEnd();
11735         }
11736         declare_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11737     }
11738     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11739         if( inputState->guessing == 0 ) {
11740             reportError(ex);
11741             consume();
11742             consumeUntil(_tokenSet_101);
11743         } else {
11744             throw;
11745         }
11746     }
11747     returnAST = declare_opt_AST;
11748 }
11749 
11750 void AdaParser::label_name() {
11751     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11752     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11753     RefAdaAST label_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11754     
11755     try {      // for error handling
11756         RefAdaAST tmp325_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11757         if ( inputState->guessing == 0 ) {
11758             tmp325_AST = astFactory->create(LT(1));
11759             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp325_AST.get()));
11760         }
11761         match(IDENTIFIER);
11762         label_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11763     }
11764     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11765         if( inputState->guessing == 0 ) {
11766             reportError(ex);
11767             consume();
11768             consumeUntil(_tokenSet_102);
11769         } else {
11770             throw;
11771         }
11772     }
11773     returnAST = label_name_AST;
11774 }
11775 
11776 void AdaParser::entry_body_formal_part() {
11777     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11778     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11779     RefAdaAST entry_body_formal_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11780     
11781     try {      // for error handling
11782         entry_index_spec_opt();
11783         if (inputState->guessing==0) {
11784             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11785         }
11786         formal_part_opt();
11787         if (inputState->guessing==0) {
11788             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11789         }
11790         entry_body_formal_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11791     }
11792     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11793         if( inputState->guessing == 0 ) {
11794             reportError(ex);
11795             consume();
11796             consumeUntil(_tokenSet_103);
11797         } else {
11798             throw;
11799         }
11800     }
11801     returnAST = entry_body_formal_part_AST;
11802 }
11803 
11804 void AdaParser::entry_barrier() {
11805     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11806     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11807     RefAdaAST entry_barrier_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11808     
11809     try {      // for error handling
11810         match(WHEN);
11811         condition();
11812         if (inputState->guessing==0) {
11813             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11814         }
11815         entry_barrier_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11816     }
11817     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11818         if( inputState->guessing == 0 ) {
11819             reportError(ex);
11820             consume();
11821             consumeUntil(_tokenSet_75);
11822         } else {
11823             throw;
11824         }
11825     }
11826     returnAST = entry_barrier_AST;
11827 }
11828 
11829 void AdaParser::entry_index_spec_opt() {
11830     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11831     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11832     RefAdaAST entry_index_spec_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11833     
11834     try {      // for error handling
11835         {
11836         bool synPredMatched383 = false;
11837         if (((LA(1) == LPAREN) && (LA(2) == FOR))) {
11838             int _m383 = mark();
11839             synPredMatched383 = true;
11840             inputState->guessing++;
11841             try {
11842                 {
11843                 match(LPAREN);
11844                 match(FOR);
11845                 }
11846             }
11847             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
11848                 synPredMatched383 = false;
11849             }
11850             rewind(_m383);
11851             inputState->guessing--;
11852         }
11853         if ( synPredMatched383 ) {
11854             match(LPAREN);
11855             match(FOR);
11856             def_id(false);
11857             if (inputState->guessing==0) {
11858                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11859             }
11860             match(IN);
11861             discrete_subtype_definition();
11862             if (inputState->guessing==0) {
11863                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11864             }
11865             match(RPAREN);
11866         }
11867         else if ((LA(1) == LPAREN || LA(1) == WHEN) && (_tokenSet_5.member(LA(2)))) {
11868         }
11869         else {
11870             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11871         }
11872         
11873         }
11874         if ( inputState->guessing==0 ) {
11875             entry_index_spec_opt_AST = RefAdaAST(currentAST.root);
11876 #line 1222 "ada.g"
11877             entry_index_spec_opt_AST =
11878                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_INDEX_SPECIFICATION,"ENTRY_INDEX_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_index_spec_opt_AST.get()))));
11879 #line 11880 "AdaParser.cpp"
11880             currentAST.root = entry_index_spec_opt_AST;
11881             if ( entry_index_spec_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11882                 entry_index_spec_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11883                   currentAST.child = entry_index_spec_opt_AST->getFirstChild();
11884             else
11885                 currentAST.child = entry_index_spec_opt_AST;
11886             currentAST.advanceChildToEnd();
11887         }
11888         entry_index_spec_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11889     }
11890     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11891         if( inputState->guessing == 0 ) {
11892             reportError(ex);
11893             consume();
11894             consumeUntil(_tokenSet_104);
11895         } else {
11896             throw;
11897         }
11898     }
11899     returnAST = entry_index_spec_opt_AST;
11900 }
11901 
11902 void AdaParser::entry_call_stmt() {
11903     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11904     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11905     RefAdaAST entry_call_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11906     
11907     try {      // for error handling
11908         name();
11909         if (inputState->guessing==0) {
11910             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11911         }
11912         match(SEMI);
11913         if ( inputState->guessing==0 ) {
11914             entry_call_stmt_AST = RefAdaAST(currentAST.root);
11915 #line 1232 "ada.g"
11916             entry_call_stmt_AST =
11917                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_CALL_STATEMENT,"ENTRY_CALL_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_call_stmt_AST.get()))));
11918 #line 11919 "AdaParser.cpp"
11919             currentAST.root = entry_call_stmt_AST;
11920             if ( entry_call_stmt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11921                 entry_call_stmt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11922                   currentAST.child = entry_call_stmt_AST->getFirstChild();
11923             else
11924                 currentAST.child = entry_call_stmt_AST;
11925             currentAST.advanceChildToEnd();
11926         }
11927         entry_call_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11928     }
11929     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11930         if( inputState->guessing == 0 ) {
11931             reportError(ex);
11932             consume();
11933             consumeUntil(_tokenSet_105);
11934         } else {
11935             throw;
11936         }
11937     }
11938     returnAST = entry_call_stmt_AST;
11939 }
11940 
11941 void AdaParser::entry_index_opt() {
11942     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11943     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
11944     RefAdaAST entry_index_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
11945     
11946     try {      // for error handling
11947         {
11948         bool synPredMatched391 = false;
11949         if (((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2))))) {
11950             int _m391 = mark();
11951             synPredMatched391 = true;
11952             inputState->guessing++;
11953             try {
11954                 {
11955                 match(LPAREN);
11956                 expression();
11957                 match(RPAREN);
11958                 }
11959             }
11960             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
11961                 synPredMatched391 = false;
11962             }
11963             rewind(_m391);
11964             inputState->guessing--;
11965         }
11966         if ( synPredMatched391 ) {
11967             match(LPAREN);
11968             expression();
11969             if (inputState->guessing==0) {
11970                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
11971             }
11972             match(RPAREN);
11973         }
11974         else if ((LA(1) == SEMI || LA(1) == LPAREN || LA(1) == DO) && (_tokenSet_89.member(LA(2)))) {
11975         }
11976         else {
11977             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
11978         }
11979         
11980         }
11981         if ( inputState->guessing==0 ) {
11982             entry_index_opt_AST = RefAdaAST(currentAST.root);
11983 #line 1251 "ada.g"
11984             entry_index_opt_AST =
11985                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_INDEX_OPT,"ENTRY_INDEX_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_index_opt_AST.get()))));
11986 #line 11987 "AdaParser.cpp"
11987             currentAST.root = entry_index_opt_AST;
11988             if ( entry_index_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
11989                 entry_index_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
11990                   currentAST.child = entry_index_opt_AST->getFirstChild();
11991             else
11992                 currentAST.child = entry_index_opt_AST;
11993             currentAST.advanceChildToEnd();
11994         }
11995         entry_index_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
11996     }
11997     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
11998         if( inputState->guessing == 0 ) {
11999             reportError(ex);
12000             consume();
12001             consumeUntil(_tokenSet_106);
12002         } else {
12003             throw;
12004         }
12005     }
12006     returnAST = entry_index_opt_AST;
12007 }
12008 
12009 void AdaParser::until_opt() {
12010     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12011     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12012     RefAdaAST until_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12013     
12014     try {      // for error handling
12015         {
12016         switch ( LA(1)) {
12017         case UNTIL:
12018         {
12019             RefAdaAST tmp334_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12020             if ( inputState->guessing == 0 ) {
12021                 tmp334_AST = astFactory->create(LT(1));
12022                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp334_AST.get()));
12023             }
12024             match(UNTIL);
12025             break;
12026         }
12027         case IDENTIFIER:
12028         case LPAREN:
12029         case NEW:
12030         case CHARACTER_LITERAL:
12031         case CHAR_STRING:
12032         case NuLL:
12033         case NOT:
12034         case PLUS:
12035         case MINUS:
12036         case ABS:
12037         case NUMERIC_LIT:
12038         {
12039             break;
12040         }
12041         default:
12042         {
12043             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12044         }
12045         }
12046         }
12047         if ( inputState->guessing==0 ) {
12048             until_opt_AST = RefAdaAST(currentAST.root);
12049 #line 1261 "ada.g"
12050             until_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(until_opt_AST.get()))));
12051 #line 12052 "AdaParser.cpp"
12052             currentAST.root = until_opt_AST;
12053             if ( until_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12054                 until_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12055                   currentAST.child = until_opt_AST->getFirstChild();
12056             else
12057                 currentAST.child = until_opt_AST;
12058             currentAST.advanceChildToEnd();
12059         }
12060         until_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12061     }
12062     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12063         if( inputState->guessing == 0 ) {
12064             reportError(ex);
12065             consume();
12066             consumeUntil(_tokenSet_5);
12067         } else {
12068             throw;
12069         }
12070     }
12071     returnAST = until_opt_AST;
12072 }
12073 
12074 void AdaParser::triggering_alternative() {
12075     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12076     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12077     RefAdaAST triggering_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12078     
12079     try {      // for error handling
12080         {
12081         switch ( LA(1)) {
12082         case DELAY:
12083         {
12084             delay_stmt();
12085             if (inputState->guessing==0) {
12086                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12087             }
12088             break;
12089         }
12090         case IDENTIFIER:
12091         {
12092             entry_call_stmt();
12093             if (inputState->guessing==0) {
12094                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12095             }
12096             break;
12097         }
12098         default:
12099         {
12100             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12101         }
12102         }
12103         }
12104         stmts_opt();
12105         if (inputState->guessing==0) {
12106             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12107         }
12108         if ( inputState->guessing==0 ) {
12109             triggering_alternative_AST = RefAdaAST(currentAST.root);
12110 #line 1285 "ada.g"
12111             triggering_alternative_AST =
12112                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TRIGGERING_ALTERNATIVE,"TRIGGERING_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(triggering_alternative_AST.get()))));
12113 #line 12114 "AdaParser.cpp"
12114             currentAST.root = triggering_alternative_AST;
12115             if ( triggering_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12116                 triggering_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12117                   currentAST.child = triggering_alternative_AST->getFirstChild();
12118             else
12119                 currentAST.child = triggering_alternative_AST;
12120             currentAST.advanceChildToEnd();
12121         }
12122         triggering_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12123     }
12124     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12125         if( inputState->guessing == 0 ) {
12126             reportError(ex);
12127             consume();
12128             consumeUntil(_tokenSet_107);
12129         } else {
12130             throw;
12131         }
12132     }
12133     returnAST = triggering_alternative_AST;
12134 }
12135 
12136 void AdaParser::abortable_part() {
12137     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12138     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12139     RefAdaAST abortable_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12140     
12141     try {      // for error handling
12142         stmts_opt();
12143         if (inputState->guessing==0) {
12144             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12145         }
12146         if ( inputState->guessing==0 ) {
12147             abortable_part_AST = RefAdaAST(currentAST.root);
12148 #line 1291 "ada.g"
12149             abortable_part_AST =
12150                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ABORTABLE_PART,"ABORTABLE_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abortable_part_AST.get()))));
12151 #line 12152 "AdaParser.cpp"
12152             currentAST.root = abortable_part_AST;
12153             if ( abortable_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12154                 abortable_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12155                   currentAST.child = abortable_part_AST->getFirstChild();
12156             else
12157                 currentAST.child = abortable_part_AST;
12158             currentAST.advanceChildToEnd();
12159         }
12160         abortable_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12161     }
12162     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12163         if( inputState->guessing == 0 ) {
12164             reportError(ex);
12165             consume();
12166             consumeUntil(_tokenSet_21);
12167         } else {
12168             throw;
12169         }
12170     }
12171     returnAST = abortable_part_AST;
12172 }
12173 
12174 void AdaParser::selective_accept() {
12175     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12176     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12177     RefAdaAST selective_accept_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12178     
12179     try {      // for error handling
12180         guard_opt();
12181         if (inputState->guessing==0) {
12182             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12183         }
12184         select_alternative();
12185         if (inputState->guessing==0) {
12186             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12187         }
12188         or_select_opt();
12189         if (inputState->guessing==0) {
12190             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12191         }
12192         else_opt();
12193         if (inputState->guessing==0) {
12194             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12195         }
12196         selective_accept_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12197     }
12198     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12199         if( inputState->guessing == 0 ) {
12200             reportError(ex);
12201             consume();
12202             consumeUntil(_tokenSet_21);
12203         } else {
12204             throw;
12205         }
12206     }
12207     returnAST = selective_accept_AST;
12208 }
12209 
12210 void AdaParser::entry_call_alternative() {
12211     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12212     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12213     RefAdaAST entry_call_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12214     
12215     try {      // for error handling
12216         entry_call_stmt();
12217         if (inputState->guessing==0) {
12218             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12219         }
12220         stmts_opt();
12221         if (inputState->guessing==0) {
12222             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12223         }
12224         if ( inputState->guessing==0 ) {
12225             entry_call_alternative_AST = RefAdaAST(currentAST.root);
12226 #line 1297 "ada.g"
12227             entry_call_alternative_AST =
12228                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_CALL_ALTERNATIVE,"ENTRY_CALL_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_call_alternative_AST.get()))));
12229 #line 12230 "AdaParser.cpp"
12230             currentAST.root = entry_call_alternative_AST;
12231             if ( entry_call_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12232                 entry_call_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12233                   currentAST.child = entry_call_alternative_AST->getFirstChild();
12234             else
12235                 currentAST.child = entry_call_alternative_AST;
12236             currentAST.advanceChildToEnd();
12237         }
12238         entry_call_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12239     }
12240     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12241         if( inputState->guessing == 0 ) {
12242             reportError(ex);
12243             consume();
12244             consumeUntil(_tokenSet_108);
12245         } else {
12246             throw;
12247         }
12248     }
12249     returnAST = entry_call_alternative_AST;
12250 }
12251 
12252 void AdaParser::delay_alternative() {
12253     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12254     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12255     RefAdaAST delay_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12256     
12257     try {      // for error handling
12258         delay_stmt();
12259         if (inputState->guessing==0) {
12260             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12261         }
12262         stmts_opt();
12263         if (inputState->guessing==0) {
12264             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12265         }
12266         if ( inputState->guessing==0 ) {
12267             delay_alternative_AST = RefAdaAST(currentAST.root);
12268 #line 1322 "ada.g"
12269             delay_alternative_AST =
12270                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DELAY_ALTERNATIVE,"DELAY_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(delay_alternative_AST.get()))));
12271 #line 12272 "AdaParser.cpp"
12272             currentAST.root = delay_alternative_AST;
12273             if ( delay_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12274                 delay_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12275                   currentAST.child = delay_alternative_AST->getFirstChild();
12276             else
12277                 currentAST.child = delay_alternative_AST;
12278             currentAST.advanceChildToEnd();
12279         }
12280         delay_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12281     }
12282     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12283         if( inputState->guessing == 0 ) {
12284             reportError(ex);
12285             consume();
12286             consumeUntil(_tokenSet_109);
12287         } else {
12288             throw;
12289         }
12290     }
12291     returnAST = delay_alternative_AST;
12292 }
12293 
12294 void AdaParser::stmts_opt() {
12295     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12296     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12297     RefAdaAST stmts_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12298     
12299     try {      // for error handling
12300         { // ( ... )*
12301         for (;;) {
12302             switch ( LA(1)) {
12303             case PRAGMA:
12304             {
12305                 pragma();
12306                 if (inputState->guessing==0) {
12307                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12308                 }
12309                 break;
12310             }
12311             case IDENTIFIER:
12312             case NuLL:
12313             case RETURN:
12314             case FOR:
12315             case CASE:
12316             case BEGIN:
12317             case LT_LT:
12318             case IF:
12319             case LOOP:
12320             case WHILE:
12321             case DECLARE:
12322             case EXIT:
12323             case GOTO:
12324             case ACCEPT:
12325             case DELAY:
12326             case SELECT:
12327             case ABORT:
12328             case RAISE:
12329             case REQUEUE:
12330             {
12331                 statement();
12332                 if (inputState->guessing==0) {
12333                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12334                 }
12335                 break;
12336             }
12337             default:
12338             {
12339                 goto _loop414;
12340             }
12341             }
12342         }
12343         _loop414:;
12344         } // ( ... )*
12345         stmts_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12346     }
12347     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12348         if( inputState->guessing == 0 ) {
12349             reportError(ex);
12350             consume();
12351             consumeUntil(_tokenSet_110);
12352         } else {
12353             throw;
12354         }
12355     }
12356     returnAST = stmts_opt_AST;
12357 }
12358 
12359 void AdaParser::guard_opt() {
12360     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12361     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12362     RefAdaAST guard_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12363     
12364     try {      // for error handling
12365         {
12366         switch ( LA(1)) {
12367         case WHEN:
12368         {
12369             match(WHEN);
12370             condition();
12371             if (inputState->guessing==0) {
12372                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12373             }
12374             match(RIGHT_SHAFT);
12375             { // ( ... )*
12376             for (;;) {
12377                 if ((LA(1) == PRAGMA)) {
12378                     pragma();
12379                     if (inputState->guessing==0) {
12380                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12381                     }
12382                 }
12383                 else {
12384                     goto _loop408;
12385                 }
12386                 
12387             }
12388             _loop408:;
12389             } // ( ... )*
12390             break;
12391         }
12392         case ACCEPT:
12393         case DELAY:
12394         case TERMINATE:
12395         {
12396             break;
12397         }
12398         default:
12399         {
12400             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12401         }
12402         }
12403         }
12404         if ( inputState->guessing==0 ) {
12405             guard_opt_AST = RefAdaAST(currentAST.root);
12406 #line 1306 "ada.g"
12407             guard_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(GUARD_OPT,"GUARD_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(guard_opt_AST.get()))));
12408 #line 12409 "AdaParser.cpp"
12409             currentAST.root = guard_opt_AST;
12410             if ( guard_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12411                 guard_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12412                   currentAST.child = guard_opt_AST->getFirstChild();
12413             else
12414                 currentAST.child = guard_opt_AST;
12415             currentAST.advanceChildToEnd();
12416         }
12417         guard_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12418     }
12419     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12420         if( inputState->guessing == 0 ) {
12421             reportError(ex);
12422             consume();
12423             consumeUntil(_tokenSet_111);
12424         } else {
12425             throw;
12426         }
12427     }
12428     returnAST = guard_opt_AST;
12429 }
12430 
12431 void AdaParser::select_alternative() {
12432     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12433     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12434     RefAdaAST select_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12435     ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
12436     RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12437     
12438     try {      // for error handling
12439         switch ( LA(1)) {
12440         case ACCEPT:
12441         {
12442             accept_alternative();
12443             if (inputState->guessing==0) {
12444                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12445             }
12446             select_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12447             break;
12448         }
12449         case DELAY:
12450         {
12451             delay_alternative();
12452             if (inputState->guessing==0) {
12453                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12454             }
12455             select_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12456             break;
12457         }
12458         case TERMINATE:
12459         {
12460             t = LT(1);
12461             if ( inputState->guessing == 0 ) {
12462                 t_AST = astFactory->create(t);
12463                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
12464             }
12465             match(TERMINATE);
12466             match(SEMI);
12467             if ( inputState->guessing==0 ) {
12468 #line 1312 "ada.g"
12469                 Set(t_AST, TERMINATE_ALTERNATIVE);
12470 #line 12471 "AdaParser.cpp"
12471             }
12472             select_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12473             break;
12474         }
12475         default:
12476         {
12477             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12478         }
12479         }
12480     }
12481     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12482         if( inputState->guessing == 0 ) {
12483             reportError(ex);
12484             consume();
12485             consumeUntil(_tokenSet_109);
12486         } else {
12487             throw;
12488         }
12489     }
12490     returnAST = select_alternative_AST;
12491 }
12492 
12493 void AdaParser::or_select_opt() {
12494     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12495     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12496     RefAdaAST or_select_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12497     
12498     try {      // for error handling
12499         { // ( ... )*
12500         for (;;) {
12501             if ((LA(1) == OR)) {
12502                 match(OR);
12503                 guard_opt();
12504                 if (inputState->guessing==0) {
12505                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12506                 }
12507                 select_alternative();
12508                 if (inputState->guessing==0) {
12509                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12510                 }
12511             }
12512             else {
12513                 goto _loop417;
12514             }
12515             
12516         }
12517         _loop417:;
12518         } // ( ... )*
12519         if ( inputState->guessing==0 ) {
12520             or_select_opt_AST = RefAdaAST(currentAST.root);
12521 #line 1331 "ada.g"
12522             or_select_opt_AST =
12523                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(OR_SELECT_OPT,"OR_SELECT_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(or_select_opt_AST.get()))));
12524 #line 12525 "AdaParser.cpp"
12525             currentAST.root = or_select_opt_AST;
12526             if ( or_select_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12527                 or_select_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12528                   currentAST.child = or_select_opt_AST->getFirstChild();
12529             else
12530                 currentAST.child = or_select_opt_AST;
12531             currentAST.advanceChildToEnd();
12532         }
12533         or_select_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12534     }
12535     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12536         if( inputState->guessing == 0 ) {
12537             reportError(ex);
12538             consume();
12539             consumeUntil(_tokenSet_98);
12540         } else {
12541             throw;
12542         }
12543     }
12544     returnAST = or_select_opt_AST;
12545 }
12546 
12547 void AdaParser::accept_alternative() {
12548     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12549     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12550     RefAdaAST accept_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12551     
12552     try {      // for error handling
12553         accept_stmt();
12554         if (inputState->guessing==0) {
12555             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12556         }
12557         stmts_opt();
12558         if (inputState->guessing==0) {
12559             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12560         }
12561         if ( inputState->guessing==0 ) {
12562             accept_alternative_AST = RefAdaAST(currentAST.root);
12563 #line 1316 "ada.g"
12564             accept_alternative_AST =
12565                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ACCEPT_ALTERNATIVE,"ACCEPT_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(accept_alternative_AST.get()))));
12566 #line 12567 "AdaParser.cpp"
12567             currentAST.root = accept_alternative_AST;
12568             if ( accept_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12569                 accept_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12570                   currentAST.child = accept_alternative_AST->getFirstChild();
12571             else
12572                 currentAST.child = accept_alternative_AST;
12573             currentAST.advanceChildToEnd();
12574         }
12575         accept_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12576     }
12577     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12578         if( inputState->guessing == 0 ) {
12579             reportError(ex);
12580             consume();
12581             consumeUntil(_tokenSet_109);
12582         } else {
12583             throw;
12584         }
12585     }
12586     returnAST = accept_alternative_AST;
12587 }
12588 
12589 void AdaParser::exception_handler() {
12590     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12591     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12592     RefAdaAST exception_handler_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12593     ANTLR_USE_NAMESPACE(antlr)RefToken  w = ANTLR_USE_NAMESPACE(antlr)nullToken;
12594     RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12595     
12596     try {      // for error handling
12597         w = LT(1);
12598         if ( inputState->guessing == 0 ) {
12599             w_AST = astFactory->create(w);
12600             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get()));
12601         }
12602         match(WHEN);
12603         identifier_colon_opt();
12604         if (inputState->guessing==0) {
12605             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12606         }
12607         except_choice_s();
12608         if (inputState->guessing==0) {
12609             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12610         }
12611         match(RIGHT_SHAFT);
12612         statements();
12613         if (inputState->guessing==0) {
12614             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12615         }
12616         if ( inputState->guessing==0 ) {
12617 #line 1347 "ada.g"
12618             Set (w_AST, EXCEPTION_HANDLER);
12619 #line 12620 "AdaParser.cpp"
12620         }
12621         exception_handler_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12622     }
12623     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12624         if( inputState->guessing == 0 ) {
12625             reportError(ex);
12626             consume();
12627             consumeUntil(_tokenSet_72);
12628         } else {
12629             throw;
12630         }
12631     }
12632     returnAST = exception_handler_AST;
12633 }
12634 
12635 void AdaParser::identifier_colon_opt() {
12636     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12637     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12638     RefAdaAST identifier_colon_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12639     
12640     try {      // for error handling
12641         {
12642         if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) {
12643             RefAdaAST tmp340_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12644             if ( inputState->guessing == 0 ) {
12645                 tmp340_AST = astFactory->create(LT(1));
12646                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp340_AST.get()));
12647             }
12648             match(IDENTIFIER);
12649             match(COLON);
12650         }
12651         else if ((LA(1) == IDENTIFIER || LA(1) == OTHERS) && (LA(2) == RIGHT_SHAFT || LA(2) == DOT || LA(2) == PIPE)) {
12652         }
12653         else {
12654             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12655         }
12656         
12657         }
12658         if ( inputState->guessing==0 ) {
12659             identifier_colon_opt_AST = RefAdaAST(currentAST.root);
12660 #line 1351 "ada.g"
12661             identifier_colon_opt_AST =
12662                     RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(IDENTIFIER_COLON_OPT,"IDENTIFIER_COLON_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(identifier_colon_opt_AST.get()))));
12663 #line 12664 "AdaParser.cpp"
12664             currentAST.root = identifier_colon_opt_AST;
12665             if ( identifier_colon_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
12666                 identifier_colon_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
12667                   currentAST.child = identifier_colon_opt_AST->getFirstChild();
12668             else
12669                 currentAST.child = identifier_colon_opt_AST;
12670             currentAST.advanceChildToEnd();
12671         }
12672         identifier_colon_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12673     }
12674     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12675         if( inputState->guessing == 0 ) {
12676             reportError(ex);
12677             consume();
12678             consumeUntil(_tokenSet_112);
12679         } else {
12680             throw;
12681         }
12682     }
12683     returnAST = identifier_colon_opt_AST;
12684 }
12685 
12686 void AdaParser::except_choice_s() {
12687     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12688     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12689     RefAdaAST except_choice_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12690     
12691     try {      // for error handling
12692         exception_choice();
12693         if (inputState->guessing==0) {
12694             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12695         }
12696         { // ( ... )*
12697         for (;;) {
12698             if ((LA(1) == PIPE)) {
12699                 RefAdaAST tmp342_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12700                 if ( inputState->guessing == 0 ) {
12701                     tmp342_AST = astFactory->create(LT(1));
12702                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp342_AST.get()));
12703                 }
12704                 match(PIPE);
12705                 exception_choice();
12706                 if (inputState->guessing==0) {
12707                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12708                 }
12709             }
12710             else {
12711                 goto _loop430;
12712             }
12713             
12714         }
12715         _loop430:;
12716         } // ( ... )*
12717         except_choice_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12718     }
12719     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12720         if( inputState->guessing == 0 ) {
12721             reportError(ex);
12722             consume();
12723             consumeUntil(_tokenSet_76);
12724         } else {
12725             throw;
12726         }
12727     }
12728     returnAST = except_choice_s_AST;
12729 }
12730 
12731 void AdaParser::exception_choice() {
12732     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12733     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12734     RefAdaAST exception_choice_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12735     
12736     try {      // for error handling
12737         switch ( LA(1)) {
12738         case IDENTIFIER:
12739         {
12740             compound_name();
12741             if (inputState->guessing==0) {
12742                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12743             }
12744             exception_choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12745             break;
12746         }
12747         case OTHERS:
12748         {
12749             RefAdaAST tmp343_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12750             if ( inputState->guessing == 0 ) {
12751                 tmp343_AST = astFactory->create(LT(1));
12752                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp343_AST.get()));
12753             }
12754             match(OTHERS);
12755             exception_choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12756             break;
12757         }
12758         default:
12759         {
12760             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12761         }
12762         }
12763     }
12764     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12765         if( inputState->guessing == 0 ) {
12766             reportError(ex);
12767             consume();
12768             consumeUntil(_tokenSet_68);
12769         } else {
12770             throw;
12771         }
12772     }
12773     returnAST = exception_choice_AST;
12774 }
12775 
12776 void AdaParser::operator_call() {
12777     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12778     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12779     RefAdaAST operator_call_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12780     ANTLR_USE_NAMESPACE(antlr)RefToken  cs = ANTLR_USE_NAMESPACE(antlr)nullToken;
12781     RefAdaAST cs_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12782     
12783     try {      // for error handling
12784         cs = LT(1);
12785         if ( inputState->guessing == 0 ) {
12786             cs_AST = astFactory->create(cs);
12787             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cs_AST.get()));
12788         }
12789         match(CHAR_STRING);
12790         operator_call_tail(cs_AST);
12791         if (inputState->guessing==0) {
12792             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12793         }
12794         operator_call_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12795     }
12796     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12797         if( inputState->guessing == 0 ) {
12798             reportError(ex);
12799             consume();
12800             consumeUntil(_tokenSet_0);
12801         } else {
12802             throw;
12803         }
12804     }
12805     returnAST = operator_call_AST;
12806 }
12807 
12808 void AdaParser::operator_call_tail(
12809     RefAdaAST opstr
12810 ) {
12811     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12812     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12813     RefAdaAST operator_call_tail_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12814     
12815     try {      // for error handling
12816         match(LPAREN);
12817         if (!( is_operator_symbol(opstr->getText().c_str()) ))
12818             throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(opstr->getText().c_str()) ");
12819         value_s();
12820         if (inputState->guessing==0) {
12821             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12822         }
12823         match(RPAREN);
12824         if ( inputState->guessing==0 ) {
12825 #line 1376 "ada.g"
12826             opstr->setType(OPERATOR_SYMBOL);
12827 #line 12828 "AdaParser.cpp"
12828         }
12829         operator_call_tail_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
12830     }
12831     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
12832         if( inputState->guessing == 0 ) {
12833             reportError(ex);
12834             consume();
12835             consumeUntil(_tokenSet_113);
12836         } else {
12837             throw;
12838         }
12839     }
12840     returnAST = operator_call_tail_AST;
12841 }
12842 
12843 void AdaParser::relation() {
12844     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12845     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
12846     RefAdaAST relation_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12847     ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
12848     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12849     
12850     try {      // for error handling
12851         simple_expression();
12852         if (inputState->guessing==0) {
12853             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12854         }
12855         {
12856         switch ( LA(1)) {
12857         case IN:
12858         {
12859             RefAdaAST tmp346_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12860             if ( inputState->guessing == 0 ) {
12861                 tmp346_AST = astFactory->create(LT(1));
12862                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp346_AST.get()));
12863             }
12864             match(IN);
12865             range_or_mark();
12866             if (inputState->guessing==0) {
12867                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12868             }
12869             break;
12870         }
12871         case NOT:
12872         {
12873             n = LT(1);
12874             if ( inputState->guessing == 0 ) {
12875                 n_AST = astFactory->create(n);
12876                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
12877             }
12878             match(NOT);
12879             match(IN);
12880             range_or_mark();
12881             if (inputState->guessing==0) {
12882                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12883             }
12884             if ( inputState->guessing==0 ) {
12885 #line 1400 "ada.g"
12886                 Set (n_AST, NOT_IN);
12887 #line 12888 "AdaParser.cpp"
12888             }
12889             break;
12890         }
12891         case EQ:
12892         {
12893             RefAdaAST tmp348_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12894             if ( inputState->guessing == 0 ) {
12895                 tmp348_AST = astFactory->create(LT(1));
12896                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp348_AST.get()));
12897             }
12898             match(EQ);
12899             simple_expression();
12900             if (inputState->guessing==0) {
12901                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12902             }
12903             break;
12904         }
12905         case NE:
12906         {
12907             RefAdaAST tmp349_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12908             if ( inputState->guessing == 0 ) {
12909                 tmp349_AST = astFactory->create(LT(1));
12910                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp349_AST.get()));
12911             }
12912             match(NE);
12913             simple_expression();
12914             if (inputState->guessing==0) {
12915                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12916             }
12917             break;
12918         }
12919         case LT_:
12920         {
12921             RefAdaAST tmp350_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12922             if ( inputState->guessing == 0 ) {
12923                 tmp350_AST = astFactory->create(LT(1));
12924                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp350_AST.get()));
12925             }
12926             match(LT_);
12927             simple_expression();
12928             if (inputState->guessing==0) {
12929                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12930             }
12931             break;
12932         }
12933         case LE:
12934         {
12935             RefAdaAST tmp351_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12936             if ( inputState->guessing == 0 ) {
12937                 tmp351_AST = astFactory->create(LT(1));
12938                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp351_AST.get()));
12939             }
12940             match(LE);
12941             simple_expression();
12942             if (inputState->guessing==0) {
12943                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12944             }
12945             break;
12946         }
12947         case GT:
12948         {
12949             RefAdaAST tmp352_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12950             if ( inputState->guessing == 0 ) {
12951                 tmp352_AST = astFactory->create(LT(1));
12952                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp352_AST.get()));
12953             }
12954             match(GT);
12955             simple_expression();
12956             if (inputState->guessing==0) {
12957                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12958             }
12959             break;
12960         }
12961         case GE:
12962         {
12963             RefAdaAST tmp353_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
12964             if ( inputState->guessing == 0 ) {
12965                 tmp353_AST = astFactory->create(LT(1));
12966                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp353_AST.get()));
12967             }
12968             match(GE);
12969             simple_expression();
12970             if (inputState->guessing==0) {
12971                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
12972             }
12973             break;
12974         }
12975         case SEMI:
12976         case COMMA:
12977         case RPAREN:
12978         case RIGHT_SHAFT:
12979         case WITH:
12980         case RANGE:
12981         case DIGITS:
12982         case IS:
12983         case PIPE:
12984         case DOT_DOT:
12985         case ASSIGN:
12986         case THEN:
12987         case LOOP:
12988         case OR:
12989         case AND:
12990         case XOR:
12991         {
12992             break;
12993         }
12994         default:
12995         {
12996             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
12997         }
12998         }
12999         }
13000         relation_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13001     }
13002     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13003         if( inputState->guessing == 0 ) {
13004             reportError(ex);
13005             consume();
13006             consumeUntil(_tokenSet_34);
13007         } else {
13008             throw;
13009         }
13010     }
13011     returnAST = relation_AST;
13012 }
13013 
13014 void AdaParser::range_or_mark() {
13015     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13016     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13017     RefAdaAST range_or_mark_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13018     
13019     try {      // for error handling
13020         bool synPredMatched450 = false;
13021         if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) {
13022             int _m450 = mark();
13023             synPredMatched450 = true;
13024             inputState->guessing++;
13025             try {
13026                 {
13027                 range();
13028                 }
13029             }
13030             catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
13031                 synPredMatched450 = false;
13032             }
13033             rewind(_m450);
13034             inputState->guessing--;
13035         }
13036         if ( synPredMatched450 ) {
13037             range();
13038             if (inputState->guessing==0) {
13039                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13040             }
13041             range_or_mark_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13042         }
13043         else if ((LA(1) == IDENTIFIER) && (_tokenSet_114.member(LA(2)))) {
13044             subtype_mark();
13045             if (inputState->guessing==0) {
13046                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13047             }
13048             range_or_mark_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13049         }
13050         else {
13051             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13052         }
13053         
13054     }
13055     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13056         if( inputState->guessing == 0 ) {
13057             reportError(ex);
13058             consume();
13059             consumeUntil(_tokenSet_34);
13060         } else {
13061             throw;
13062         }
13063     }
13064     returnAST = range_or_mark_AST;
13065 }
13066 
13067 void AdaParser::signed_term() {
13068     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13069     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13070     RefAdaAST signed_term_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13071     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
13072     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13073     ANTLR_USE_NAMESPACE(antlr)RefToken  m = ANTLR_USE_NAMESPACE(antlr)nullToken;
13074     RefAdaAST m_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13075     
13076     try {      // for error handling
13077         switch ( LA(1)) {
13078         case PLUS:
13079         {
13080             p = LT(1);
13081             if ( inputState->guessing == 0 ) {
13082                 p_AST = astFactory->create(p);
13083                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13084             }
13085             match(PLUS);
13086             term();
13087             if (inputState->guessing==0) {
13088                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13089             }
13090             if ( inputState->guessing==0 ) {
13091 #line 1422 "ada.g"
13092                 Set(p_AST, UNARY_PLUS);
13093 #line 13094 "AdaParser.cpp"
13094             }
13095             signed_term_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13096             break;
13097         }
13098         case MINUS:
13099         {
13100             m = LT(1);
13101             if ( inputState->guessing == 0 ) {
13102                 m_AST = astFactory->create(m);
13103                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(m_AST.get()));
13104             }
13105             match(MINUS);
13106             term();
13107             if (inputState->guessing==0) {
13108                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13109             }
13110             if ( inputState->guessing==0 ) {
13111 #line 1423 "ada.g"
13112                 Set(m_AST, UNARY_MINUS);
13113 #line 13114 "AdaParser.cpp"
13114             }
13115             signed_term_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13116             break;
13117         }
13118         case IDENTIFIER:
13119         case LPAREN:
13120         case NEW:
13121         case CHARACTER_LITERAL:
13122         case CHAR_STRING:
13123         case NuLL:
13124         case NOT:
13125         case ABS:
13126         case NUMERIC_LIT:
13127         {
13128             term();
13129             if (inputState->guessing==0) {
13130                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13131             }
13132             signed_term_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13133             break;
13134         }
13135         default:
13136         {
13137             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13138         }
13139         }
13140     }
13141     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13142         if( inputState->guessing == 0 ) {
13143             reportError(ex);
13144             consume();
13145             consumeUntil(_tokenSet_115);
13146         } else {
13147             throw;
13148         }
13149     }
13150     returnAST = signed_term_AST;
13151 }
13152 
13153 void AdaParser::term() {
13154     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13155     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13156     RefAdaAST term_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13157     
13158     try {      // for error handling
13159         factor();
13160         if (inputState->guessing==0) {
13161             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13162         }
13163         { // ( ... )*
13164         for (;;) {
13165             switch ( LA(1)) {
13166             case STAR:
13167             {
13168                 RefAdaAST tmp354_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13169                 if ( inputState->guessing == 0 ) {
13170                     tmp354_AST = astFactory->create(LT(1));
13171                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp354_AST.get()));
13172                 }
13173                 match(STAR);
13174                 factor();
13175                 if (inputState->guessing==0) {
13176                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13177                 }
13178                 break;
13179             }
13180             case DIV:
13181             {
13182                 RefAdaAST tmp355_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13183                 if ( inputState->guessing == 0 ) {
13184                     tmp355_AST = astFactory->create(LT(1));
13185                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp355_AST.get()));
13186                 }
13187                 match(DIV);
13188                 factor();
13189                 if (inputState->guessing==0) {
13190                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13191                 }
13192                 break;
13193             }
13194             case MOD:
13195             {
13196                 RefAdaAST tmp356_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13197                 if ( inputState->guessing == 0 ) {
13198                     tmp356_AST = astFactory->create(LT(1));
13199                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp356_AST.get()));
13200                 }
13201                 match(MOD);
13202                 factor();
13203                 if (inputState->guessing==0) {
13204                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13205                 }
13206                 break;
13207             }
13208             case REM:
13209             {
13210                 RefAdaAST tmp357_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13211                 if ( inputState->guessing == 0 ) {
13212                     tmp357_AST = astFactory->create(LT(1));
13213                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp357_AST.get()));
13214                 }
13215                 match(REM);
13216                 factor();
13217                 if (inputState->guessing==0) {
13218                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13219                 }
13220                 break;
13221             }
13222             default:
13223             {
13224                 goto _loop457;
13225             }
13226             }
13227         }
13228         _loop457:;
13229         } // ( ... )*
13230         term_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13231     }
13232     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13233         if( inputState->guessing == 0 ) {
13234             reportError(ex);
13235             consume();
13236             consumeUntil(_tokenSet_115);
13237         } else {
13238             throw;
13239         }
13240     }
13241     returnAST = term_AST;
13242 }
13243 
13244 void AdaParser::factor() {
13245     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13246     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13247     RefAdaAST factor_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13248     
13249     try {      // for error handling
13250         {
13251         switch ( LA(1)) {
13252         case NOT:
13253         {
13254             RefAdaAST tmp358_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13255             if ( inputState->guessing == 0 ) {
13256                 tmp358_AST = astFactory->create(LT(1));
13257                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp358_AST.get()));
13258             }
13259             match(NOT);
13260             primary();
13261             if (inputState->guessing==0) {
13262                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13263             }
13264             break;
13265         }
13266         case ABS:
13267         {
13268             RefAdaAST tmp359_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13269             if ( inputState->guessing == 0 ) {
13270                 tmp359_AST = astFactory->create(LT(1));
13271                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp359_AST.get()));
13272             }
13273             match(ABS);
13274             primary();
13275             if (inputState->guessing==0) {
13276                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13277             }
13278             break;
13279         }
13280         case IDENTIFIER:
13281         case LPAREN:
13282         case NEW:
13283         case CHARACTER_LITERAL:
13284         case CHAR_STRING:
13285         case NuLL:
13286         case NUMERIC_LIT:
13287         {
13288             primary();
13289             if (inputState->guessing==0) {
13290                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13291             }
13292             {
13293             switch ( LA(1)) {
13294             case EXPON:
13295             {
13296                 RefAdaAST tmp360_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13297                 if ( inputState->guessing == 0 ) {
13298                     tmp360_AST = astFactory->create(LT(1));
13299                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp360_AST.get()));
13300                 }
13301                 match(EXPON);
13302                 primary();
13303                 if (inputState->guessing==0) {
13304                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13305                 }
13306                 break;
13307             }
13308             case SEMI:
13309             case COMMA:
13310             case RPAREN:
13311             case RIGHT_SHAFT:
13312             case WITH:
13313             case RANGE:
13314             case DIGITS:
13315             case IS:
13316             case PIPE:
13317             case DOT_DOT:
13318             case IN:
13319             case ASSIGN:
13320             case MOD:
13321             case THEN:
13322             case LOOP:
13323             case OR:
13324             case AND:
13325             case XOR:
13326             case NOT:
13327             case EQ:
13328             case NE:
13329             case LT_:
13330             case LE:
13331             case GT:
13332             case GE:
13333             case PLUS:
13334             case MINUS:
13335             case CONCAT:
13336             case STAR:
13337             case DIV:
13338             case REM:
13339             {
13340                 break;
13341             }
13342             default:
13343             {
13344                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13345             }
13346             }
13347             }
13348             break;
13349         }
13350         default:
13351         {
13352             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13353         }
13354         }
13355         }
13356         factor_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13357     }
13358     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13359         if( inputState->guessing == 0 ) {
13360             reportError(ex);
13361             consume();
13362             consumeUntil(_tokenSet_116);
13363         } else {
13364             throw;
13365         }
13366     }
13367     returnAST = factor_AST;
13368 }
13369 
13370 void AdaParser::primary() {
13371     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13372     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13373     RefAdaAST primary_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13374     ANTLR_USE_NAMESPACE(antlr)RefToken  cs = ANTLR_USE_NAMESPACE(antlr)nullToken;
13375     RefAdaAST cs_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13376     
13377     try {      // for error handling
13378         {
13379         switch ( LA(1)) {
13380         case IDENTIFIER:
13381         {
13382             name_or_qualified();
13383             if (inputState->guessing==0) {
13384                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13385             }
13386             break;
13387         }
13388         case LPAREN:
13389         {
13390             parenthesized_primary();
13391             if (inputState->guessing==0) {
13392                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13393             }
13394             break;
13395         }
13396         case NEW:
13397         {
13398             allocator();
13399             if (inputState->guessing==0) {
13400                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13401             }
13402             break;
13403         }
13404         case NuLL:
13405         {
13406             RefAdaAST tmp361_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13407             if ( inputState->guessing == 0 ) {
13408                 tmp361_AST = astFactory->create(LT(1));
13409                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp361_AST.get()));
13410             }
13411             match(NuLL);
13412             break;
13413         }
13414         case NUMERIC_LIT:
13415         {
13416             RefAdaAST tmp362_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13417             if ( inputState->guessing == 0 ) {
13418                 tmp362_AST = astFactory->create(LT(1));
13419                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp362_AST.get()));
13420             }
13421             match(NUMERIC_LIT);
13422             break;
13423         }
13424         case CHARACTER_LITERAL:
13425         {
13426             RefAdaAST tmp363_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13427             if ( inputState->guessing == 0 ) {
13428                 tmp363_AST = astFactory->create(LT(1));
13429                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp363_AST.get()));
13430             }
13431             match(CHARACTER_LITERAL);
13432             break;
13433         }
13434         case CHAR_STRING:
13435         {
13436             cs = LT(1);
13437             if ( inputState->guessing == 0 ) {
13438                 cs_AST = astFactory->create(cs);
13439                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cs_AST.get()));
13440             }
13441             match(CHAR_STRING);
13442             {
13443             switch ( LA(1)) {
13444             case LPAREN:
13445             {
13446                 operator_call_tail(cs_AST);
13447                 if (inputState->guessing==0) {
13448                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13449                 }
13450                 break;
13451             }
13452             case SEMI:
13453             case COMMA:
13454             case RPAREN:
13455             case RIGHT_SHAFT:
13456             case WITH:
13457             case RANGE:
13458             case DIGITS:
13459             case IS:
13460             case PIPE:
13461             case DOT_DOT:
13462             case IN:
13463             case ASSIGN:
13464             case MOD:
13465             case THEN:
13466             case LOOP:
13467             case OR:
13468             case AND:
13469             case XOR:
13470             case NOT:
13471             case EQ:
13472             case NE:
13473             case LT_:
13474             case LE:
13475             case GT:
13476             case GE:
13477             case PLUS:
13478             case MINUS:
13479             case CONCAT:
13480             case STAR:
13481             case DIV:
13482             case REM:
13483             case EXPON:
13484             {
13485                 break;
13486             }
13487             default:
13488             {
13489                 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13490             }
13491             }
13492             }
13493             break;
13494         }
13495         default:
13496         {
13497             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13498         }
13499         }
13500         }
13501         primary_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13502     }
13503     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13504         if( inputState->guessing == 0 ) {
13505             reportError(ex);
13506             consume();
13507             consumeUntil(_tokenSet_117);
13508         } else {
13509             throw;
13510         }
13511     }
13512     returnAST = primary_AST;
13513 }
13514 
13515 void AdaParser::name_or_qualified() {
13516     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13517     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13518     RefAdaAST name_or_qualified_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13519     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
13520     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13521 #line 1454 "ada.g"
13522     RefAdaAST dummy;
13523 #line 13524 "AdaParser.cpp"
13524     
13525     try {      // for error handling
13526         RefAdaAST tmp364_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13527         if ( inputState->guessing == 0 ) {
13528             tmp364_AST = astFactory->create(LT(1));
13529             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp364_AST.get()));
13530         }
13531         match(IDENTIFIER);
13532         { // ( ... )*
13533         for (;;) {
13534             switch ( LA(1)) {
13535             case DOT:
13536             {
13537                 RefAdaAST tmp365_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13538                 if ( inputState->guessing == 0 ) {
13539                     tmp365_AST = astFactory->create(LT(1));
13540                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp365_AST.get()));
13541                 }
13542                 match(DOT);
13543                 {
13544                 switch ( LA(1)) {
13545                 case ALL:
13546                 {
13547                     RefAdaAST tmp366_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13548                     if ( inputState->guessing == 0 ) {
13549                         tmp366_AST = astFactory->create(LT(1));
13550                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp366_AST.get()));
13551                     }
13552                     match(ALL);
13553                     break;
13554                 }
13555                 case IDENTIFIER:
13556                 {
13557                     RefAdaAST tmp367_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13558                     if ( inputState->guessing == 0 ) {
13559                         tmp367_AST = astFactory->create(LT(1));
13560                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp367_AST.get()));
13561                     }
13562                     match(IDENTIFIER);
13563                     break;
13564                 }
13565                 case CHARACTER_LITERAL:
13566                 {
13567                     RefAdaAST tmp368_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13568                     if ( inputState->guessing == 0 ) {
13569                         tmp368_AST = astFactory->create(LT(1));
13570                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp368_AST.get()));
13571                     }
13572                     match(CHARACTER_LITERAL);
13573                     break;
13574                 }
13575                 case CHAR_STRING:
13576                 {
13577                     dummy=is_operator();
13578                     if (inputState->guessing==0) {
13579                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13580                     }
13581                     break;
13582                 }
13583                 default:
13584                 {
13585                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13586                 }
13587                 }
13588                 }
13589                 break;
13590             }
13591             case LPAREN:
13592             {
13593                 p = LT(1);
13594                 if ( inputState->guessing == 0 ) {
13595                     p_AST = astFactory->create(p);
13596                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13597                 }
13598                 match(LPAREN);
13599                 value_s();
13600                 if (inputState->guessing==0) {
13601                     astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13602                 }
13603                 match(RPAREN);
13604                 if ( inputState->guessing==0 ) {
13605 #line 1462 "ada.g"
13606                     Set(p_AST, INDEXED_COMPONENT);
13607 #line 13608 "AdaParser.cpp"
13608                 }
13609                 break;
13610             }
13611             case TIC:
13612             {
13613                 RefAdaAST tmp370_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13614                 if ( inputState->guessing == 0 ) {
13615                     tmp370_AST = astFactory->create(LT(1));
13616                     astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp370_AST.get()));
13617                 }
13618                 match(TIC);
13619                 {
13620                 switch ( LA(1)) {
13621                 case LPAREN:
13622                 {
13623                     parenthesized_primary();
13624                     if (inputState->guessing==0) {
13625                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13626                     }
13627                     break;
13628                 }
13629                 case IDENTIFIER:
13630                 case RANGE:
13631                 case DIGITS:
13632                 case DELTA:
13633                 case ACCESS:
13634                 {
13635                     attribute_id();
13636                     if (inputState->guessing==0) {
13637                         astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13638                     }
13639                     break;
13640                 }
13641                 default:
13642                 {
13643                     throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13644                 }
13645                 }
13646                 }
13647                 break;
13648             }
13649             default:
13650             {
13651                 goto _loop468;
13652             }
13653             }
13654         }
13655         _loop468:;
13656         } // ( ... )*
13657         name_or_qualified_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13658     }
13659     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13660         if( inputState->guessing == 0 ) {
13661             reportError(ex);
13662             consume();
13663             consumeUntil(_tokenSet_117);
13664         } else {
13665             throw;
13666         }
13667     }
13668     returnAST = name_or_qualified_AST;
13669 }
13670 
13671 void AdaParser::allocator() {
13672     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13673     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13674     RefAdaAST allocator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13675     ANTLR_USE_NAMESPACE(antlr)RefToken  n = ANTLR_USE_NAMESPACE(antlr)nullToken;
13676     RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13677     
13678     try {      // for error handling
13679         n = LT(1);
13680         if ( inputState->guessing == 0 ) {
13681             n_AST = astFactory->create(n);
13682             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()));
13683         }
13684         match(NEW);
13685         name_or_qualified();
13686         if (inputState->guessing==0) {
13687             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13688         }
13689         if ( inputState->guessing==0 ) {
13690 #line 1468 "ada.g"
13691             Set(n_AST, ALLOCATOR);
13692 #line 13693 "AdaParser.cpp"
13693         }
13694         allocator_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13695     }
13696     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13697         if( inputState->guessing == 0 ) {
13698             reportError(ex);
13699             consume();
13700             consumeUntil(_tokenSet_117);
13701         } else {
13702             throw;
13703         }
13704     }
13705     returnAST = allocator_AST;
13706 }
13707 
13708 void AdaParser::subprogram_body() {
13709     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13710     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13711     RefAdaAST subprogram_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13712     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
13713     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13714     ANTLR_USE_NAMESPACE(antlr)RefToken  f = ANTLR_USE_NAMESPACE(antlr)nullToken;
13715     RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13716     
13717     try {      // for error handling
13718         switch ( LA(1)) {
13719         case PROCEDURE:
13720         {
13721             p = LT(1);
13722             if ( inputState->guessing == 0 ) {
13723                 p_AST = astFactory->create(p);
13724                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13725             }
13726             match(PROCEDURE);
13727             def_id(false);
13728             if (inputState->guessing==0) {
13729                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13730             }
13731             formal_part_opt();
13732             if (inputState->guessing==0) {
13733                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13734             }
13735             match(IS);
13736             body_part();
13737             if (inputState->guessing==0) {
13738                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13739             }
13740             match(SEMI);
13741             if ( inputState->guessing==0 ) {
13742 #line 1482 "ada.g"
13743                 Set(p_AST, PROCEDURE_BODY);
13744 #line 13745 "AdaParser.cpp"
13745             }
13746             subprogram_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13747             break;
13748         }
13749         case FUNCTION:
13750         {
13751             f = LT(1);
13752             if ( inputState->guessing == 0 ) {
13753                 f_AST = astFactory->create(f);
13754                 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get()));
13755             }
13756             match(FUNCTION);
13757             function_tail();
13758             if (inputState->guessing==0) {
13759                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13760             }
13761             match(IS);
13762             body_part();
13763             if (inputState->guessing==0) {
13764                 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13765             }
13766             match(SEMI);
13767             if ( inputState->guessing==0 ) {
13768 #line 1484 "ada.g"
13769                 Set(f_AST, FUNCTION_BODY);
13770 #line 13771 "AdaParser.cpp"
13771             }
13772             subprogram_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13773             break;
13774         }
13775         default:
13776         {
13777             throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
13778         }
13779         }
13780     }
13781     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13782         if( inputState->guessing == 0 ) {
13783             reportError(ex);
13784             consume();
13785             consumeUntil(_tokenSet_2);
13786         } else {
13787             throw;
13788         }
13789     }
13790     returnAST = subprogram_body_AST;
13791 }
13792 
13793 void AdaParser::package_body() {
13794     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13795     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13796     RefAdaAST package_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13797     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
13798     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13799     
13800     try {      // for error handling
13801         p = LT(1);
13802         if ( inputState->guessing == 0 ) {
13803             p_AST = astFactory->create(p);
13804             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13805         }
13806         match(PACKAGE);
13807         body_is();
13808         if (inputState->guessing==0) {
13809             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13810         }
13811         pkg_body_part();
13812         if (inputState->guessing==0) {
13813             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13814         }
13815         end_id_opt();
13816         match(SEMI);
13817         if ( inputState->guessing==0 ) {
13818 #line 1488 "ada.g"
13819             Set(p_AST, PACKAGE_BODY);
13820 #line 13821 "AdaParser.cpp"
13821         }
13822         package_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13823     }
13824     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13825         if( inputState->guessing == 0 ) {
13826             reportError(ex);
13827             consume();
13828             consumeUntil(_tokenSet_2);
13829         } else {
13830             throw;
13831         }
13832     }
13833     returnAST = package_body_AST;
13834 }
13835 
13836 void AdaParser::task_body() {
13837     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13838     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13839     RefAdaAST task_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13840     ANTLR_USE_NAMESPACE(antlr)RefToken  t = ANTLR_USE_NAMESPACE(antlr)nullToken;
13841     RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13842     
13843     try {      // for error handling
13844         t = LT(1);
13845         if ( inputState->guessing == 0 ) {
13846             t_AST = astFactory->create(t);
13847             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get()));
13848         }
13849         match(TASK);
13850         body_is();
13851         if (inputState->guessing==0) {
13852             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13853         }
13854         body_part();
13855         if (inputState->guessing==0) {
13856             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13857         }
13858         match(SEMI);
13859         if ( inputState->guessing==0 ) {
13860 #line 1492 "ada.g"
13861             Set(t_AST, TASK_BODY);
13862 #line 13863 "AdaParser.cpp"
13863         }
13864         task_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13865     }
13866     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13867         if( inputState->guessing == 0 ) {
13868             reportError(ex);
13869             consume();
13870             consumeUntil(_tokenSet_2);
13871         } else {
13872             throw;
13873         }
13874     }
13875     returnAST = task_body_AST;
13876 }
13877 
13878 void AdaParser::protected_body() {
13879     returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13880     ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
13881     RefAdaAST protected_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13882     ANTLR_USE_NAMESPACE(antlr)RefToken  p = ANTLR_USE_NAMESPACE(antlr)nullToken;
13883     RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
13884     
13885     try {      // for error handling
13886         p = LT(1);
13887         if ( inputState->guessing == 0 ) {
13888             p_AST = astFactory->create(p);
13889             astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get()));
13890         }
13891         match(PROTECTED);
13892         body_is();
13893         if (inputState->guessing==0) {
13894             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13895         }
13896         prot_op_bodies_opt();
13897         if (inputState->guessing==0) {
13898             astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
13899         }
13900         end_id_opt();
13901         match(SEMI);
13902         if ( inputState->guessing==0 ) {
13903 #line 1496 "ada.g"
13904             Set(p_AST, PROTECTED_BODY);
13905 #line 13906 "AdaParser.cpp"
13906         }
13907         protected_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root);
13908     }
13909     catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
13910         if( inputState->guessing == 0 ) {
13911             reportError(ex);
13912             consume();
13913             consumeUntil(_tokenSet_2);
13914         } else {
13915             throw;
13916         }
13917     }
13918     returnAST = protected_body_AST;
13919 }
13920 
13921 RefAdaAST AdaParser::getAST()
13922 {
13923     return returnAST;
13924 }
13925 
13926 void AdaParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
13927 {
13928     factory.setMaxNodeType(303);
13929 }
13930 const char* AdaParser::tokenNames[] = {
13931     "<0>",
13932     "EOF",
13933     "<2>",
13934     "NULL_TREE_LOOKAHEAD",
13935     "\"pragma\"",
13936     "IDENTIFIER",
13937     "SEMI",
13938     "LPAREN",
13939     "COMMA",
13940     "RPAREN",
13941     "RIGHT_SHAFT",
13942     "\"with\"",
13943     "DOT",
13944     "\"use\"",
13945     "\"type\"",
13946     "TIC",
13947     "\"range\"",
13948     "\"digits\"",
13949     "\"delta\"",
13950     "\"access\"",
13951     "\"private\"",
13952     "\"package\"",
13953     "\"body\"",
13954     "\"is\"",
13955     "\"procedure\"",
13956     "\"function\"",
13957     "\"new\"",
13958     "\"others\"",
13959     "PIPE",
13960     "DOT_DOT",
13961     "\"all\"",
13962     "COLON",
13963     "\"in\"",
13964     "\"out\"",
13965     "\"renames\"",
13966     "CHARACTER_LITERAL",
13967     "CHAR_STRING",
13968     "\"null\"",
13969     "\"record\"",
13970     "\"separate\"",
13971     "\"abstract\"",
13972     "\"return\"",
13973     "\"task\"",
13974     "\"protected\"",
13975     "BOX",
13976     "ASSIGN",
13977     "\"entry\"",
13978     "\"for\"",
13979     "\"end\"",
13980     "\"at\"",
13981     "\"mod\"",
13982     "\"subtype\"",
13983     "\"exception\"",
13984     "\"constant\"",
13985     "\"array\"",
13986     "\"of\"",
13987     "\"aliased\"",
13988     "\"case\"",
13989     "\"when\"",
13990     "\"tagged\"",
13991     "\"limited\"",
13992     "\"generic\"",
13993     "\"begin\"",
13994     "LT_LT",
13995     "GT_GT",
13996     "\"if\"",
13997     "\"then\"",
13998     "\"elsif\"",
13999     "\"else\"",
14000     "\"loop\"",
14001     "\"while\"",
14002     "\"reverse\"",
14003     "\"declare\"",
14004     "\"exit\"",
14005     "\"goto\"",
14006     "\"accept\"",
14007     "\"do\"",
14008     "\"delay\"",
14009     "\"until\"",
14010     "\"select\"",
14011     "\"abort\"",
14012     "\"or\"",
14013     "\"terminate\"",
14014     "\"raise\"",
14015     "\"requeue\"",
14016     "\"and\"",
14017     "\"xor\"",
14018     "\"not\"",
14019     "EQ",
14020     "NE",
14021     "LT_",
14022     "LE",
14023     "GT",
14024     "GE",
14025     "PLUS",
14026     "MINUS",
14027     "CONCAT",
14028     "STAR",
14029     "DIV",
14030     "\"rem\"",
14031     "\"abs\"",
14032     "EXPON",
14033     "NUMERIC_LIT",
14034     "ABORTABLE_PART",
14035     "ABORT_STATEMENT",
14036     "ABSTRACT_SUBPROGRAM_DECLARATION",
14037     "ACCEPT_ALTERNATIVE",
14038     "ACCEPT_STATEMENT",
14039     "ALLOCATOR",
14040     "ASSIGNMENT_STATEMENT",
14041     "ASYNCHRONOUS_SELECT",
14042     "ATTRIBUTE_DEFINITION_CLAUSE",
14043     "AT_CLAUSE",
14044     "BLOCK_STATEMENT",
14045     "CASE_STATEMENT",
14046     "CASE_STATEMENT_ALTERNATIVE",
14047     "CODE_STATEMENT",
14048     "COMPONENT_DECLARATION",
14049     "COMPONENT_LIST",
14050     "CONDITION",
14051     "CONDITIONAL_ENTRY_CALL",
14052     "CONTEXT_CLAUSE",
14053     "DECLARATIVE_ITEM",
14054     "DECLARATIVE_PART",
14055     "DEFINING_IDENTIFIER_LIST",
14056     "DELAY_ALTERNATIVE",
14057     "DELAY_STATEMENT",
14058     "DELTA_CONSTRAINT",
14059     "DIGITS_CONSTRAINT",
14060     "DISCRETE_RANGE",
14061     "DISCRIMINANT_ASSOCIATION",
14062     "DISCRIMINANT_CONSTRAINT",
14063     "DISCRIMINANT_SPECIFICATION",
14064     "ENTRY_BODY",
14065     "ENTRY_CALL_ALTERNATIVE",
14066     "ENTRY_CALL_STATEMENT",
14067     "ENTRY_DECLARATION",
14068     "ENTRY_INDEX_SPECIFICATION",
14069     "ENUMERATION_REPESENTATION_CLAUSE",
14070     "EXCEPTION_DECLARATION",
14071     "EXCEPTION_HANDLER",
14072     "EXCEPTION_RENAMING_DECLARATION",
14073     "EXIT_STATEMENT",
14074     "FORMAL_PACKAGE_DECLARATION",
14075     "FORMAL_TYPE_DECLARATION",
14076     "FULL_TYPE_DECLARATION",
14077     "GENERIC_FORMAL_PART",
14078     "GENERIC_INSTANTIATION",
14079     "GENERIC_PACKAGE_DECLARATION",
14080     "GENERIC_RENAMING_DECLARATION",
14081     "GENERIC_SUBPROGRAM_DECLARATION",
14082     "GOTO_STATEMENT",
14083     "HANDLED_SEQUENCE_OF_STATEMENTS",
14084     "IF_STATEMENT",
14085     "INCOMPLETE_TYPE_DECLARATION",
14086     "INDEXED_COMPONENT",
14087     "INDEX_CONSTRAINT",
14088     "LIBRARY_ITEM",
14089     "LOOP_STATEMENT",
14090     "NAME",
14091     "NULL_STATEMENT",
14092     "NUMBER_DECLARATION",
14093     "OBJECT_DECLARATION",
14094     "OBJECT_RENAMING_DECLARATION",
14095     "OPERATOR_SYMBOL",
14096     "PACKAGE_BODY",
14097     "PACKAGE_BODY_STUB",
14098     "PACKAGE_RENAMING_DECLARATION",
14099     "PACKAGE_SPECIFICATION",
14100     "PARAMETER_SPECIFICATION",
14101     "PREFIX",
14102     "PRIMARY",
14103     "PRIVATE_EXTENSION_DECLARATION",
14104     "PRIVATE_TYPE_DECLARATION",
14105     "PROCEDURE_CALL_STATEMENT",
14106     "PROTECTED_BODY",
14107     "PROTECTED_BODY_STUB",
14108     "PROTECTED_TYPE_DECLARATION",
14109     "RAISE_STATEMENT",
14110     "RANGE_ATTRIBUTE_REFERENCE",
14111     "RECORD_REPRESENTATION_CLAUSE",
14112     "REQUEUE_STATEMENT",
14113     "RETURN_STATEMENT",
14114     "SELECTIVE_ACCEPT",
14115     "SELECT_ALTERNATIVE",
14116     "SELECT_STATEMENT",
14117     "SEQUENCE_OF_STATEMENTS",
14118     "SINGLE_PROTECTED_DECLARATION",
14119     "SINGLE_TASK_DECLARATION",
14120     "STATEMENT",
14121     "SUBPROGRAM_BODY",
14122     "SUBPROGRAM_BODY_STUB",
14123     "SUBPROGRAM_DECLARATION",
14124     "SUBPROGRAM_RENAMING_DECLARATION",
14125     "SUBTYPE_DECLARATION",
14126     "SUBTYPE_INDICATION",
14127     "SUBTYPE_MARK",
14128     "SUBUNIT",
14129     "TASK_BODY",
14130     "TASK_BODY_STUB",
14131     "TASK_TYPE_DECLARATION",
14132     "TERMINATE_ALTERNATIVE",
14133     "TIMED_ENTRY_CALL",
14134     "TRIGGERING_ALTERNATIVE",
14135     "TYPE_DECLARATION",
14136     "USE_CLAUSE",
14137     "USE_TYPE_CLAUSE",
14138     "VARIANT",
14139     "VARIANT_PART",
14140     "WITH_CLAUSE",
14141     "ABSTRACT_FUNCTION_DECLARATION",
14142     "ABSTRACT_PROCEDURE_DECLARATION",
14143     "ACCESS_TO_FUNCTION_DECLARATION",
14144     "ACCESS_TO_OBJECT_DECLARATION",
14145     "ACCESS_TO_PROCEDURE_DECLARATION",
14146     "ACCESS_TYPE_DECLARATION",
14147     "ARRAY_OBJECT_DECLARATION",
14148     "ARRAY_TYPE_DECLARATION",
14149     "AND_THEN",
14150     "BASIC_DECLARATIVE_ITEMS_OPT",
14151     "BLOCK_BODY",
14152     "BLOCK_BODY_OPT",
14153     "CALL_STATEMENT",
14154     "COMPONENT_CLAUSES_OPT",
14155     "COMPONENT_ITEMS",
14156     "COND_CLAUSE",
14157     "DECIMAL_FIXED_POINT_DECLARATION",
14158     "DECLARE_OPT",
14159     "DERIVED_RECORD_EXTENSION",
14160     "DERIVED_TYPE_DECLARATION",
14161     "DISCRETE_SUBTYPE_DEF_OPT",
14162     "DISCRIMINANT_SPECIFICATIONS",
14163     "DISCRIM_PART_OPT",
14164     "ELSE_OPT",
14165     "ELSIFS_OPT",
14166     "ENTRY_INDEX_OPT",
14167     "ENUMERATION_TYPE_DECLARATION",
14168     "EXCEPT_HANDLER_PART_OPT",
14169     "EXTENSION_OPT",
14170     "FLOATING_POINT_DECLARATION",
14171     "FORMAL_DECIMAL_FIXED_POINT_DECLARATION",
14172     "FORMAL_DISCRETE_TYPE_DECLARATION",
14173     "FORMAL_FLOATING_POINT_DECLARATION",
14174     "FORMAL_FUNCTION_DECLARATION",
14175     "FORMAL_MODULAR_TYPE_DECLARATION",
14176     "FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION",
14177     "FORMAL_ORDINARY_FIXED_POINT_DECLARATION",
14178     "FORMAL_PART_OPT",
14179     "FORMAL_PRIVATE_EXTENSION_DECLARATION",
14180     "FORMAL_PRIVATE_TYPE_DECLARATION",
14181     "FORMAL_PROCEDURE_DECLARATION",
14182     "FORMAL_SIGNED_INTEGER_TYPE_DECLARATION",
14183     "FUNCTION_BODY",
14184     "FUNCTION_BODY_STUB",
14185     "FUNCTION_DECLARATION",
14186     "FUNCTION_RENAMING_DECLARATION",
14187     "GENERIC_FUNCTION_DECLARATION",
14188     "GENERIC_FUNCTION_INSTANTIATION",
14189     "GENERIC_FUNCTION_RENAMING",
14190     "GENERIC_PACKAGE_INSTANTIATION",
14191     "GENERIC_PACKAGE_RENAMING",
14192     "GENERIC_PROCEDURE_DECLARATION",
14193     "GENERIC_PROCEDURE_INSTANTIATION",
14194     "GENERIC_PROCEDURE_RENAMING",
14195     "GUARD_OPT",
14196     "IDENTIFIER_COLON_OPT",
14197     "INIT_OPT",
14198     "ITERATION_SCHEME_OPT",
14199     "LABEL_OPT",
14200     "MARK_WITH_CONSTRAINT",
14201     "MODIFIERS",
14202     "MODULAR_TYPE_DECLARATION",
14203     "MOD_CLAUSE_OPT",
14204     "NOT_IN",
14205     "ORDINARY_DERIVED_TYPE_DECLARATION",
14206     "ORDINARY_FIXED_POINT_DECLARATION",
14207     "OR_ELSE",
14208     "OR_SELECT_OPT",
14209     "PARENTHESIZED_PRIMARY",
14210     "PRIVATE_TASK_ITEMS_OPT",
14211     "PROCEDURE_BODY",
14212     "PROCEDURE_BODY_STUB",
14213     "PROCEDURE_DECLARATION",
14214     "PROCEDURE_RENAMING_DECLARATION",
14215     "PROT_MEMBER_DECLARATIONS",
14216     "PROT_OP_BODIES_OPT",
14217     "PROT_OP_DECLARATIONS",
14218     "RANGED_EXPRS",
14219     "RECORD_TYPE_DECLARATION",
14220     "SELECTOR_NAMES_OPT",
14221     "SIGNED_INTEGER_TYPE_DECLARATION",
14222     "TASK_ITEMS_OPT",
14223     "UNARY_MINUS",
14224     "UNARY_PLUS",
14225     "VALUE",
14226     "VALUES",
14227     "VARIANTS",
14228     "COMMENT_INTRO",
14229     "DIGIT",
14230     "EXPONENT",
14231     "EXTENDED_DIGIT",
14232     "BASED_INTEGER",
14233     "WS_",
14234     "COMMENT",
14235     0
14236 };
14237 
14238 const unsigned long AdaParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14239 // EOF 
14240 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_0(_tokenSet_0_data_,10);
14241 const unsigned long AdaParser::_tokenSet_1_data_[] = { 53477376UL, 536871040UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14242 // "private" "package" "procedure" "function" "separate" "generic" 
14243 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_1(_tokenSet_1_data_,10);
14244 const unsigned long AdaParser::_tokenSet_2_data_[] = { 18UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14245 // EOF "pragma" 
14246 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_2(_tokenSet_2_data_,10);
14247 const unsigned long AdaParser::_tokenSet_3_data_[] = { 53504050UL, 3860450976UL, 2076542UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14248 // EOF "pragma" IDENTIFIER "with" "use" "type" "private" "package" "procedure" 
14249 // "function" "null" "separate" "return" "task" "protected" "entry" "for" 
14250 // "end" "subtype" "exception" "case" "when" "generic" "begin" LT_LT "if" 
14251 // "then" "elsif" "else" "loop" "while" "declare" "exit" "goto" "accept" 
14252 // "delay" "select" "abort" "or" "terminate" "raise" "requeue" 
14253 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_3(_tokenSet_3_data_,10);
14254 const unsigned long AdaParser::_tokenSet_4_data_[] = { 64UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14255 // SEMI 
14256 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_4(_tokenSet_4_data_,10);
14257 const unsigned long AdaParser::_tokenSet_5_data_[] = { 67109024UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14258 // IDENTIFIER LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "not" PLUS 
14259 // MINUS "abs" NUMERIC_LIT 
14260 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_5(_tokenSet_5_data_,10);
14261 const unsigned long AdaParser::_tokenSet_6_data_[] = { 201364384UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14262 // IDENTIFIER LPAREN COMMA RPAREN DOT TIC "new" "others" "in" CHARACTER_LITERAL 
14263 // CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 
14264 // MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
14265 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_6(_tokenSet_6_data_,10);
14266 const unsigned long AdaParser::_tokenSet_7_data_[] = { 768UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14267 // COMMA RPAREN 
14268 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_7(_tokenSet_7_data_,10);
14269 const unsigned long AdaParser::_tokenSet_8_data_[] = { 813895488UL, 8192UL, 36UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14270 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 
14271 // ASSIGN "then" "loop" 
14272 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_8(_tokenSet_8_data_,10);
14273 const unsigned long AdaParser::_tokenSet_9_data_[] = { 53487632UL, 536871040UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14274 // "pragma" "with" "use" "private" "package" "procedure" "function" "separate" 
14275 // "generic" 
14276 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_9(_tokenSet_9_data_,10);
14277 const unsigned long AdaParser::_tokenSet_10_data_[] = { 53504050UL, 1611238528UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14278 // EOF "pragma" IDENTIFIER "with" "use" "type" "private" "package" "procedure" 
14279 // "function" "separate" "task" "protected" "for" "end" "subtype" "generic" 
14280 // "begin" 
14281 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_10(_tokenSet_10_data_,10);
14282 const unsigned long AdaParser::_tokenSet_11_data_[] = { 814198720UL, 67248645UL, 6426660UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14283 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" "use" TIC "range" "digits" 
14284 // "delta" "is" PIPE DOT_DOT "in" "renames" "return" ASSIGN "at" "when" 
14285 // "then" "loop" "do" "or" "and" "xor" 
14286 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_11(_tokenSet_11_data_,10);
14287 const unsigned long AdaParser::_tokenSet_12_data_[] = { 814165952UL, 139268UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14288 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" "use" "range" "digits" "delta" 
14289 // "is" PIPE DOT_DOT "renames" ASSIGN "at" "then" "loop" "or" "and" "xor" 
14290 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_12(_tokenSet_12_data_,10);
14291 const unsigned long AdaParser::_tokenSet_13_data_[] = { 814202816UL, 401413UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14292 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT "use" TIC "range" "digits" 
14293 // "delta" "is" PIPE DOT_DOT "in" "renames" ASSIGN "at" "mod" "then" "loop" 
14294 // "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV 
14295 // "rem" EXPON 
14296 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_13(_tokenSet_13_data_,10);
14297 const unsigned long AdaParser::_tokenSet_14_data_[] = { 52428800UL, 536870912UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14298 // "package" "procedure" "function" "generic" 
14299 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_14(_tokenSet_14_data_,10);
14300 const unsigned long AdaParser::_tokenSet_15_data_[] = { 8388800UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14301 // SEMI LPAREN "is" "renames" 
14302 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_15(_tokenSet_15_data_,10);
14303 const unsigned long AdaParser::_tokenSet_16_data_[] = { 52453426UL, 1611238800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14304 // EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" 
14305 // CHAR_STRING "separate" "abstract" "task" "protected" "for" "end" "subtype" 
14306 // "generic" "begin" 
14307 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_16(_tokenSet_16_data_,10);
14308 const unsigned long AdaParser::_tokenSet_17_data_[] = { 52453426UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14309 // EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" 
14310 // "task" "protected" "for" "end" "subtype" "generic" "begin" 
14311 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_17(_tokenSet_17_data_,10);
14312 const unsigned long AdaParser::_tokenSet_18_data_[] = { 53502002UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14313 // EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 
14314 // "function" "task" "protected" "for" "end" "subtype" "generic" "begin" 
14315 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_18(_tokenSet_18_data_,10);
14316 const unsigned long AdaParser::_tokenSet_19_data_[] = { 8392896UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14317 // SEMI LPAREN DOT "is" "in" "renames" "when" "do" 
14318 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_19(_tokenSet_19_data_,10);
14319 const unsigned long AdaParser::_tokenSet_20_data_[] = { 8388800UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14320 // SEMI LPAREN "is" "in" "renames" "when" "do" 
14321 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_20(_tokenSet_20_data_,10);
14322 const unsigned long AdaParser::_tokenSet_21_data_[] = { 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14323 // "end" 
14324 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_21(_tokenSet_21_data_,10);
14325 const unsigned long AdaParser::_tokenSet_22_data_[] = { 53502002UL, 537496976UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14326 // EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 
14327 // "function" CHAR_STRING "separate" "abstract" "task" "protected" "for" 
14328 // "end" "subtype" "generic" 
14329 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_22(_tokenSet_22_data_,10);
14330 const unsigned long AdaParser::_tokenSet_23_data_[] = { 53502002UL, 537496576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14331 // EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 
14332 // "function" "task" "protected" "for" "end" "subtype" "generic" 
14333 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_23(_tokenSet_23_data_,10);
14334 const unsigned long AdaParser::_tokenSet_24_data_[] = { 8388672UL, 67108868UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14335 // SEMI "is" "renames" "when" "do" 
14336 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_24(_tokenSet_24_data_,10);
14337 const unsigned long AdaParser::_tokenSet_25_data_[] = { 8392832UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14338 // LPAREN DOT "is" "return" 
14339 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_25(_tokenSet_25_data_,10);
14340 const unsigned long AdaParser::_tokenSet_26_data_[] = { 8388736UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14341 // LPAREN "is" "return" 
14342 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_26(_tokenSet_26_data_,10);
14343 const unsigned long AdaParser::_tokenSet_27_data_[] = { 8388672UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14344 // SEMI "is" "renames" 
14345 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_27(_tokenSet_27_data_,10);
14346 const unsigned long AdaParser::_tokenSet_28_data_[] = { 2560UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14347 // RPAREN "with" 
14348 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_28(_tokenSet_28_data_,10);
14349 const unsigned long AdaParser::_tokenSet_29_data_[] = { 2816UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14350 // COMMA RPAREN "with" 
14351 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_29(_tokenSet_29_data_,10);
14352 const unsigned long AdaParser::_tokenSet_30_data_[] = { 3840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14353 // COMMA RPAREN RIGHT_SHAFT "with" 
14354 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_30(_tokenSet_30_data_,10);
14355 const unsigned long AdaParser::_tokenSet_31_data_[] = { 268439296UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14356 // COMMA RPAREN RIGHT_SHAFT "with" PIPE 
14357 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_31(_tokenSet_31_data_,10);
14358 const unsigned long AdaParser::_tokenSet_32_data_[] = { 813895488UL, 8193UL, 1071775780UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14359 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 
14360 // "in" ASSIGN "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE GT GE 
14361 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_32(_tokenSet_32_data_,10);
14362 const unsigned long AdaParser::_tokenSet_33_data_[] = { 738234528UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14363 // IDENTIFIER LPAREN DOT TIC "new" "others" DOT_DOT CHARACTER_LITERAL CHAR_STRING 
14364 // "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
14365 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_33(_tokenSet_33_data_,10);
14366 const unsigned long AdaParser::_tokenSet_34_data_[] = { 813895488UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14367 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 
14368 // ASSIGN "then" "loop" "or" "and" "xor" 
14369 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_34(_tokenSet_34_data_,10);
14370 const unsigned long AdaParser::_tokenSet_35_data_[] = { 268439360UL, 8192UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14371 // SEMI COMMA RPAREN RIGHT_SHAFT "with" PIPE ASSIGN "loop" 
14372 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_35(_tokenSet_35_data_,10);
14373 const unsigned long AdaParser::_tokenSet_36_data_[] = { 32768UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14374 // TIC 
14375 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_36(_tokenSet_36_data_,10);
14376 const unsigned long AdaParser::_tokenSet_37_data_[] = { 576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14377 // SEMI RPAREN 
14378 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_37(_tokenSet_37_data_,10);
14379 const unsigned long AdaParser::_tokenSet_38_data_[] = { 524320UL, 16777219UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14380 // IDENTIFIER "access" "in" "out" "aliased" 
14381 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_38(_tokenSet_38_data_,10);
14382 const unsigned long AdaParser::_tokenSet_39_data_[] = { 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14383 // IDENTIFIER 
14384 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_39(_tokenSet_39_data_,10);
14385 const unsigned long AdaParser::_tokenSet_40_data_[] = { 2147484160UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14386 // RPAREN COLON 
14387 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_40(_tokenSet_40_data_,10);
14388 const unsigned long AdaParser::_tokenSet_41_data_[] = { 2368UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14389 // SEMI COMMA "with" ASSIGN 
14390 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_41(_tokenSet_41_data_,10);
14391 const unsigned long AdaParser::_tokenSet_42_data_[] = { 8388800UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14392 // SEMI LPAREN "is" "return" 
14393 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_42(_tokenSet_42_data_,10);
14394 const unsigned long AdaParser::_tokenSet_43_data_[] = { 813932480UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14395 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" 
14396 // "is" PIPE DOT_DOT "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" 
14397 // EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" EXPON 
14398 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_43(_tokenSet_43_data_,10);
14399 const unsigned long AdaParser::_tokenSet_44_data_[] = { 201326752UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14400 // IDENTIFIER LPAREN "new" "others" CHARACTER_LITERAL CHAR_STRING "null" 
14401 // "not" PLUS MINUS "abs" NUMERIC_LIT 
14402 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_44(_tokenSet_44_data_,10);
14403 const unsigned long AdaParser::_tokenSet_45_data_[] = { 1006739360UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14404 // IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "new" 
14405 // "others" PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" 
14406 // "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV 
14407 // "rem" "abs" EXPON NUMERIC_LIT 
14408 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_45(_tokenSet_45_data_,10);
14409 const unsigned long AdaParser::_tokenSet_46_data_[] = { 1006737312UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14410 // IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT DOT TIC "range" "new" "others" 
14411 // PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" "or" "and" 
14412 // "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" "abs" 
14413 // EXPON NUMERIC_LIT 
14414 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_46(_tokenSet_46_data_,10);
14415 const unsigned long AdaParser::_tokenSet_47_data_[] = { 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14416 // RPAREN 
14417 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_47(_tokenSet_47_data_,10);
14418 const unsigned long AdaParser::_tokenSet_48_data_[] = { 0UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14419 // "return" 
14420 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_48(_tokenSet_48_data_,10);
14421 const unsigned long AdaParser::_tokenSet_49_data_[] = { 1048576UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14422 // "private" "end" 
14423 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_49(_tokenSet_49_data_,10);
14424 const unsigned long AdaParser::_tokenSet_50_data_[] = { 32UL, 23068672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14425 // IDENTIFIER "constant" "array" "aliased" 
14426 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_50(_tokenSet_50_data_,10);
14427 const unsigned long AdaParser::_tokenSet_51_data_[] = { 495840UL, 6299648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14428 // IDENTIFIER SEMI LPAREN DOT TIC "range" "digits" "delta" ASSIGN "constant" 
14429 // "array" 
14430 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_51(_tokenSet_51_data_,10);
14431 const unsigned long AdaParser::_tokenSet_52_data_[] = { 8388672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14432 // SEMI "is" 
14433 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_52(_tokenSet_52_data_,10);
14434 const unsigned long AdaParser::_tokenSet_53_data_[] = { 68157504UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14435 // SEMI "private" "new" "null" "record" "abstract" "tagged" "limited" 
14436 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_53(_tokenSet_53_data_,10);
14437 const unsigned long AdaParser::_tokenSet_54_data_[] = { 51380272UL, 114688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14438 // "pragma" IDENTIFIER "private" "procedure" "function" "entry" "for" "end" 
14439 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_54(_tokenSet_54_data_,10);
14440 const unsigned long AdaParser::_tokenSet_55_data_[] = { 192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14441 // SEMI LPAREN 
14442 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_55(_tokenSet_55_data_,10);
14443 const unsigned long AdaParser::_tokenSet_56_data_[] = { 496256UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14444 // LPAREN RPAREN DOT TIC "range" "digits" "delta" "loop" 
14445 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_56(_tokenSet_56_data_,10);
14446 const unsigned long AdaParser::_tokenSet_57_data_[] = { 512UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14447 // RPAREN "loop" 
14448 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_57(_tokenSet_57_data_,10);
14449 const unsigned long AdaParser::_tokenSet_58_data_[] = { 2880UL, 8192UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14450 // SEMI COMMA RPAREN "with" ASSIGN "loop" 
14451 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_58(_tokenSet_58_data_,10);
14452 const unsigned long AdaParser::_tokenSet_59_data_[] = { 48UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14453 // "pragma" IDENTIFIER "end" 
14454 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_59(_tokenSet_59_data_,10);
14455 const unsigned long AdaParser::_tokenSet_60_data_[] = { 50331664UL, 49152UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14456 // "pragma" "procedure" "function" "entry" "for" 
14457 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_60(_tokenSet_60_data_,10);
14458 const unsigned long AdaParser::_tokenSet_61_data_[] = { 50331696UL, 100777984UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14459 // "pragma" IDENTIFIER "procedure" "function" "entry" "for" "end" "case" 
14460 // "when" 
14461 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_61(_tokenSet_61_data_,10);
14462 const unsigned long AdaParser::_tokenSet_62_data_[] = { 64UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14463 // SEMI ASSIGN 
14464 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_62(_tokenSet_62_data_,10);
14465 const unsigned long AdaParser::_tokenSet_63_data_[] = { 1048576UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14466 // "private" "null" "record" "abstract" "tagged" "limited" 
14467 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_63(_tokenSet_63_data_,10);
14468 const unsigned long AdaParser::_tokenSet_64_data_[] = { 1048688UL, 436207712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14469 // "pragma" IDENTIFIER SEMI "private" "null" "record" "case" "tagged" "limited" 
14470 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_64(_tokenSet_64_data_,10);
14471 const unsigned long AdaParser::_tokenSet_65_data_[] = { 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14472 // "use" 
14473 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_65(_tokenSet_65_data_,10);
14474 const unsigned long AdaParser::_tokenSet_66_data_[] = { 32UL, 4194304UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14475 // IDENTIFIER "array" 
14476 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_66(_tokenSet_66_data_,10);
14477 const unsigned long AdaParser::_tokenSet_67_data_[] = { 496512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14478 // LPAREN COMMA RPAREN DOT TIC "range" "digits" "delta" 
14479 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_67(_tokenSet_67_data_,10);
14480 const unsigned long AdaParser::_tokenSet_68_data_[] = { 268436480UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14481 // RIGHT_SHAFT PIPE 
14482 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_68(_tokenSet_68_data_,10);
14483 const unsigned long AdaParser::_tokenSet_69_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14484 // "procedure" "function" 
14485 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_69(_tokenSet_69_data_,10);
14486 const unsigned long AdaParser::_tokenSet_70_data_[] = { 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14487 // "new" 
14488 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_70(_tokenSet_70_data_,10);
14489 const unsigned long AdaParser::_tokenSet_71_data_[] = { 1048576UL, 96UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14490 // "private" "null" "record" 
14491 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_71(_tokenSet_71_data_,10);
14492 const unsigned long AdaParser::_tokenSet_72_data_[] = { 0UL, 67174400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14493 // "end" "when" 
14494 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_72(_tokenSet_72_data_,10);
14495 const unsigned long AdaParser::_tokenSet_73_data_[] = { 0UL, 100728832UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14496 // "end" "case" "when" 
14497 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_73(_tokenSet_73_data_,10);
14498 const unsigned long AdaParser::_tokenSet_74_data_[] = { 0UL, 33554432UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14499 // "case" 
14500 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_74(_tokenSet_74_data_,10);
14501 const unsigned long AdaParser::_tokenSet_75_data_[] = { 8388608UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14502 // "is" 
14503 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_75(_tokenSet_75_data_,10);
14504 const unsigned long AdaParser::_tokenSet_76_data_[] = { 1024UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14505 // RIGHT_SHAFT 
14506 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_76(_tokenSet_76_data_,10);
14507 const unsigned long AdaParser::_tokenSet_77_data_[] = { 738300064UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14508 // IDENTIFIER LPAREN DOT TIC "range" "new" "others" DOT_DOT CHARACTER_LITERAL 
14509 // CHAR_STRING "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" 
14510 // EXPON NUMERIC_LIT 
14511 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_77(_tokenSet_77_data_,10);
14512 const unsigned long AdaParser::_tokenSet_78_data_[] = { 469800096UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14513 // IDENTIFIER LPAREN RIGHT_SHAFT DOT TIC "new" "others" PIPE "in" CHARACTER_LITERAL 
14514 // CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 
14515 // MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 
14516 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_78(_tokenSet_78_data_,10);
14517 const unsigned long AdaParser::_tokenSet_79_data_[] = { 52428800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14518 // "package" "procedure" "function" 
14519 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_79(_tokenSet_79_data_,10);
14520 const unsigned long AdaParser::_tokenSet_80_data_[] = { 52455472UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14521 // "pragma" IDENTIFIER "with" "use" "type" "package" "procedure" "function" 
14522 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_80(_tokenSet_80_data_,10);
14523 const unsigned long AdaParser::_tokenSet_81_data_[] = { 1048576UL, 402653440UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14524 // "private" "abstract" "tagged" "limited" 
14525 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_81(_tokenSet_81_data_,10);
14526 const unsigned long AdaParser::_tokenSet_82_data_[] = { 1048640UL, 402653184UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14527 // SEMI "private" "tagged" "limited" 
14528 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_82(_tokenSet_82_data_,10);
14529 const unsigned long AdaParser::_tokenSet_83_data_[] = { 0UL, 1073807360UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14530 // "end" "begin" 
14531 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_83(_tokenSet_83_data_,10);
14532 const unsigned long AdaParser::_tokenSet_84_data_[] = { 52453424UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14533 // "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" "task" 
14534 // "protected" "for" "end" "subtype" "generic" "begin" 
14535 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_84(_tokenSet_84_data_,10);
14536 const unsigned long AdaParser::_tokenSet_85_data_[] = { 52453424UL, 1611254912UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14537 // "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" "separate" 
14538 // "task" "protected" "entry" "for" "end" "subtype" "generic" "begin" 
14539 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_85(_tokenSet_85_data_,10);
14540 const unsigned long AdaParser::_tokenSet_86_data_[] = { 50331664UL, 81920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14541 // "pragma" "procedure" "function" "entry" "end" 
14542 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_86(_tokenSet_86_data_,10);
14543 const unsigned long AdaParser::_tokenSet_87_data_[] = { 0UL, 68222976UL, 24UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14544 // "end" "exception" "when" "elsif" "else" 
14545 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_87(_tokenSet_87_data_,10);
14546 const unsigned long AdaParser::_tokenSet_88_data_[] = { 37056UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14547 // SEMI LPAREN DOT TIC ASSIGN 
14548 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_88(_tokenSet_88_data_,10);
14549 const unsigned long AdaParser::_tokenSet_89_data_[] = { 48UL, 3323036192UL, 1814398UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14550 // "pragma" IDENTIFIER "null" "return" "for" "end" "exception" "case" "when" 
14551 // "begin" LT_LT "if" "then" "elsif" "else" "loop" "while" "declare" "exit" 
14552 // "goto" "accept" "delay" "select" "abort" "or" "raise" "requeue" 
14553 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_89(_tokenSet_89_data_,10);
14554 const unsigned long AdaParser::_tokenSet_90_data_[] = { 32UL, 1107329568UL, 1683298UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14555 // IDENTIFIER "null" "return" "for" "case" "begin" "if" "loop" "while" 
14556 // "declare" "exit" "goto" "accept" "delay" "select" "abort" "raise" "requeue" 
14557 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_90(_tokenSet_90_data_,10);
14558 const unsigned long AdaParser::_tokenSet_91_data_[] = { 67145952UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14559 // IDENTIFIER SEMI LPAREN DOT TIC "new" CHARACTER_LITERAL CHAR_STRING "null" 
14560 // "until" "not" PLUS MINUS "abs" NUMERIC_LIT 
14561 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_91(_tokenSet_91_data_,10);
14562 const unsigned long AdaParser::_tokenSet_92_data_[] = { 0UL, 67108864UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14563 // "when" "accept" "delay" "terminate" 
14564 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_92(_tokenSet_92_data_,10);
14565 const unsigned long AdaParser::_tokenSet_93_data_[] = { 67109088UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14566 // IDENTIFIER SEMI LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "until" 
14567 // "not" PLUS MINUS "abs" NUMERIC_LIT 
14568 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_93(_tokenSet_93_data_,10);
14569 const unsigned long AdaParser::_tokenSet_94_data_[] = { 37056UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14570 // SEMI LPAREN DOT TIC 
14571 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_94(_tokenSet_94_data_,10);
14572 const unsigned long AdaParser::_tokenSet_95_data_[] = { 96UL, 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14573 // IDENTIFIER SEMI CHAR_STRING 
14574 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_95(_tokenSet_95_data_,10);
14575 const unsigned long AdaParser::_tokenSet_96_data_[] = { 0UL, 1073774592UL, 352UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14576 // "for" "begin" "loop" "while" "declare" 
14577 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_96(_tokenSet_96_data_,10);
14578 const unsigned long AdaParser::_tokenSet_97_data_[] = { 0UL, 65536UL, 24UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14579 // "end" "elsif" "else" 
14580 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_97(_tokenSet_97_data_,10);
14581 const unsigned long AdaParser::_tokenSet_98_data_[] = { 0UL, 65536UL, 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14582 // "end" "else" 
14583 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_98(_tokenSet_98_data_,10);
14584 const unsigned long AdaParser::_tokenSet_99_data_[] = { 8389696UL, 0UL, 36UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14585 // SEMI RIGHT_SHAFT "is" "then" "loop" 
14586 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_99(_tokenSet_99_data_,10);
14587 const unsigned long AdaParser::_tokenSet_100_data_[] = { 0UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14588 // "loop" 
14589 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_100(_tokenSet_100_data_,10);
14590 const unsigned long AdaParser::_tokenSet_101_data_[] = { 0UL, 1073741824UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14591 // "begin" 
14592 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_101(_tokenSet_101_data_,10);
14593 const unsigned long AdaParser::_tokenSet_102_data_[] = { 64UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14594 // SEMI "when" 
14595 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_102(_tokenSet_102_data_,10);
14596 const unsigned long AdaParser::_tokenSet_103_data_[] = { 0UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14597 // "when" 
14598 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_103(_tokenSet_103_data_,10);
14599 const unsigned long AdaParser::_tokenSet_104_data_[] = { 128UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14600 // LPAREN "when" 
14601 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_104(_tokenSet_104_data_,10);
14602 const unsigned long AdaParser::_tokenSet_105_data_[] = { 48UL, 3254813216UL, 1814390UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14603 // "pragma" IDENTIFIER "null" "return" "for" "case" "begin" LT_LT "if" 
14604 // "then" "else" "loop" "while" "declare" "exit" "goto" "accept" "delay" 
14605 // "select" "abort" "or" "raise" "requeue" 
14606 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_105(_tokenSet_105_data_,10);
14607 const unsigned long AdaParser::_tokenSet_106_data_[] = { 192UL, 0UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14608 // SEMI LPAREN "do" 
14609 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_106(_tokenSet_106_data_,10);
14610 const unsigned long AdaParser::_tokenSet_107_data_[] = { 0UL, 0UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14611 // "then" 
14612 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_107(_tokenSet_107_data_,10);
14613 const unsigned long AdaParser::_tokenSet_108_data_[] = { 0UL, 0UL, 131088UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14614 // "else" "or" 
14615 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_108(_tokenSet_108_data_,10);
14616 const unsigned long AdaParser::_tokenSet_109_data_[] = { 0UL, 65536UL, 131088UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14617 // "end" "else" "or" 
14618 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_109(_tokenSet_109_data_,10);
14619 const unsigned long AdaParser::_tokenSet_110_data_[] = { 0UL, 65536UL, 131092UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14620 // "end" "then" "else" "or" 
14621 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_110(_tokenSet_110_data_,10);
14622 const unsigned long AdaParser::_tokenSet_111_data_[] = { 0UL, 0UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14623 // "accept" "delay" "terminate" 
14624 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_111(_tokenSet_111_data_,10);
14625 const unsigned long AdaParser::_tokenSet_112_data_[] = { 134217760UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14626 // IDENTIFIER "others" 
14627 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_112(_tokenSet_112_data_,10);
14628 const unsigned long AdaParser::_tokenSet_113_data_[] = { 813895490UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14629 // EOF SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE 
14630 // DOT_DOT "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" EQ NE 
14631 // LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" EXPON 
14632 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_113(_tokenSet_113_data_,10);
14633 const unsigned long AdaParser::_tokenSet_114_data_[] = { 813932352UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14634 // SEMI COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" "is" PIPE 
14635 // DOT_DOT ASSIGN "then" "loop" "or" "and" "xor" 
14636 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_114(_tokenSet_114_data_,10);
14637 const unsigned long AdaParser::_tokenSet_115_data_[] = { 813895488UL, 8193UL, 4293001252UL, 1UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14638 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 
14639 // "in" ASSIGN "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE GT GE 
14640 // PLUS MINUS CONCAT 
14641 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_115(_tokenSet_115_data_,10);
14642 const unsigned long AdaParser::_tokenSet_116_data_[] = { 813895488UL, 270337UL, 4293001252UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14643 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 
14644 // "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE 
14645 // GT GE PLUS MINUS CONCAT STAR DIV "rem" 
14646 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_116(_tokenSet_116_data_,10);
14647 const unsigned long AdaParser::_tokenSet_117_data_[] = { 813895488UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
14648 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 
14649 // "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE 
14650 // GT GE PLUS MINUS CONCAT STAR DIV "rem" EXPON 
14651 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_117(_tokenSet_117_data_,10);
14652 
14653 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:43 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003