KDevelop API Documentation

languages/ada/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.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Oct 19 08:01:41 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003