KDevelop API Documentation

AdaTreeParserSuper.cpp

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