KDevelop API Documentation

languages/ada/AdaStoreWalker.cpp

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