KDevelop API Documentation

languages/ada/AdaParser.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "ada.g" -> "AdaParser.cpp"$ */ 00002 #include "AdaParser.hpp" 00003 #include <antlr/NoViableAltException.hpp> 00004 #include <antlr/SemanticException.hpp> 00005 #include <antlr/ASTFactory.hpp> 00006 #line 1 "ada.g" 00007 #line 8 "AdaParser.cpp" 00008 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k) 00009 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k) 00010 { 00011 } 00012 00013 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf) 00014 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2) 00015 { 00016 } 00017 00018 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k) 00019 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k) 00020 { 00021 } 00022 00023 AdaParser::AdaParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer) 00024 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2) 00025 { 00026 } 00027 00028 AdaParser::AdaParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state) 00029 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2) 00030 { 00031 } 00032 00033 void AdaParser::compilation_unit() { 00034 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00035 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00036 RefAdaAST compilation_unit_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00037 00038 try { // for error handling 00039 context_items_opt(); 00040 if (inputState->guessing==0) { 00041 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00042 } 00043 { 00044 switch ( LA(1)) { 00045 case PRIVATE: 00046 case PACKAGE: 00047 case PROCEDURE: 00048 case FUNCTION: 00049 case GENERIC: 00050 { 00051 library_item(); 00052 if (inputState->guessing==0) { 00053 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00054 } 00055 break; 00056 } 00057 case SEPARATE: 00058 { 00059 subunit(); 00060 if (inputState->guessing==0) { 00061 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00062 } 00063 break; 00064 } 00065 default: 00066 { 00067 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00068 } 00069 } 00070 } 00071 { // ( ... )* 00072 for (;;) { 00073 if ((LA(1) == PRAGMA)) { 00074 pragma(); 00075 if (inputState->guessing==0) { 00076 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00077 } 00078 } 00079 else { 00080 goto _loop4; 00081 } 00082 00083 } 00084 _loop4:; 00085 } // ( ... )* 00086 compilation_unit_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00087 } 00088 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00089 if( inputState->guessing == 0 ) { 00090 reportError(ex); 00091 consume(); 00092 consumeUntil(_tokenSet_0); 00093 } else { 00094 throw; 00095 } 00096 } 00097 returnAST = compilation_unit_AST; 00098 } 00099 00100 void AdaParser::context_items_opt() { 00101 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00102 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00103 RefAdaAST context_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00104 00105 try { // for error handling 00106 { // ( ... )* 00107 for (;;) { 00108 if ((LA(1) == PRAGMA)) { 00109 pragma(); 00110 if (inputState->guessing==0) { 00111 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00112 } 00113 } 00114 else { 00115 goto _loop14; 00116 } 00117 00118 } 00119 _loop14:; 00120 } // ( ... )* 00121 { // ( ... )* 00122 for (;;) { 00123 if ((LA(1) == WITH)) { 00124 with_clause(); 00125 if (inputState->guessing==0) { 00126 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00127 } 00128 { // ( ... )* 00129 for (;;) { 00130 switch ( LA(1)) { 00131 case USE: 00132 { 00133 use_clause(); 00134 if (inputState->guessing==0) { 00135 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00136 } 00137 break; 00138 } 00139 case PRAGMA: 00140 { 00141 pragma(); 00142 if (inputState->guessing==0) { 00143 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00144 } 00145 break; 00146 } 00147 default: 00148 { 00149 goto _loop17; 00150 } 00151 } 00152 } 00153 _loop17:; 00154 } // ( ... )* 00155 } 00156 else { 00157 goto _loop18; 00158 } 00159 00160 } 00161 _loop18:; 00162 } // ( ... )* 00163 if ( inputState->guessing==0 ) { 00164 context_items_opt_AST = RefAdaAST(currentAST.root); 00165 #line 86 "ada.g" 00166 context_items_opt_AST = 00167 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CONTEXT_CLAUSE,"CONTEXT_CLAUSE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(context_items_opt_AST.get())))); 00168 #line 169 "AdaParser.cpp" 00169 currentAST.root = context_items_opt_AST; 00170 if ( context_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 00171 context_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 00172 currentAST.child = context_items_opt_AST->getFirstChild(); 00173 else 00174 currentAST.child = context_items_opt_AST; 00175 currentAST.advanceChildToEnd(); 00176 } 00177 context_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00178 } 00179 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00180 if( inputState->guessing == 0 ) { 00181 reportError(ex); 00182 consume(); 00183 consumeUntil(_tokenSet_1); 00184 } else { 00185 throw; 00186 } 00187 } 00188 returnAST = context_items_opt_AST; 00189 } 00190 00191 void AdaParser::library_item() { 00192 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00193 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00194 RefAdaAST library_item_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00195 00196 try { // for error handling 00197 private_opt(); 00198 if (inputState->guessing==0) { 00199 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00200 } 00201 { 00202 switch ( LA(1)) { 00203 case PACKAGE: 00204 { 00205 lib_pkg_spec_or_body(); 00206 if (inputState->guessing==0) { 00207 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00208 } 00209 break; 00210 } 00211 case PROCEDURE: 00212 case FUNCTION: 00213 { 00214 subprog_decl_or_rename_or_inst_or_body(true); 00215 if (inputState->guessing==0) { 00216 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00217 } 00218 break; 00219 } 00220 case GENERIC: 00221 { 00222 generic_decl(true); 00223 if (inputState->guessing==0) { 00224 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00225 } 00226 break; 00227 } 00228 default: 00229 { 00230 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00231 } 00232 } 00233 } 00234 if ( inputState->guessing==0 ) { 00235 library_item_AST = RefAdaAST(currentAST.root); 00236 #line 133 "ada.g" 00237 library_item_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LIBRARY_ITEM,"LIBRARY_ITEM").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(library_item_AST.get())))); 00238 #line 239 "AdaParser.cpp" 00239 currentAST.root = library_item_AST; 00240 if ( library_item_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 00241 library_item_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 00242 currentAST.child = library_item_AST->getFirstChild(); 00243 else 00244 currentAST.child = library_item_AST; 00245 currentAST.advanceChildToEnd(); 00246 } 00247 library_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00248 } 00249 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00250 if( inputState->guessing == 0 ) { 00251 reportError(ex); 00252 consume(); 00253 consumeUntil(_tokenSet_2); 00254 } else { 00255 throw; 00256 } 00257 } 00258 returnAST = library_item_AST; 00259 } 00260 00261 void AdaParser::subunit() { 00262 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00263 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00264 RefAdaAST subunit_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00265 ANTLR_USE_NAMESPACE(antlr)RefToken sep = ANTLR_USE_NAMESPACE(antlr)nullToken; 00266 RefAdaAST sep_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00267 00268 try { // for error handling 00269 sep = LT(1); 00270 if ( inputState->guessing == 0 ) { 00271 sep_AST = astFactory->create(sep); 00272 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(sep_AST.get())); 00273 } 00274 match(SEPARATE); 00275 match(LPAREN); 00276 compound_name(); 00277 if (inputState->guessing==0) { 00278 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00279 } 00280 match(RPAREN); 00281 if ( inputState->guessing==0 ) { 00282 #line 1472 "ada.g" 00283 Set(sep_AST, SUBUNIT); 00284 #line 285 "AdaParser.cpp" 00285 } 00286 { 00287 switch ( LA(1)) { 00288 case PROCEDURE: 00289 case FUNCTION: 00290 { 00291 subprogram_body(); 00292 if (inputState->guessing==0) { 00293 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00294 } 00295 break; 00296 } 00297 case PACKAGE: 00298 { 00299 package_body(); 00300 if (inputState->guessing==0) { 00301 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00302 } 00303 break; 00304 } 00305 case TASK: 00306 { 00307 task_body(); 00308 if (inputState->guessing==0) { 00309 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00310 } 00311 break; 00312 } 00313 case PROTECTED: 00314 { 00315 protected_body(); 00316 if (inputState->guessing==0) { 00317 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00318 } 00319 break; 00320 } 00321 default: 00322 { 00323 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00324 } 00325 } 00326 } 00327 subunit_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00328 } 00329 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00330 if( inputState->guessing == 0 ) { 00331 reportError(ex); 00332 consume(); 00333 consumeUntil(_tokenSet_2); 00334 } else { 00335 throw; 00336 } 00337 } 00338 returnAST = subunit_AST; 00339 } 00340 00341 void AdaParser::pragma() { 00342 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00343 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00344 RefAdaAST pragma_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00345 00346 try { // for error handling 00347 RefAdaAST tmp3_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00348 if ( inputState->guessing == 0 ) { 00349 tmp3_AST = astFactory->create(LT(1)); 00350 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp3_AST.get())); 00351 } 00352 match(PRAGMA); 00353 RefAdaAST tmp4_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00354 if ( inputState->guessing == 0 ) { 00355 tmp4_AST = astFactory->create(LT(1)); 00356 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp4_AST.get())); 00357 } 00358 match(IDENTIFIER); 00359 pragma_args_opt(); 00360 if (inputState->guessing==0) { 00361 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00362 } 00363 match(SEMI); 00364 pragma_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00365 } 00366 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00367 if( inputState->guessing == 0 ) { 00368 reportError(ex); 00369 consume(); 00370 consumeUntil(_tokenSet_3); 00371 } else { 00372 throw; 00373 } 00374 } 00375 returnAST = pragma_AST; 00376 } 00377 00378 void AdaParser::pragma_args_opt() { 00379 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00380 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00381 RefAdaAST pragma_args_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00382 00383 try { // for error handling 00384 { 00385 switch ( LA(1)) { 00386 case LPAREN: 00387 { 00388 match(LPAREN); 00389 pragma_arg(); 00390 if (inputState->guessing==0) { 00391 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00392 } 00393 { // ( ... )* 00394 for (;;) { 00395 if ((LA(1) == COMMA)) { 00396 match(COMMA); 00397 pragma_arg(); 00398 if (inputState->guessing==0) { 00399 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00400 } 00401 } 00402 else { 00403 goto _loop9; 00404 } 00405 00406 } 00407 _loop9:; 00408 } // ( ... )* 00409 match(RPAREN); 00410 break; 00411 } 00412 case SEMI: 00413 { 00414 break; 00415 } 00416 default: 00417 { 00418 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00419 } 00420 } 00421 } 00422 pragma_args_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00423 } 00424 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00425 if( inputState->guessing == 0 ) { 00426 reportError(ex); 00427 consume(); 00428 consumeUntil(_tokenSet_4); 00429 } else { 00430 throw; 00431 } 00432 } 00433 returnAST = pragma_args_opt_AST; 00434 } 00435 00436 void AdaParser::pragma_arg() { 00437 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00438 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00439 RefAdaAST pragma_arg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00440 00441 try { // for error handling 00442 { 00443 if ((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT)) { 00444 RefAdaAST tmp9_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00445 if ( inputState->guessing == 0 ) { 00446 tmp9_AST = astFactory->create(LT(1)); 00447 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp9_AST.get())); 00448 } 00449 match(IDENTIFIER); 00450 RefAdaAST tmp10_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00451 if ( inputState->guessing == 0 ) { 00452 tmp10_AST = astFactory->create(LT(1)); 00453 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp10_AST.get())); 00454 } 00455 match(RIGHT_SHAFT); 00456 } 00457 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 00458 } 00459 else { 00460 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00461 } 00462 00463 } 00464 expression(); 00465 if (inputState->guessing==0) { 00466 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00467 } 00468 pragma_arg_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00469 } 00470 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00471 if( inputState->guessing == 0 ) { 00472 reportError(ex); 00473 consume(); 00474 consumeUntil(_tokenSet_7); 00475 } else { 00476 throw; 00477 } 00478 } 00479 returnAST = pragma_arg_AST; 00480 } 00481 00482 void AdaParser::expression() { 00483 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00484 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00485 RefAdaAST expression_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00486 ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; 00487 RefAdaAST a_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00488 ANTLR_USE_NAMESPACE(antlr)RefToken o = ANTLR_USE_NAMESPACE(antlr)nullToken; 00489 RefAdaAST o_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00490 00491 try { // for error handling 00492 relation(); 00493 if (inputState->guessing==0) { 00494 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00495 } 00496 { // ( ... )* 00497 for (;;) { 00498 switch ( LA(1)) { 00499 case AND: 00500 { 00501 a = LT(1); 00502 if ( inputState->guessing == 0 ) { 00503 a_AST = astFactory->create(a); 00504 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get())); 00505 } 00506 match(AND); 00507 { 00508 switch ( LA(1)) { 00509 case THEN: 00510 { 00511 match(THEN); 00512 if ( inputState->guessing==0 ) { 00513 #line 1392 "ada.g" 00514 Set (a_AST, AND_THEN); 00515 #line 516 "AdaParser.cpp" 00516 } 00517 break; 00518 } 00519 case IDENTIFIER: 00520 case LPAREN: 00521 case NEW: 00522 case CHARACTER_LITERAL: 00523 case CHAR_STRING: 00524 case NuLL: 00525 case NOT: 00526 case PLUS: 00527 case MINUS: 00528 case ABS: 00529 case NUMERIC_LIT: 00530 { 00531 break; 00532 } 00533 default: 00534 { 00535 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00536 } 00537 } 00538 } 00539 relation(); 00540 if (inputState->guessing==0) { 00541 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00542 } 00543 break; 00544 } 00545 case OR: 00546 { 00547 o = LT(1); 00548 if ( inputState->guessing == 0 ) { 00549 o_AST = astFactory->create(o); 00550 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(o_AST.get())); 00551 } 00552 match(OR); 00553 { 00554 switch ( LA(1)) { 00555 case ELSE: 00556 { 00557 match(ELSE); 00558 if ( inputState->guessing==0 ) { 00559 #line 1393 "ada.g" 00560 Set (o_AST, OR_ELSE); 00561 #line 562 "AdaParser.cpp" 00562 } 00563 break; 00564 } 00565 case IDENTIFIER: 00566 case LPAREN: 00567 case NEW: 00568 case CHARACTER_LITERAL: 00569 case CHAR_STRING: 00570 case NuLL: 00571 case NOT: 00572 case PLUS: 00573 case MINUS: 00574 case ABS: 00575 case NUMERIC_LIT: 00576 { 00577 break; 00578 } 00579 default: 00580 { 00581 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00582 } 00583 } 00584 } 00585 relation(); 00586 if (inputState->guessing==0) { 00587 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00588 } 00589 break; 00590 } 00591 case XOR: 00592 { 00593 RefAdaAST tmp13_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00594 if ( inputState->guessing == 0 ) { 00595 tmp13_AST = astFactory->create(LT(1)); 00596 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp13_AST.get())); 00597 } 00598 match(XOR); 00599 relation(); 00600 if (inputState->guessing==0) { 00601 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00602 } 00603 break; 00604 } 00605 default: 00606 { 00607 goto _loop445; 00608 } 00609 } 00610 } 00611 _loop445:; 00612 } // ( ... )* 00613 expression_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00614 } 00615 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00616 if( inputState->guessing == 0 ) { 00617 reportError(ex); 00618 consume(); 00619 consumeUntil(_tokenSet_8); 00620 } else { 00621 throw; 00622 } 00623 } 00624 returnAST = expression_AST; 00625 } 00626 00627 void AdaParser::with_clause() { 00628 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00629 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00630 RefAdaAST with_clause_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00631 ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; 00632 RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00633 00634 try { // for error handling 00635 w = LT(1); 00636 if ( inputState->guessing == 0 ) { 00637 w_AST = astFactory->create(w); 00638 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get())); 00639 } 00640 match(WITH); 00641 c_name_list(); 00642 if (inputState->guessing==0) { 00643 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00644 } 00645 match(SEMI); 00646 if ( inputState->guessing==0 ) { 00647 #line 94 "ada.g" 00648 Set(w_AST, WITH_CLAUSE); 00649 #line 650 "AdaParser.cpp" 00650 } 00651 with_clause_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00652 } 00653 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00654 if( inputState->guessing == 0 ) { 00655 reportError(ex); 00656 consume(); 00657 consumeUntil(_tokenSet_9); 00658 } else { 00659 throw; 00660 } 00661 } 00662 returnAST = with_clause_AST; 00663 } 00664 00665 void AdaParser::use_clause() { 00666 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00667 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00668 RefAdaAST use_clause_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00669 ANTLR_USE_NAMESPACE(antlr)RefToken u = ANTLR_USE_NAMESPACE(antlr)nullToken; 00670 RefAdaAST u_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00671 00672 try { // for error handling 00673 u = LT(1); 00674 if ( inputState->guessing == 0 ) { 00675 u_AST = astFactory->create(u); 00676 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(u_AST.get())); 00677 } 00678 match(USE); 00679 { 00680 switch ( LA(1)) { 00681 case TYPE: 00682 { 00683 match(TYPE); 00684 subtype_mark(); 00685 if (inputState->guessing==0) { 00686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00687 } 00688 { // ( ... )* 00689 for (;;) { 00690 if ((LA(1) == COMMA)) { 00691 match(COMMA); 00692 subtype_mark(); 00693 if (inputState->guessing==0) { 00694 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00695 } 00696 } 00697 else { 00698 goto _loop29; 00699 } 00700 00701 } 00702 _loop29:; 00703 } // ( ... )* 00704 if ( inputState->guessing==0 ) { 00705 #line 108 "ada.g" 00706 Set(u_AST, USE_TYPE_CLAUSE); 00707 #line 708 "AdaParser.cpp" 00708 } 00709 break; 00710 } 00711 case IDENTIFIER: 00712 { 00713 c_name_list(); 00714 if (inputState->guessing==0) { 00715 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00716 } 00717 if ( inputState->guessing==0 ) { 00718 #line 109 "ada.g" 00719 Set(u_AST, USE_CLAUSE); 00720 #line 721 "AdaParser.cpp" 00721 } 00722 break; 00723 } 00724 default: 00725 { 00726 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00727 } 00728 } 00729 } 00730 match(SEMI); 00731 use_clause_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00732 } 00733 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00734 if( inputState->guessing == 0 ) { 00735 reportError(ex); 00736 consume(); 00737 consumeUntil(_tokenSet_10); 00738 } else { 00739 throw; 00740 } 00741 } 00742 returnAST = use_clause_AST; 00743 } 00744 00745 void AdaParser::c_name_list() { 00746 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00747 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00748 RefAdaAST c_name_list_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00749 00750 try { // for error handling 00751 compound_name(); 00752 if (inputState->guessing==0) { 00753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00754 } 00755 { // ( ... )* 00756 for (;;) { 00757 if ((LA(1) == COMMA)) { 00758 match(COMMA); 00759 compound_name(); 00760 if (inputState->guessing==0) { 00761 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00762 } 00763 } 00764 else { 00765 goto _loop22; 00766 } 00767 00768 } 00769 _loop22:; 00770 } // ( ... )* 00771 c_name_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00772 } 00773 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00774 if( inputState->guessing == 0 ) { 00775 reportError(ex); 00776 consume(); 00777 consumeUntil(_tokenSet_4); 00778 } else { 00779 throw; 00780 } 00781 } 00782 returnAST = c_name_list_AST; 00783 } 00784 00785 void AdaParser::compound_name() { 00786 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00787 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00788 RefAdaAST compound_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00789 00790 try { // for error handling 00791 RefAdaAST tmp19_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00792 if ( inputState->guessing == 0 ) { 00793 tmp19_AST = astFactory->create(LT(1)); 00794 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp19_AST.get())); 00795 } 00796 match(IDENTIFIER); 00797 { // ( ... )* 00798 for (;;) { 00799 if ((LA(1) == DOT)) { 00800 RefAdaAST tmp20_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00801 if ( inputState->guessing == 0 ) { 00802 tmp20_AST = astFactory->create(LT(1)); 00803 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp20_AST.get())); 00804 } 00805 match(DOT); 00806 RefAdaAST tmp21_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00807 if ( inputState->guessing == 0 ) { 00808 tmp21_AST = astFactory->create(LT(1)); 00809 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp21_AST.get())); 00810 } 00811 match(IDENTIFIER); 00812 } 00813 else { 00814 goto _loop25; 00815 } 00816 00817 } 00818 _loop25:; 00819 } // ( ... )* 00820 compound_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00821 } 00822 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00823 if( inputState->guessing == 0 ) { 00824 reportError(ex); 00825 consume(); 00826 consumeUntil(_tokenSet_11); 00827 } else { 00828 throw; 00829 } 00830 } 00831 returnAST = compound_name_AST; 00832 } 00833 00834 void AdaParser::subtype_mark() { 00835 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00836 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00837 RefAdaAST subtype_mark_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00838 00839 try { // for error handling 00840 compound_name(); 00841 if (inputState->guessing==0) { 00842 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00843 } 00844 { 00845 switch ( LA(1)) { 00846 case TIC: 00847 { 00848 RefAdaAST tmp22_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00849 if ( inputState->guessing == 0 ) { 00850 tmp22_AST = astFactory->create(LT(1)); 00851 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp22_AST.get())); 00852 } 00853 match(TIC); 00854 attribute_id(); 00855 if (inputState->guessing==0) { 00856 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 00857 } 00858 break; 00859 } 00860 case SEMI: 00861 case LPAREN: 00862 case COMMA: 00863 case RPAREN: 00864 case RIGHT_SHAFT: 00865 case WITH: 00866 case USE: 00867 case RANGE: 00868 case DIGITS: 00869 case DELTA: 00870 case IS: 00871 case PIPE: 00872 case DOT_DOT: 00873 case RENAMES: 00874 case ASSIGN: 00875 case AT: 00876 case THEN: 00877 case LOOP: 00878 case OR: 00879 case AND: 00880 case XOR: 00881 { 00882 break; 00883 } 00884 default: 00885 { 00886 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00887 } 00888 } 00889 } 00890 subtype_mark_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00891 } 00892 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00893 if( inputState->guessing == 0 ) { 00894 reportError(ex); 00895 consume(); 00896 consumeUntil(_tokenSet_12); 00897 } else { 00898 throw; 00899 } 00900 } 00901 returnAST = subtype_mark_AST; 00902 } 00903 00904 void AdaParser::attribute_id() { 00905 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00906 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00907 RefAdaAST attribute_id_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00908 00909 try { // for error handling 00910 switch ( LA(1)) { 00911 case RANGE: 00912 { 00913 RefAdaAST tmp23_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00914 if ( inputState->guessing == 0 ) { 00915 tmp23_AST = astFactory->create(LT(1)); 00916 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp23_AST.get())); 00917 } 00918 match(RANGE); 00919 attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00920 break; 00921 } 00922 case DIGITS: 00923 { 00924 RefAdaAST tmp24_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00925 if ( inputState->guessing == 0 ) { 00926 tmp24_AST = astFactory->create(LT(1)); 00927 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp24_AST.get())); 00928 } 00929 match(DIGITS); 00930 attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00931 break; 00932 } 00933 case DELTA: 00934 { 00935 RefAdaAST tmp25_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00936 if ( inputState->guessing == 0 ) { 00937 tmp25_AST = astFactory->create(LT(1)); 00938 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp25_AST.get())); 00939 } 00940 match(DELTA); 00941 attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00942 break; 00943 } 00944 case ACCESS: 00945 { 00946 RefAdaAST tmp26_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00947 if ( inputState->guessing == 0 ) { 00948 tmp26_AST = astFactory->create(LT(1)); 00949 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp26_AST.get())); 00950 } 00951 match(ACCESS); 00952 attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00953 break; 00954 } 00955 case IDENTIFIER: 00956 { 00957 RefAdaAST tmp27_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00958 if ( inputState->guessing == 0 ) { 00959 tmp27_AST = astFactory->create(LT(1)); 00960 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp27_AST.get())); 00961 } 00962 match(IDENTIFIER); 00963 attribute_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 00964 break; 00965 } 00966 default: 00967 { 00968 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 00969 } 00970 } 00971 } 00972 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 00973 if( inputState->guessing == 0 ) { 00974 reportError(ex); 00975 consume(); 00976 consumeUntil(_tokenSet_13); 00977 } else { 00978 throw; 00979 } 00980 } 00981 returnAST = attribute_id_AST; 00982 } 00983 00984 void AdaParser::private_opt() { 00985 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00986 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 00987 RefAdaAST private_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00988 00989 try { // for error handling 00990 { 00991 switch ( LA(1)) { 00992 case PRIVATE: 00993 { 00994 RefAdaAST tmp28_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 00995 if ( inputState->guessing == 0 ) { 00996 tmp28_AST = astFactory->create(LT(1)); 00997 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp28_AST.get())); 00998 } 00999 match(PRIVATE); 01000 break; 01001 } 01002 case PACKAGE: 01003 case PROCEDURE: 01004 case FUNCTION: 01005 case GENERIC: 01006 { 01007 break; 01008 } 01009 default: 01010 { 01011 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01012 } 01013 } 01014 } 01015 if ( inputState->guessing==0 ) { 01016 private_opt_AST = RefAdaAST(currentAST.root); 01017 #line 137 "ada.g" 01018 private_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(private_opt_AST.get())))); 01019 #line 1020 "AdaParser.cpp" 01020 currentAST.root = private_opt_AST; 01021 if ( private_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 01022 private_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 01023 currentAST.child = private_opt_AST->getFirstChild(); 01024 else 01025 currentAST.child = private_opt_AST; 01026 currentAST.advanceChildToEnd(); 01027 } 01028 private_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01029 } 01030 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01031 if( inputState->guessing == 0 ) { 01032 reportError(ex); 01033 consume(); 01034 consumeUntil(_tokenSet_14); 01035 } else { 01036 throw; 01037 } 01038 } 01039 returnAST = private_opt_AST; 01040 } 01041 01042 void AdaParser::lib_pkg_spec_or_body() { 01043 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01044 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01045 RefAdaAST lib_pkg_spec_or_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01046 ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken; 01047 RefAdaAST pkg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01048 01049 try { // for error handling 01050 pkg = LT(1); 01051 if ( inputState->guessing == 0 ) { 01052 pkg_AST = astFactory->create(pkg); 01053 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get())); 01054 } 01055 match(PACKAGE); 01056 { 01057 switch ( LA(1)) { 01058 case BODY: 01059 { 01060 match(BODY); 01061 def_id(true); 01062 if (inputState->guessing==0) { 01063 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01064 } 01065 match(IS); 01066 pkg_body_part(); 01067 if (inputState->guessing==0) { 01068 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01069 } 01070 end_id_opt(); 01071 match(SEMI); 01072 if ( inputState->guessing==0 ) { 01073 #line 143 "ada.g" 01074 Set(pkg_AST, PACKAGE_BODY); 01075 #line 1076 "AdaParser.cpp" 01076 } 01077 break; 01078 } 01079 case IDENTIFIER: 01080 { 01081 def_id(true); 01082 if (inputState->guessing==0) { 01083 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01084 } 01085 spec_decl_part(pkg_AST); 01086 if (inputState->guessing==0) { 01087 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01088 } 01089 break; 01090 } 01091 default: 01092 { 01093 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01094 } 01095 } 01096 } 01097 lib_pkg_spec_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01098 } 01099 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01100 if( inputState->guessing == 0 ) { 01101 reportError(ex); 01102 consume(); 01103 consumeUntil(_tokenSet_2); 01104 } else { 01105 throw; 01106 } 01107 } 01108 returnAST = lib_pkg_spec_or_body_AST; 01109 } 01110 01111 void AdaParser::subprog_decl_or_rename_or_inst_or_body( 01112 bool lib_level 01113 ) { 01114 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01115 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01116 RefAdaAST subprog_decl_or_rename_or_inst_or_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01117 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 01118 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01119 ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; 01120 RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01121 #line 930 "ada.g" 01122 RefAdaAST t; 01123 #line 1124 "AdaParser.cpp" 01124 01125 try { // for error handling 01126 switch ( LA(1)) { 01127 case PROCEDURE: 01128 { 01129 p = LT(1); 01130 if ( inputState->guessing == 0 ) { 01131 p_AST = astFactory->create(p); 01132 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 01133 } 01134 match(PROCEDURE); 01135 def_id(lib_level); 01136 if (inputState->guessing==0) { 01137 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01138 } 01139 { 01140 if ((LA(1) == IS) && (LA(2) == NEW)) { 01141 generic_subp_inst(); 01142 if (inputState->guessing==0) { 01143 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01144 } 01145 if ( inputState->guessing==0 ) { 01146 #line 934 "ada.g" 01147 Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION); 01148 #line 1149 "AdaParser.cpp" 01149 } 01150 } 01151 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_16.member(LA(2)))) { 01152 formal_part_opt(); 01153 if (inputState->guessing==0) { 01154 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01155 } 01156 { 01157 switch ( LA(1)) { 01158 case RENAMES: 01159 { 01160 renames(); 01161 if (inputState->guessing==0) { 01162 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01163 } 01164 if ( inputState->guessing==0 ) { 01165 #line 936 "ada.g" 01166 Set(p_AST, PROCEDURE_RENAMING_DECLARATION); 01167 #line 1168 "AdaParser.cpp" 01168 } 01169 break; 01170 } 01171 case IS: 01172 { 01173 match(IS); 01174 { 01175 switch ( LA(1)) { 01176 case SEPARATE: 01177 case ABSTRACT: 01178 { 01179 separate_or_abstract(p_AST); 01180 if (inputState->guessing==0) { 01181 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01182 } 01183 break; 01184 } 01185 case PRAGMA: 01186 case IDENTIFIER: 01187 case USE: 01188 case TYPE: 01189 case PACKAGE: 01190 case PROCEDURE: 01191 case FUNCTION: 01192 case TASK: 01193 case PROTECTED: 01194 case FOR: 01195 case SUBTYPE: 01196 case GENERIC: 01197 case BEGIN: 01198 { 01199 body_part(); 01200 if (inputState->guessing==0) { 01201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01202 } 01203 if ( inputState->guessing==0 ) { 01204 #line 938 "ada.g" 01205 Set(p_AST, PROCEDURE_BODY); 01206 #line 1207 "AdaParser.cpp" 01207 } 01208 break; 01209 } 01210 default: 01211 { 01212 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01213 } 01214 } 01215 } 01216 break; 01217 } 01218 case SEMI: 01219 { 01220 if ( inputState->guessing==0 ) { 01221 #line 940 "ada.g" 01222 pop_def_id(); 01223 Set(p_AST, PROCEDURE_DECLARATION); 01224 #line 1225 "AdaParser.cpp" 01225 } 01226 break; 01227 } 01228 default: 01229 { 01230 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01231 } 01232 } 01233 } 01234 match(SEMI); 01235 } 01236 else { 01237 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01238 } 01239 01240 } 01241 subprog_decl_or_rename_or_inst_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01242 break; 01243 } 01244 case FUNCTION: 01245 { 01246 f = LT(1); 01247 if ( inputState->guessing == 0 ) { 01248 f_AST = astFactory->create(f); 01249 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get())); 01250 } 01251 match(FUNCTION); 01252 def_designator(lib_level); 01253 if (inputState->guessing==0) { 01254 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01255 } 01256 { 01257 switch ( LA(1)) { 01258 case IS: 01259 { 01260 generic_subp_inst(); 01261 if (inputState->guessing==0) { 01262 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01263 } 01264 if ( inputState->guessing==0 ) { 01265 #line 947 "ada.g" 01266 Set(f_AST, GENERIC_FUNCTION_INSTANTIATION); 01267 #line 1268 "AdaParser.cpp" 01268 } 01269 break; 01270 } 01271 case LPAREN: 01272 case RETURN: 01273 { 01274 function_tail(); 01275 if (inputState->guessing==0) { 01276 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01277 } 01278 { 01279 switch ( LA(1)) { 01280 case RENAMES: 01281 { 01282 renames(); 01283 if (inputState->guessing==0) { 01284 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01285 } 01286 if ( inputState->guessing==0 ) { 01287 #line 949 "ada.g" 01288 Set(f_AST, FUNCTION_RENAMING_DECLARATION); 01289 #line 1290 "AdaParser.cpp" 01290 } 01291 break; 01292 } 01293 case IS: 01294 { 01295 match(IS); 01296 { 01297 switch ( LA(1)) { 01298 case SEPARATE: 01299 case ABSTRACT: 01300 { 01301 separate_or_abstract(f_AST); 01302 if (inputState->guessing==0) { 01303 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01304 } 01305 break; 01306 } 01307 case PRAGMA: 01308 case IDENTIFIER: 01309 case USE: 01310 case TYPE: 01311 case PACKAGE: 01312 case PROCEDURE: 01313 case FUNCTION: 01314 case TASK: 01315 case PROTECTED: 01316 case FOR: 01317 case SUBTYPE: 01318 case GENERIC: 01319 case BEGIN: 01320 { 01321 body_part(); 01322 if (inputState->guessing==0) { 01323 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01324 } 01325 if ( inputState->guessing==0 ) { 01326 #line 951 "ada.g" 01327 Set(f_AST, FUNCTION_BODY); 01328 #line 1329 "AdaParser.cpp" 01329 } 01330 break; 01331 } 01332 default: 01333 { 01334 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01335 } 01336 } 01337 } 01338 break; 01339 } 01340 case SEMI: 01341 { 01342 if ( inputState->guessing==0 ) { 01343 #line 953 "ada.g" 01344 pop_def_id(); 01345 Set(f_AST, FUNCTION_DECLARATION); 01346 #line 1347 "AdaParser.cpp" 01347 } 01348 break; 01349 } 01350 default: 01351 { 01352 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01353 } 01354 } 01355 } 01356 match(SEMI); 01357 break; 01358 } 01359 default: 01360 { 01361 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01362 } 01363 } 01364 } 01365 subprog_decl_or_rename_or_inst_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01366 break; 01367 } 01368 default: 01369 { 01370 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01371 } 01372 } 01373 } 01374 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01375 if( inputState->guessing == 0 ) { 01376 reportError(ex); 01377 consume(); 01378 consumeUntil(_tokenSet_17); 01379 } else { 01380 throw; 01381 } 01382 } 01383 returnAST = subprog_decl_or_rename_or_inst_or_body_AST; 01384 } 01385 01386 void AdaParser::generic_decl( 01387 bool lib_level 01388 ) { 01389 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01390 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01391 RefAdaAST generic_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01392 ANTLR_USE_NAMESPACE(antlr)RefToken g = ANTLR_USE_NAMESPACE(antlr)nullToken; 01393 RefAdaAST g_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01394 01395 try { // for error handling 01396 g = LT(1); 01397 if ( inputState->guessing == 0 ) { 01398 g_AST = astFactory->create(g); 01399 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(g_AST.get())); 01400 } 01401 match(GENERIC); 01402 generic_formal_part_opt(); 01403 if (inputState->guessing==0) { 01404 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01405 } 01406 { 01407 switch ( LA(1)) { 01408 case PACKAGE: 01409 { 01410 match(PACKAGE); 01411 def_id(lib_level); 01412 if (inputState->guessing==0) { 01413 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01414 } 01415 { 01416 switch ( LA(1)) { 01417 case RENAMES: 01418 { 01419 renames(); 01420 if (inputState->guessing==0) { 01421 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01422 } 01423 if ( inputState->guessing==0 ) { 01424 #line 851 "ada.g" 01425 Set(g_AST, GENERIC_PACKAGE_RENAMING); 01426 #line 1427 "AdaParser.cpp" 01427 } 01428 break; 01429 } 01430 case IS: 01431 { 01432 match(IS); 01433 pkg_spec_part(); 01434 if (inputState->guessing==0) { 01435 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01436 } 01437 if ( inputState->guessing==0 ) { 01438 #line 852 "ada.g" 01439 Set(g_AST, GENERIC_PACKAGE_DECLARATION); 01440 #line 1441 "AdaParser.cpp" 01441 } 01442 break; 01443 } 01444 default: 01445 { 01446 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01447 } 01448 } 01449 } 01450 break; 01451 } 01452 case PROCEDURE: 01453 { 01454 match(PROCEDURE); 01455 def_id(lib_level); 01456 if (inputState->guessing==0) { 01457 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01458 } 01459 formal_part_opt(); 01460 if (inputState->guessing==0) { 01461 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01462 } 01463 { 01464 switch ( LA(1)) { 01465 case RENAMES: 01466 { 01467 renames(); 01468 if (inputState->guessing==0) { 01469 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01470 } 01471 if ( inputState->guessing==0 ) { 01472 #line 855 "ada.g" 01473 Set(g_AST, GENERIC_PROCEDURE_RENAMING); 01474 #line 1475 "AdaParser.cpp" 01475 } 01476 break; 01477 } 01478 case SEMI: 01479 { 01480 if ( inputState->guessing==0 ) { 01481 #line 858 "ada.g" 01482 Set(g_AST, GENERIC_PROCEDURE_DECLARATION); pop_def_id(); 01483 #line 1484 "AdaParser.cpp" 01484 } 01485 break; 01486 } 01487 default: 01488 { 01489 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01490 } 01491 } 01492 } 01493 break; 01494 } 01495 case FUNCTION: 01496 { 01497 match(FUNCTION); 01498 def_designator(lib_level); 01499 if (inputState->guessing==0) { 01500 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01501 } 01502 function_tail(); 01503 if (inputState->guessing==0) { 01504 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01505 } 01506 { 01507 switch ( LA(1)) { 01508 case RENAMES: 01509 { 01510 renames(); 01511 if (inputState->guessing==0) { 01512 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01513 } 01514 if ( inputState->guessing==0 ) { 01515 #line 861 "ada.g" 01516 Set(g_AST, GENERIC_FUNCTION_RENAMING); 01517 #line 1518 "AdaParser.cpp" 01518 } 01519 break; 01520 } 01521 case SEMI: 01522 { 01523 if ( inputState->guessing==0 ) { 01524 #line 864 "ada.g" 01525 Set(g_AST, GENERIC_FUNCTION_DECLARATION); pop_def_id(); 01526 #line 1527 "AdaParser.cpp" 01527 } 01528 break; 01529 } 01530 default: 01531 { 01532 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01533 } 01534 } 01535 } 01536 break; 01537 } 01538 default: 01539 { 01540 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01541 } 01542 } 01543 } 01544 match(SEMI); 01545 generic_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01546 } 01547 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01548 if( inputState->guessing == 0 ) { 01549 reportError(ex); 01550 consume(); 01551 consumeUntil(_tokenSet_18); 01552 } else { 01553 throw; 01554 } 01555 } 01556 returnAST = generic_decl_AST; 01557 } 01558 01559 void AdaParser::def_id( 01560 bool lib_level 01561 ) { 01562 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01563 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01564 RefAdaAST def_id_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01565 RefAdaAST cn_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01566 ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; 01567 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01568 01569 try { // for error handling 01570 if (((LA(1) == IDENTIFIER) && (_tokenSet_19.member(LA(2))))&&( lib_level )) { 01571 compound_name(); 01572 if (inputState->guessing==0) { 01573 cn_AST = returnAST; 01574 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01575 } 01576 if ( inputState->guessing==0 ) { 01577 #line 171 "ada.g" 01578 push_def_id(cn_AST); 01579 #line 1580 "AdaParser.cpp" 01580 } 01581 def_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01582 } 01583 else if (((LA(1) == IDENTIFIER) && (_tokenSet_20.member(LA(2))))&&( !lib_level )) { 01584 n = LT(1); 01585 if ( inputState->guessing == 0 ) { 01586 n_AST = astFactory->create(n); 01587 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get())); 01588 } 01589 match(IDENTIFIER); 01590 if ( inputState->guessing==0 ) { 01591 #line 172 "ada.g" 01592 push_def_id(n_AST); 01593 #line 1594 "AdaParser.cpp" 01594 } 01595 def_id_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01596 } 01597 else { 01598 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01599 } 01600 01601 } 01602 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01603 if( inputState->guessing == 0 ) { 01604 reportError(ex); 01605 consume(); 01606 consumeUntil(_tokenSet_20); 01607 } else { 01608 throw; 01609 } 01610 } 01611 returnAST = def_id_AST; 01612 } 01613 01614 void AdaParser::pkg_body_part() { 01615 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01616 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01617 RefAdaAST pkg_body_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01618 01619 try { // for error handling 01620 declarative_part(); 01621 if (inputState->guessing==0) { 01622 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01623 } 01624 block_body_opt(); 01625 if (inputState->guessing==0) { 01626 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01627 } 01628 pkg_body_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01629 } 01630 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01631 if( inputState->guessing == 0 ) { 01632 reportError(ex); 01633 consume(); 01634 consumeUntil(_tokenSet_21); 01635 } else { 01636 throw; 01637 } 01638 } 01639 returnAST = pkg_body_part_AST; 01640 } 01641 01642 void AdaParser::end_id_opt() { 01643 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01644 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01645 RefAdaAST end_id_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01646 01647 try { // for error handling 01648 match(END); 01649 id_opt(); 01650 if (inputState->guessing==0) { 01651 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01652 } 01653 end_id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01654 } 01655 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01656 if( inputState->guessing == 0 ) { 01657 reportError(ex); 01658 consume(); 01659 consumeUntil(_tokenSet_4); 01660 } else { 01661 throw; 01662 } 01663 } 01664 returnAST = end_id_opt_AST; 01665 } 01666 01667 void AdaParser::spec_decl_part( 01668 RefAdaAST pkg 01669 ) { 01670 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01671 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01672 RefAdaAST spec_decl_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01673 01674 try { // for error handling 01675 { 01676 switch ( LA(1)) { 01677 case IS: 01678 { 01679 match(IS); 01680 { 01681 switch ( LA(1)) { 01682 case NEW: 01683 { 01684 generic_inst(); 01685 if (inputState->guessing==0) { 01686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01687 } 01688 if ( inputState->guessing==0 ) { 01689 #line 363 "ada.g" 01690 Set(pkg, GENERIC_PACKAGE_INSTANTIATION); 01691 #line 1692 "AdaParser.cpp" 01692 } 01693 break; 01694 } 01695 case PRAGMA: 01696 case IDENTIFIER: 01697 case USE: 01698 case TYPE: 01699 case PRIVATE: 01700 case PACKAGE: 01701 case PROCEDURE: 01702 case FUNCTION: 01703 case TASK: 01704 case PROTECTED: 01705 case FOR: 01706 case END: 01707 case SUBTYPE: 01708 case GENERIC: 01709 { 01710 pkg_spec_part(); 01711 if (inputState->guessing==0) { 01712 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01713 } 01714 if ( inputState->guessing==0 ) { 01715 #line 364 "ada.g" 01716 Set(pkg, PACKAGE_SPECIFICATION); 01717 #line 1718 "AdaParser.cpp" 01718 } 01719 break; 01720 } 01721 default: 01722 { 01723 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01724 } 01725 } 01726 } 01727 break; 01728 } 01729 case RENAMES: 01730 { 01731 renames(); 01732 if (inputState->guessing==0) { 01733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01734 } 01735 if ( inputState->guessing==0 ) { 01736 #line 366 "ada.g" 01737 Set(pkg, PACKAGE_RENAMING_DECLARATION); 01738 #line 1739 "AdaParser.cpp" 01739 } 01740 break; 01741 } 01742 default: 01743 { 01744 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01745 } 01746 } 01747 } 01748 match(SEMI); 01749 spec_decl_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01750 } 01751 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01752 if( inputState->guessing == 0 ) { 01753 reportError(ex); 01754 consume(); 01755 consumeUntil(_tokenSet_18); 01756 } else { 01757 throw; 01758 } 01759 } 01760 returnAST = spec_decl_part_AST; 01761 } 01762 01763 void AdaParser::subprog_decl( 01764 bool lib_level 01765 ) { 01766 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01767 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01768 RefAdaAST subprog_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01769 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 01770 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01771 ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; 01772 RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01773 #line 148 "ada.g" 01774 RefAdaAST t; 01775 #line 1776 "AdaParser.cpp" 01776 01777 try { // for error handling 01778 switch ( LA(1)) { 01779 case PROCEDURE: 01780 { 01781 p = LT(1); 01782 if ( inputState->guessing == 0 ) { 01783 p_AST = astFactory->create(p); 01784 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 01785 } 01786 match(PROCEDURE); 01787 def_id(lib_level); 01788 if (inputState->guessing==0) { 01789 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01790 } 01791 { 01792 if ((LA(1) == IS) && (LA(2) == NEW)) { 01793 generic_subp_inst(); 01794 if (inputState->guessing==0) { 01795 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01796 } 01797 if ( inputState->guessing==0 ) { 01798 #line 152 "ada.g" 01799 Set(p_AST, GENERIC_PROCEDURE_INSTANTIATION); 01800 #line 1801 "AdaParser.cpp" 01801 } 01802 } 01803 else if ((_tokenSet_15.member(LA(1))) && (_tokenSet_22.member(LA(2)))) { 01804 formal_part_opt(); 01805 if (inputState->guessing==0) { 01806 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01807 } 01808 { 01809 switch ( LA(1)) { 01810 case RENAMES: 01811 { 01812 renames(); 01813 if (inputState->guessing==0) { 01814 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01815 } 01816 if ( inputState->guessing==0 ) { 01817 #line 154 "ada.g" 01818 Set(p_AST, PROCEDURE_RENAMING_DECLARATION); 01819 #line 1820 "AdaParser.cpp" 01820 } 01821 break; 01822 } 01823 case SEMI: 01824 case IS: 01825 { 01826 is_separate_or_abstract_or_decl(p_AST); 01827 if (inputState->guessing==0) { 01828 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01829 } 01830 break; 01831 } 01832 default: 01833 { 01834 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01835 } 01836 } 01837 } 01838 match(SEMI); 01839 } 01840 else { 01841 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01842 } 01843 01844 } 01845 subprog_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01846 break; 01847 } 01848 case FUNCTION: 01849 { 01850 f = LT(1); 01851 if ( inputState->guessing == 0 ) { 01852 f_AST = astFactory->create(f); 01853 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get())); 01854 } 01855 match(FUNCTION); 01856 def_designator(lib_level); 01857 if (inputState->guessing==0) { 01858 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01859 } 01860 { 01861 switch ( LA(1)) { 01862 case IS: 01863 { 01864 generic_subp_inst(); 01865 if (inputState->guessing==0) { 01866 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01867 } 01868 if ( inputState->guessing==0 ) { 01869 #line 161 "ada.g" 01870 Set(f_AST, GENERIC_FUNCTION_INSTANTIATION); 01871 #line 1872 "AdaParser.cpp" 01872 } 01873 break; 01874 } 01875 case LPAREN: 01876 case RETURN: 01877 { 01878 function_tail(); 01879 if (inputState->guessing==0) { 01880 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01881 } 01882 { 01883 switch ( LA(1)) { 01884 case RENAMES: 01885 { 01886 renames(); 01887 if (inputState->guessing==0) { 01888 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01889 } 01890 if ( inputState->guessing==0 ) { 01891 #line 163 "ada.g" 01892 Set(f_AST, FUNCTION_RENAMING_DECLARATION); 01893 #line 1894 "AdaParser.cpp" 01894 } 01895 break; 01896 } 01897 case SEMI: 01898 case IS: 01899 { 01900 is_separate_or_abstract_or_decl(f_AST); 01901 if (inputState->guessing==0) { 01902 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01903 } 01904 break; 01905 } 01906 default: 01907 { 01908 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01909 } 01910 } 01911 } 01912 match(SEMI); 01913 break; 01914 } 01915 default: 01916 { 01917 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01918 } 01919 } 01920 } 01921 subprog_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01922 break; 01923 } 01924 default: 01925 { 01926 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 01927 } 01928 } 01929 } 01930 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01931 if( inputState->guessing == 0 ) { 01932 reportError(ex); 01933 consume(); 01934 consumeUntil(_tokenSet_23); 01935 } else { 01936 throw; 01937 } 01938 } 01939 returnAST = subprog_decl_AST; 01940 } 01941 01942 void AdaParser::generic_subp_inst() { 01943 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01944 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01945 RefAdaAST generic_subp_inst_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01946 01947 try { // for error handling 01948 match(IS); 01949 generic_inst(); 01950 if (inputState->guessing==0) { 01951 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01952 } 01953 match(SEMI); 01954 generic_subp_inst_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 01955 } 01956 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 01957 if( inputState->guessing == 0 ) { 01958 reportError(ex); 01959 consume(); 01960 consumeUntil(_tokenSet_18); 01961 } else { 01962 throw; 01963 } 01964 } 01965 returnAST = generic_subp_inst_AST; 01966 } 01967 01968 void AdaParser::formal_part_opt() { 01969 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01970 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 01971 RefAdaAST formal_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 01972 01973 try { // for error handling 01974 { 01975 switch ( LA(1)) { 01976 case LPAREN: 01977 { 01978 match(LPAREN); 01979 parameter_specification(); 01980 if (inputState->guessing==0) { 01981 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01982 } 01983 { // ( ... )* 01984 for (;;) { 01985 if ((LA(1) == SEMI)) { 01986 match(SEMI); 01987 parameter_specification(); 01988 if (inputState->guessing==0) { 01989 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 01990 } 01991 } 01992 else { 01993 goto _loop74; 01994 } 01995 01996 } 01997 _loop74:; 01998 } // ( ... )* 01999 match(RPAREN); 02000 break; 02001 } 02002 case SEMI: 02003 case IS: 02004 case RENAMES: 02005 case WHEN: 02006 case DO: 02007 { 02008 break; 02009 } 02010 default: 02011 { 02012 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02013 } 02014 } 02015 } 02016 if ( inputState->guessing==0 ) { 02017 formal_part_opt_AST = RefAdaAST(currentAST.root); 02018 #line 234 "ada.g" 02019 formal_part_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(formal_part_opt_AST.get())))); 02020 #line 2021 "AdaParser.cpp" 02021 currentAST.root = formal_part_opt_AST; 02022 if ( formal_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 02023 formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 02024 currentAST.child = formal_part_opt_AST->getFirstChild(); 02025 else 02026 currentAST.child = formal_part_opt_AST; 02027 currentAST.advanceChildToEnd(); 02028 } 02029 formal_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02030 } 02031 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02032 if( inputState->guessing == 0 ) { 02033 reportError(ex); 02034 consume(); 02035 consumeUntil(_tokenSet_24); 02036 } else { 02037 throw; 02038 } 02039 } 02040 returnAST = formal_part_opt_AST; 02041 } 02042 02043 void AdaParser::renames() { 02044 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02045 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02046 RefAdaAST renames_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02047 #line 257 "ada.g" 02048 RefAdaAST dummy; 02049 #line 2050 "AdaParser.cpp" 02050 02051 try { // for error handling 02052 match(RENAMES); 02053 { 02054 switch ( LA(1)) { 02055 case IDENTIFIER: 02056 { 02057 name(); 02058 if (inputState->guessing==0) { 02059 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02060 } 02061 break; 02062 } 02063 case CHAR_STRING: 02064 { 02065 dummy=definable_operator_symbol(); 02066 if (inputState->guessing==0) { 02067 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02068 } 02069 break; 02070 } 02071 default: 02072 { 02073 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02074 } 02075 } 02076 } 02077 if ( inputState->guessing==0 ) { 02078 #line 261 "ada.g" 02079 pop_def_id(); 02080 #line 2081 "AdaParser.cpp" 02081 } 02082 renames_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02083 } 02084 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02085 if( inputState->guessing == 0 ) { 02086 reportError(ex); 02087 consume(); 02088 consumeUntil(_tokenSet_4); 02089 } else { 02090 throw; 02091 } 02092 } 02093 returnAST = renames_AST; 02094 } 02095 02096 void AdaParser::is_separate_or_abstract_or_decl( 02097 RefAdaAST t 02098 ) { 02099 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02100 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02101 RefAdaAST is_separate_or_abstract_or_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02102 02103 try { // for error handling 02104 switch ( LA(1)) { 02105 case IS: 02106 { 02107 match(IS); 02108 separate_or_abstract(t); 02109 break; 02110 } 02111 case SEMI: 02112 { 02113 if ( inputState->guessing==0 ) { 02114 #line 304 "ada.g" 02115 pop_def_id(); 02116 if (t->getType() == AdaTokenTypes::PROCEDURE) 02117 Set(t, PROCEDURE_DECLARATION); 02118 else 02119 Set(t, FUNCTION_DECLARATION); 02120 02121 #line 2122 "AdaParser.cpp" 02122 } 02123 break; 02124 } 02125 default: 02126 { 02127 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02128 } 02129 } 02130 } 02131 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02132 if( inputState->guessing == 0 ) { 02133 reportError(ex); 02134 consume(); 02135 consumeUntil(_tokenSet_4); 02136 } else { 02137 throw; 02138 } 02139 } 02140 returnAST = is_separate_or_abstract_or_decl_AST; 02141 } 02142 02143 void AdaParser::def_designator( 02144 bool lib_level 02145 ) { 02146 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02147 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02148 RefAdaAST def_designator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02149 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02150 #line 329 "ada.g" 02151 RefAdaAST d; 02152 #line 2153 "AdaParser.cpp" 02153 02154 try { // for error handling 02155 if (((LA(1) == IDENTIFIER) && (_tokenSet_25.member(LA(2))))&&( lib_level )) { 02156 compound_name(); 02157 if (inputState->guessing==0) { 02158 n_AST = returnAST; 02159 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02160 } 02161 if ( inputState->guessing==0 ) { 02162 #line 331 "ada.g" 02163 push_def_id(n_AST); 02164 #line 2165 "AdaParser.cpp" 02165 } 02166 def_designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02167 } 02168 else if (((LA(1) == IDENTIFIER || LA(1) == CHAR_STRING) && (LA(2) == LPAREN || LA(2) == IS || LA(2) == RETURN))&&( !lib_level )) { 02169 d=designator(); 02170 if (inputState->guessing==0) { 02171 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02172 } 02173 if ( inputState->guessing==0 ) { 02174 #line 332 "ada.g" 02175 push_def_id(d); 02176 #line 2177 "AdaParser.cpp" 02177 } 02178 def_designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02179 } 02180 else { 02181 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02182 } 02183 02184 } 02185 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02186 if( inputState->guessing == 0 ) { 02187 reportError(ex); 02188 consume(); 02189 consumeUntil(_tokenSet_26); 02190 } else { 02191 throw; 02192 } 02193 } 02194 returnAST = def_designator_AST; 02195 } 02196 02197 void AdaParser::function_tail() { 02198 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02199 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02200 RefAdaAST function_tail_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02201 02202 try { // for error handling 02203 func_formal_part_opt(); 02204 if (inputState->guessing==0) { 02205 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02206 } 02207 match(RETURN); 02208 subtype_mark(); 02209 if (inputState->guessing==0) { 02210 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02211 } 02212 function_tail_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02213 } 02214 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02215 if( inputState->guessing == 0 ) { 02216 reportError(ex); 02217 consume(); 02218 consumeUntil(_tokenSet_27); 02219 } else { 02220 throw; 02221 } 02222 } 02223 returnAST = function_tail_AST; 02224 } 02225 02226 void AdaParser::generic_inst() { 02227 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02228 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02229 RefAdaAST generic_inst_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02230 02231 try { // for error handling 02232 match(NEW); 02233 compound_name(); 02234 if (inputState->guessing==0) { 02235 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02236 } 02237 { 02238 switch ( LA(1)) { 02239 case LPAREN: 02240 { 02241 match(LPAREN); 02242 value_s(); 02243 if (inputState->guessing==0) { 02244 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02245 } 02246 match(RPAREN); 02247 break; 02248 } 02249 case SEMI: 02250 { 02251 break; 02252 } 02253 default: 02254 { 02255 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02256 } 02257 } 02258 } 02259 if ( inputState->guessing==0 ) { 02260 #line 179 "ada.g" 02261 pop_def_id(); 02262 #line 2263 "AdaParser.cpp" 02263 } 02264 generic_inst_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02265 } 02266 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02267 if( inputState->guessing == 0 ) { 02268 reportError(ex); 02269 consume(); 02270 consumeUntil(_tokenSet_4); 02271 } else { 02272 throw; 02273 } 02274 } 02275 returnAST = generic_inst_AST; 02276 } 02277 02278 void AdaParser::value_s() { 02279 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02280 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02281 RefAdaAST value_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02282 02283 try { // for error handling 02284 value(); 02285 if (inputState->guessing==0) { 02286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02287 } 02288 { // ( ... )* 02289 for (;;) { 02290 if ((LA(1) == COMMA)) { 02291 match(COMMA); 02292 value(); 02293 if (inputState->guessing==0) { 02294 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02295 } 02296 } 02297 else { 02298 goto _loop440; 02299 } 02300 02301 } 02302 _loop440:; 02303 } // ( ... )* 02304 if ( inputState->guessing==0 ) { 02305 value_s_AST = RefAdaAST(currentAST.root); 02306 #line 1380 "ada.g" 02307 value_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VALUES,"VALUES").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(value_s_AST.get())))); 02308 #line 2309 "AdaParser.cpp" 02309 currentAST.root = value_s_AST; 02310 if ( value_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 02311 value_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 02312 currentAST.child = value_s_AST->getFirstChild(); 02313 else 02314 currentAST.child = value_s_AST; 02315 currentAST.advanceChildToEnd(); 02316 } 02317 value_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02318 } 02319 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02320 if( inputState->guessing == 0 ) { 02321 reportError(ex); 02322 consume(); 02323 consumeUntil(_tokenSet_28); 02324 } else { 02325 throw; 02326 } 02327 } 02328 returnAST = value_s_AST; 02329 } 02330 02331 void AdaParser::parenth_values() { 02332 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02333 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02334 RefAdaAST parenth_values_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02335 02336 try { // for error handling 02337 match(LPAREN); 02338 value(); 02339 if (inputState->guessing==0) { 02340 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02341 } 02342 { // ( ... )* 02343 for (;;) { 02344 if ((LA(1) == COMMA)) { 02345 match(COMMA); 02346 value(); 02347 if (inputState->guessing==0) { 02348 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02349 } 02350 } 02351 else { 02352 goto _loop50; 02353 } 02354 02355 } 02356 _loop50:; 02357 } // ( ... )* 02358 match(RPAREN); 02359 parenth_values_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02360 } 02361 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02362 if( inputState->guessing == 0 ) { 02363 reportError(ex); 02364 consume(); 02365 consumeUntil(_tokenSet_4); 02366 } else { 02367 throw; 02368 } 02369 } 02370 returnAST = parenth_values_AST; 02371 } 02372 02373 void AdaParser::value() { 02374 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02375 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02376 RefAdaAST value_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02377 02378 try { // for error handling 02379 { 02380 switch ( LA(1)) { 02381 case OTHERS: 02382 { 02383 RefAdaAST tmp61_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02384 if ( inputState->guessing == 0 ) { 02385 tmp61_AST = astFactory->create(LT(1)); 02386 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp61_AST.get())); 02387 } 02388 match(OTHERS); 02389 match(RIGHT_SHAFT); 02390 expression(); 02391 if (inputState->guessing==0) { 02392 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02393 } 02394 break; 02395 } 02396 case IDENTIFIER: 02397 case LPAREN: 02398 case NEW: 02399 case CHARACTER_LITERAL: 02400 case CHAR_STRING: 02401 case NuLL: 02402 case NOT: 02403 case PLUS: 02404 case MINUS: 02405 case ABS: 02406 case NUMERIC_LIT: 02407 { 02408 ranged_expr_s(); 02409 if (inputState->guessing==0) { 02410 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02411 } 02412 { 02413 switch ( LA(1)) { 02414 case RIGHT_SHAFT: 02415 { 02416 RefAdaAST tmp63_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02417 if ( inputState->guessing == 0 ) { 02418 tmp63_AST = astFactory->create(LT(1)); 02419 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp63_AST.get())); 02420 } 02421 match(RIGHT_SHAFT); 02422 expression(); 02423 if (inputState->guessing==0) { 02424 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02425 } 02426 break; 02427 } 02428 case COMMA: 02429 case RPAREN: 02430 case WITH: 02431 { 02432 break; 02433 } 02434 default: 02435 { 02436 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02437 } 02438 } 02439 } 02440 break; 02441 } 02442 default: 02443 { 02444 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02445 } 02446 } 02447 } 02448 value_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02449 } 02450 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02451 if( inputState->guessing == 0 ) { 02452 reportError(ex); 02453 consume(); 02454 consumeUntil(_tokenSet_29); 02455 } else { 02456 throw; 02457 } 02458 } 02459 returnAST = value_AST; 02460 } 02461 02462 void AdaParser::ranged_expr_s() { 02463 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02464 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02465 RefAdaAST ranged_expr_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02466 02467 try { // for error handling 02468 ranged_expr(); 02469 if (inputState->guessing==0) { 02470 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02471 } 02472 { // ( ... )* 02473 for (;;) { 02474 if ((LA(1) == PIPE)) { 02475 RefAdaAST tmp64_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02476 if ( inputState->guessing == 0 ) { 02477 tmp64_AST = astFactory->create(LT(1)); 02478 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp64_AST.get())); 02479 } 02480 match(PIPE); 02481 ranged_expr(); 02482 if (inputState->guessing==0) { 02483 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02484 } 02485 } 02486 else { 02487 goto _loop56; 02488 } 02489 02490 } 02491 _loop56:; 02492 } // ( ... )* 02493 ranged_expr_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02494 } 02495 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02496 if( inputState->guessing == 0 ) { 02497 reportError(ex); 02498 consume(); 02499 consumeUntil(_tokenSet_30); 02500 } else { 02501 throw; 02502 } 02503 } 02504 returnAST = ranged_expr_s_AST; 02505 } 02506 02507 void AdaParser::ranged_expr() { 02508 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02509 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02510 RefAdaAST ranged_expr_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02511 02512 try { // for error handling 02513 expression(); 02514 if (inputState->guessing==0) { 02515 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02516 } 02517 { 02518 switch ( LA(1)) { 02519 case DOT_DOT: 02520 { 02521 RefAdaAST tmp65_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02522 if ( inputState->guessing == 0 ) { 02523 tmp65_AST = astFactory->create(LT(1)); 02524 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp65_AST.get())); 02525 } 02526 match(DOT_DOT); 02527 simple_expression(); 02528 if (inputState->guessing==0) { 02529 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02530 } 02531 break; 02532 } 02533 case RANGE: 02534 { 02535 RefAdaAST tmp66_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02536 if ( inputState->guessing == 0 ) { 02537 tmp66_AST = astFactory->create(LT(1)); 02538 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp66_AST.get())); 02539 } 02540 match(RANGE); 02541 range(); 02542 if (inputState->guessing==0) { 02543 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02544 } 02545 break; 02546 } 02547 case COMMA: 02548 case RPAREN: 02549 case RIGHT_SHAFT: 02550 case WITH: 02551 case PIPE: 02552 { 02553 break; 02554 } 02555 default: 02556 { 02557 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02558 } 02559 } 02560 } 02561 ranged_expr_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02562 } 02563 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02564 if( inputState->guessing == 0 ) { 02565 reportError(ex); 02566 consume(); 02567 consumeUntil(_tokenSet_31); 02568 } else { 02569 throw; 02570 } 02571 } 02572 returnAST = ranged_expr_AST; 02573 } 02574 02575 void AdaParser::simple_expression() { 02576 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02577 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02578 RefAdaAST simple_expression_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02579 02580 try { // for error handling 02581 signed_term(); 02582 if (inputState->guessing==0) { 02583 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02584 } 02585 { // ( ... )* 02586 for (;;) { 02587 switch ( LA(1)) { 02588 case PLUS: 02589 { 02590 RefAdaAST tmp67_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02591 if ( inputState->guessing == 0 ) { 02592 tmp67_AST = astFactory->create(LT(1)); 02593 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp67_AST.get())); 02594 } 02595 match(PLUS); 02596 signed_term(); 02597 if (inputState->guessing==0) { 02598 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02599 } 02600 break; 02601 } 02602 case MINUS: 02603 { 02604 RefAdaAST tmp68_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02605 if ( inputState->guessing == 0 ) { 02606 tmp68_AST = astFactory->create(LT(1)); 02607 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp68_AST.get())); 02608 } 02609 match(MINUS); 02610 signed_term(); 02611 if (inputState->guessing==0) { 02612 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02613 } 02614 break; 02615 } 02616 case CONCAT: 02617 { 02618 RefAdaAST tmp69_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02619 if ( inputState->guessing == 0 ) { 02620 tmp69_AST = astFactory->create(LT(1)); 02621 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp69_AST.get())); 02622 } 02623 match(CONCAT); 02624 signed_term(); 02625 if (inputState->guessing==0) { 02626 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02627 } 02628 break; 02629 } 02630 default: 02631 { 02632 goto _loop453; 02633 } 02634 } 02635 } 02636 _loop453:; 02637 } // ( ... )* 02638 simple_expression_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02639 } 02640 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02641 if( inputState->guessing == 0 ) { 02642 reportError(ex); 02643 consume(); 02644 consumeUntil(_tokenSet_32); 02645 } else { 02646 throw; 02647 } 02648 } 02649 returnAST = simple_expression_AST; 02650 } 02651 02652 void AdaParser::range() { 02653 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02654 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02655 RefAdaAST range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02656 02657 try { // for error handling 02658 { 02659 bool synPredMatched63 = false; 02660 if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) { 02661 int _m63 = mark(); 02662 synPredMatched63 = true; 02663 inputState->guessing++; 02664 try { 02665 { 02666 range_dots(); 02667 } 02668 } 02669 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 02670 synPredMatched63 = false; 02671 } 02672 rewind(_m63); 02673 inputState->guessing--; 02674 } 02675 if ( synPredMatched63 ) { 02676 range_dots(); 02677 if (inputState->guessing==0) { 02678 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02679 } 02680 } 02681 else if ((LA(1) == IDENTIFIER) && (LA(2) == LPAREN || LA(2) == DOT || LA(2) == TIC)) { 02682 range_attrib_ref(); 02683 if (inputState->guessing==0) { 02684 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02685 } 02686 } 02687 else { 02688 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02689 } 02690 02691 } 02692 range_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02693 } 02694 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02695 if( inputState->guessing == 0 ) { 02696 reportError(ex); 02697 consume(); 02698 consumeUntil(_tokenSet_34); 02699 } else { 02700 throw; 02701 } 02702 } 02703 returnAST = range_AST; 02704 } 02705 02706 void AdaParser::range_constraint() { 02707 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02708 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02709 RefAdaAST range_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02710 02711 try { // for error handling 02712 match(RANGE); 02713 range(); 02714 if (inputState->guessing==0) { 02715 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02716 } 02717 range_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02718 } 02719 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02720 if( inputState->guessing == 0 ) { 02721 reportError(ex); 02722 consume(); 02723 consumeUntil(_tokenSet_35); 02724 } else { 02725 throw; 02726 } 02727 } 02728 returnAST = range_constraint_AST; 02729 } 02730 02731 void AdaParser::range_dots() { 02732 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02733 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02734 RefAdaAST range_dots_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02735 02736 try { // for error handling 02737 simple_expression(); 02738 if (inputState->guessing==0) { 02739 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02740 } 02741 RefAdaAST tmp71_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02742 if ( inputState->guessing == 0 ) { 02743 tmp71_AST = astFactory->create(LT(1)); 02744 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp71_AST.get())); 02745 } 02746 match(DOT_DOT); 02747 simple_expression(); 02748 if (inputState->guessing==0) { 02749 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02750 } 02751 range_dots_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02752 } 02753 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02754 if( inputState->guessing == 0 ) { 02755 reportError(ex); 02756 consume(); 02757 consumeUntil(_tokenSet_34); 02758 } else { 02759 throw; 02760 } 02761 } 02762 returnAST = range_dots_AST; 02763 } 02764 02765 void AdaParser::range_attrib_ref() { 02766 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02767 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02768 RefAdaAST range_attrib_ref_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02769 ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; 02770 RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02771 02772 try { // for error handling 02773 prefix(); 02774 if (inputState->guessing==0) { 02775 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02776 } 02777 match(TIC); 02778 r = LT(1); 02779 if ( inputState->guessing == 0 ) { 02780 r_AST = astFactory->create(r); 02781 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get())); 02782 } 02783 match(RANGE); 02784 { 02785 switch ( LA(1)) { 02786 case LPAREN: 02787 { 02788 match(LPAREN); 02789 expression(); 02790 if (inputState->guessing==0) { 02791 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02792 } 02793 match(RPAREN); 02794 break; 02795 } 02796 case SEMI: 02797 case COMMA: 02798 case RPAREN: 02799 case RIGHT_SHAFT: 02800 case WITH: 02801 case RANGE: 02802 case DIGITS: 02803 case IS: 02804 case PIPE: 02805 case DOT_DOT: 02806 case ASSIGN: 02807 case THEN: 02808 case LOOP: 02809 case OR: 02810 case AND: 02811 case XOR: 02812 { 02813 break; 02814 } 02815 default: 02816 { 02817 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02818 } 02819 } 02820 } 02821 if ( inputState->guessing==0 ) { 02822 #line 218 "ada.g" 02823 Set(r_AST, RANGE_ATTRIBUTE_REFERENCE); 02824 #line 2825 "AdaParser.cpp" 02825 } 02826 range_attrib_ref_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02827 } 02828 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02829 if( inputState->guessing == 0 ) { 02830 reportError(ex); 02831 consume(); 02832 consumeUntil(_tokenSet_34); 02833 } else { 02834 throw; 02835 } 02836 } 02837 returnAST = range_attrib_ref_AST; 02838 } 02839 02840 void AdaParser::prefix() { 02841 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02842 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02843 RefAdaAST prefix_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02844 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 02845 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02846 02847 try { // for error handling 02848 RefAdaAST tmp75_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02849 if ( inputState->guessing == 0 ) { 02850 tmp75_AST = astFactory->create(LT(1)); 02851 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp75_AST.get())); 02852 } 02853 match(IDENTIFIER); 02854 { // ( ... )* 02855 for (;;) { 02856 switch ( LA(1)) { 02857 case DOT: 02858 { 02859 RefAdaAST tmp76_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02860 if ( inputState->guessing == 0 ) { 02861 tmp76_AST = astFactory->create(LT(1)); 02862 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp76_AST.get())); 02863 } 02864 match(DOT); 02865 { 02866 switch ( LA(1)) { 02867 case ALL: 02868 { 02869 RefAdaAST tmp77_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02870 if ( inputState->guessing == 0 ) { 02871 tmp77_AST = astFactory->create(LT(1)); 02872 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp77_AST.get())); 02873 } 02874 match(ALL); 02875 break; 02876 } 02877 case IDENTIFIER: 02878 { 02879 RefAdaAST tmp78_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02880 if ( inputState->guessing == 0 ) { 02881 tmp78_AST = astFactory->create(LT(1)); 02882 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp78_AST.get())); 02883 } 02884 match(IDENTIFIER); 02885 break; 02886 } 02887 default: 02888 { 02889 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 02890 } 02891 } 02892 } 02893 break; 02894 } 02895 case LPAREN: 02896 { 02897 p = LT(1); 02898 if ( inputState->guessing == 0 ) { 02899 p_AST = astFactory->create(p); 02900 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 02901 } 02902 match(LPAREN); 02903 value_s(); 02904 if (inputState->guessing==0) { 02905 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02906 } 02907 match(RPAREN); 02908 if ( inputState->guessing==0 ) { 02909 #line 227 "ada.g" 02910 Set(p_AST, INDEXED_COMPONENT); 02911 #line 2912 "AdaParser.cpp" 02912 } 02913 break; 02914 } 02915 default: 02916 { 02917 goto _loop70; 02918 } 02919 } 02920 } 02921 _loop70:; 02922 } // ( ... )* 02923 prefix_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02924 } 02925 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02926 if( inputState->guessing == 0 ) { 02927 reportError(ex); 02928 consume(); 02929 consumeUntil(_tokenSet_36); 02930 } else { 02931 throw; 02932 } 02933 } 02934 returnAST = prefix_AST; 02935 } 02936 02937 void AdaParser::parameter_specification() { 02938 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02939 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02940 RefAdaAST parameter_specification_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02941 02942 try { // for error handling 02943 def_ids_colon(); 02944 if (inputState->guessing==0) { 02945 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02946 } 02947 mode_opt(); 02948 if (inputState->guessing==0) { 02949 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02950 } 02951 subtype_mark(); 02952 if (inputState->guessing==0) { 02953 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02954 } 02955 init_opt(); 02956 if (inputState->guessing==0) { 02957 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02958 } 02959 if ( inputState->guessing==0 ) { 02960 parameter_specification_AST = RefAdaAST(currentAST.root); 02961 #line 239 "ada.g" 02962 parameter_specification_AST = 02963 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(parameter_specification_AST.get())))); 02964 #line 2965 "AdaParser.cpp" 02965 currentAST.root = parameter_specification_AST; 02966 if ( parameter_specification_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 02967 parameter_specification_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 02968 currentAST.child = parameter_specification_AST->getFirstChild(); 02969 else 02970 currentAST.child = parameter_specification_AST; 02971 currentAST.advanceChildToEnd(); 02972 } 02973 parameter_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02974 } 02975 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 02976 if( inputState->guessing == 0 ) { 02977 reportError(ex); 02978 consume(); 02979 consumeUntil(_tokenSet_37); 02980 } else { 02981 throw; 02982 } 02983 } 02984 returnAST = parameter_specification_AST; 02985 } 02986 02987 void AdaParser::def_ids_colon() { 02988 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02989 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 02990 RefAdaAST def_ids_colon_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 02991 02992 try { // for error handling 02993 defining_identifier_list(); 02994 if (inputState->guessing==0) { 02995 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 02996 } 02997 match(COLON); 02998 def_ids_colon_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 02999 } 03000 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03001 if( inputState->guessing == 0 ) { 03002 reportError(ex); 03003 consume(); 03004 consumeUntil(_tokenSet_38); 03005 } else { 03006 throw; 03007 } 03008 } 03009 returnAST = def_ids_colon_AST; 03010 } 03011 03012 void AdaParser::mode_opt() { 03013 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03014 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03015 RefAdaAST mode_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03016 03017 try { // for error handling 03018 { 03019 switch ( LA(1)) { 03020 case IN: 03021 { 03022 RefAdaAST tmp81_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03023 if ( inputState->guessing == 0 ) { 03024 tmp81_AST = astFactory->create(LT(1)); 03025 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp81_AST.get())); 03026 } 03027 match(IN); 03028 { 03029 switch ( LA(1)) { 03030 case OUT: 03031 { 03032 RefAdaAST tmp82_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03033 if ( inputState->guessing == 0 ) { 03034 tmp82_AST = astFactory->create(LT(1)); 03035 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp82_AST.get())); 03036 } 03037 match(OUT); 03038 break; 03039 } 03040 case IDENTIFIER: 03041 { 03042 break; 03043 } 03044 default: 03045 { 03046 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03047 } 03048 } 03049 } 03050 break; 03051 } 03052 case OUT: 03053 { 03054 RefAdaAST tmp83_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03055 if ( inputState->guessing == 0 ) { 03056 tmp83_AST = astFactory->create(LT(1)); 03057 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp83_AST.get())); 03058 } 03059 match(OUT); 03060 break; 03061 } 03062 case ACCESS: 03063 { 03064 RefAdaAST tmp84_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03065 if ( inputState->guessing == 0 ) { 03066 tmp84_AST = astFactory->create(LT(1)); 03067 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp84_AST.get())); 03068 } 03069 match(ACCESS); 03070 break; 03071 } 03072 case IDENTIFIER: 03073 { 03074 break; 03075 } 03076 default: 03077 { 03078 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03079 } 03080 } 03081 } 03082 if ( inputState->guessing==0 ) { 03083 mode_opt_AST = RefAdaAST(currentAST.root); 03084 #line 254 "ada.g" 03085 mode_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mode_opt_AST.get())))); 03086 #line 3087 "AdaParser.cpp" 03087 currentAST.root = mode_opt_AST; 03088 if ( mode_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03089 mode_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03090 currentAST.child = mode_opt_AST->getFirstChild(); 03091 else 03092 currentAST.child = mode_opt_AST; 03093 currentAST.advanceChildToEnd(); 03094 } 03095 mode_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03096 } 03097 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03098 if( inputState->guessing == 0 ) { 03099 reportError(ex); 03100 consume(); 03101 consumeUntil(_tokenSet_39); 03102 } else { 03103 throw; 03104 } 03105 } 03106 returnAST = mode_opt_AST; 03107 } 03108 03109 void AdaParser::init_opt() { 03110 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03111 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03112 RefAdaAST init_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03113 03114 try { // for error handling 03115 { 03116 switch ( LA(1)) { 03117 case ASSIGN: 03118 { 03119 match(ASSIGN); 03120 expression(); 03121 if (inputState->guessing==0) { 03122 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03123 } 03124 break; 03125 } 03126 case SEMI: 03127 case RPAREN: 03128 { 03129 break; 03130 } 03131 default: 03132 { 03133 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03134 } 03135 } 03136 } 03137 if ( inputState->guessing==0 ) { 03138 init_opt_AST = RefAdaAST(currentAST.root); 03139 #line 460 "ada.g" 03140 init_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(INIT_OPT,"INIT_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(init_opt_AST.get())))); 03141 #line 3142 "AdaParser.cpp" 03142 currentAST.root = init_opt_AST; 03143 if ( init_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03144 init_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03145 currentAST.child = init_opt_AST->getFirstChild(); 03146 else 03147 currentAST.child = init_opt_AST; 03148 currentAST.advanceChildToEnd(); 03149 } 03150 init_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03151 } 03152 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03153 if( inputState->guessing == 0 ) { 03154 reportError(ex); 03155 consume(); 03156 consumeUntil(_tokenSet_37); 03157 } else { 03158 throw; 03159 } 03160 } 03161 returnAST = init_opt_AST; 03162 } 03163 03164 void AdaParser::defining_identifier_list() { 03165 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03166 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03167 RefAdaAST defining_identifier_list_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03168 03169 try { // for error handling 03170 RefAdaAST tmp86_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03171 if ( inputState->guessing == 0 ) { 03172 tmp86_AST = astFactory->create(LT(1)); 03173 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp86_AST.get())); 03174 } 03175 match(IDENTIFIER); 03176 { // ( ... )* 03177 for (;;) { 03178 if ((LA(1) == COMMA)) { 03179 match(COMMA); 03180 RefAdaAST tmp88_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03181 if ( inputState->guessing == 0 ) { 03182 tmp88_AST = astFactory->create(LT(1)); 03183 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp88_AST.get())); 03184 } 03185 match(IDENTIFIER); 03186 } 03187 else { 03188 goto _loop79; 03189 } 03190 03191 } 03192 _loop79:; 03193 } // ( ... )* 03194 if ( inputState->guessing==0 ) { 03195 defining_identifier_list_AST = RefAdaAST(currentAST.root); 03196 #line 248 "ada.g" 03197 defining_identifier_list_AST = 03198 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DEFINING_IDENTIFIER_LIST,"DEFINING_IDENTIFIER_LIST").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(defining_identifier_list_AST.get())))); 03199 #line 3200 "AdaParser.cpp" 03200 currentAST.root = defining_identifier_list_AST; 03201 if ( defining_identifier_list_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03202 defining_identifier_list_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03203 currentAST.child = defining_identifier_list_AST->getFirstChild(); 03204 else 03205 currentAST.child = defining_identifier_list_AST; 03206 currentAST.advanceChildToEnd(); 03207 } 03208 defining_identifier_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03209 } 03210 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03211 if( inputState->guessing == 0 ) { 03212 reportError(ex); 03213 consume(); 03214 consumeUntil(_tokenSet_40); 03215 } else { 03216 throw; 03217 } 03218 } 03219 returnAST = defining_identifier_list_AST; 03220 } 03221 03222 void AdaParser::name() { 03223 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03224 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03225 RefAdaAST name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03226 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 03227 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03228 #line 264 "ada.g" 03229 RefAdaAST dummy; 03230 #line 3231 "AdaParser.cpp" 03231 03232 try { // for error handling 03233 RefAdaAST tmp89_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03234 if ( inputState->guessing == 0 ) { 03235 tmp89_AST = astFactory->create(LT(1)); 03236 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp89_AST.get())); 03237 } 03238 match(IDENTIFIER); 03239 { // ( ... )* 03240 for (;;) { 03241 switch ( LA(1)) { 03242 case DOT: 03243 { 03244 RefAdaAST tmp90_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03245 if ( inputState->guessing == 0 ) { 03246 tmp90_AST = astFactory->create(LT(1)); 03247 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp90_AST.get())); 03248 } 03249 match(DOT); 03250 { 03251 switch ( LA(1)) { 03252 case ALL: 03253 { 03254 RefAdaAST tmp91_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03255 if ( inputState->guessing == 0 ) { 03256 tmp91_AST = astFactory->create(LT(1)); 03257 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp91_AST.get())); 03258 } 03259 match(ALL); 03260 break; 03261 } 03262 case IDENTIFIER: 03263 { 03264 RefAdaAST tmp92_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03265 if ( inputState->guessing == 0 ) { 03266 tmp92_AST = astFactory->create(LT(1)); 03267 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp92_AST.get())); 03268 } 03269 match(IDENTIFIER); 03270 break; 03271 } 03272 case CHARACTER_LITERAL: 03273 { 03274 RefAdaAST tmp93_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03275 if ( inputState->guessing == 0 ) { 03276 tmp93_AST = astFactory->create(LT(1)); 03277 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp93_AST.get())); 03278 } 03279 match(CHARACTER_LITERAL); 03280 break; 03281 } 03282 case CHAR_STRING: 03283 { 03284 dummy=is_operator(); 03285 if (inputState->guessing==0) { 03286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03287 } 03288 break; 03289 } 03290 default: 03291 { 03292 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03293 } 03294 } 03295 } 03296 break; 03297 } 03298 case LPAREN: 03299 { 03300 p = LT(1); 03301 if ( inputState->guessing == 0 ) { 03302 p_AST = astFactory->create(p); 03303 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 03304 } 03305 match(LPAREN); 03306 value_s(); 03307 if (inputState->guessing==0) { 03308 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03309 } 03310 match(RPAREN); 03311 if ( inputState->guessing==0 ) { 03312 #line 272 "ada.g" 03313 Set(p_AST, INDEXED_COMPONENT); 03314 #line 3315 "AdaParser.cpp" 03315 } 03316 break; 03317 } 03318 case TIC: 03319 { 03320 RefAdaAST tmp95_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03321 if ( inputState->guessing == 0 ) { 03322 tmp95_AST = astFactory->create(LT(1)); 03323 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp95_AST.get())); 03324 } 03325 match(TIC); 03326 attribute_id(); 03327 if (inputState->guessing==0) { 03328 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03329 } 03330 break; 03331 } 03332 default: 03333 { 03334 goto _loop88; 03335 } 03336 } 03337 } 03338 _loop88:; 03339 } // ( ... )* 03340 name_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03341 } 03342 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03343 if( inputState->guessing == 0 ) { 03344 reportError(ex); 03345 consume(); 03346 consumeUntil(_tokenSet_41); 03347 } else { 03348 throw; 03349 } 03350 } 03351 returnAST = name_AST; 03352 } 03353 03354 RefAdaAST AdaParser::definable_operator_symbol() { 03355 #line 284 "ada.g" 03356 RefAdaAST d; 03357 #line 3358 "AdaParser.cpp" 03358 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03359 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03360 RefAdaAST definable_operator_symbol_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03361 ANTLR_USE_NAMESPACE(antlr)RefToken op = ANTLR_USE_NAMESPACE(antlr)nullToken; 03362 RefAdaAST op_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03363 03364 try { // for error handling 03365 if (!( definable_operator(LT(1)->getText().c_str()) )) 03366 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" definable_operator(LT(1)->getText().c_str()) "); 03367 op = LT(1); 03368 if ( inputState->guessing == 0 ) { 03369 op_AST = astFactory->create(op); 03370 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(op_AST.get())); 03371 } 03372 match(CHAR_STRING); 03373 if ( inputState->guessing==0 ) { 03374 #line 286 "ada.g" 03375 op_AST->setType(OPERATOR_SYMBOL); d=op_AST; 03376 #line 3377 "AdaParser.cpp" 03377 } 03378 definable_operator_symbol_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03379 } 03380 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03381 if( inputState->guessing == 0 ) { 03382 reportError(ex); 03383 consume(); 03384 consumeUntil(_tokenSet_42); 03385 } else { 03386 throw; 03387 } 03388 } 03389 returnAST = definable_operator_symbol_AST; 03390 return d; 03391 } 03392 03393 RefAdaAST AdaParser::is_operator() { 03394 #line 279 "ada.g" 03395 RefAdaAST d; 03396 #line 3397 "AdaParser.cpp" 03397 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03398 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03399 RefAdaAST is_operator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03400 ANTLR_USE_NAMESPACE(antlr)RefToken op = ANTLR_USE_NAMESPACE(antlr)nullToken; 03401 RefAdaAST op_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03402 03403 try { // for error handling 03404 if (!( is_operator_symbol(LT(1)->getText().c_str()) )) 03405 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(LT(1)->getText().c_str()) "); 03406 op = LT(1); 03407 if ( inputState->guessing == 0 ) { 03408 op_AST = astFactory->create(op); 03409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(op_AST.get())); 03410 } 03411 match(CHAR_STRING); 03412 if ( inputState->guessing==0 ) { 03413 #line 281 "ada.g" 03414 op_AST->setType(OPERATOR_SYMBOL); d=op_AST; 03415 #line 3416 "AdaParser.cpp" 03416 } 03417 is_operator_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03418 } 03419 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03420 if( inputState->guessing == 0 ) { 03421 reportError(ex); 03422 consume(); 03423 consumeUntil(_tokenSet_43); 03424 } else { 03425 throw; 03426 } 03427 } 03428 returnAST = is_operator_AST; 03429 return d; 03430 } 03431 03432 void AdaParser::parenthesized_primary() { 03433 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03434 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03435 RefAdaAST parenthesized_primary_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03436 ANTLR_USE_NAMESPACE(antlr)RefToken pp = ANTLR_USE_NAMESPACE(antlr)nullToken; 03437 RefAdaAST pp_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03438 03439 try { // for error handling 03440 pp = LT(1); 03441 if ( inputState->guessing == 0 ) { 03442 pp_AST = astFactory->create(pp); 03443 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pp_AST.get())); 03444 } 03445 match(LPAREN); 03446 { 03447 if ((LA(1) == NuLL) && (LA(2) == RECORD)) { 03448 RefAdaAST tmp96_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03449 if ( inputState->guessing == 0 ) { 03450 tmp96_AST = astFactory->create(LT(1)); 03451 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp96_AST.get())); 03452 } 03453 match(NuLL); 03454 match(RECORD); 03455 } 03456 else if ((_tokenSet_44.member(LA(1))) && (_tokenSet_45.member(LA(2)))) { 03457 value_s(); 03458 if (inputState->guessing==0) { 03459 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03460 } 03461 extension_opt(); 03462 if (inputState->guessing==0) { 03463 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03464 } 03465 } 03466 else { 03467 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03468 } 03469 03470 } 03471 match(RPAREN); 03472 if ( inputState->guessing==0 ) { 03473 #line 294 "ada.g" 03474 Set(pp_AST, PARENTHESIZED_PRIMARY); 03475 #line 3476 "AdaParser.cpp" 03476 } 03477 parenthesized_primary_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03478 } 03479 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03480 if( inputState->guessing == 0 ) { 03481 reportError(ex); 03482 consume(); 03483 consumeUntil(_tokenSet_43); 03484 } else { 03485 throw; 03486 } 03487 } 03488 returnAST = parenthesized_primary_AST; 03489 } 03490 03491 void AdaParser::extension_opt() { 03492 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03493 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03494 RefAdaAST extension_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03495 03496 try { // for error handling 03497 { 03498 switch ( LA(1)) { 03499 case WITH: 03500 { 03501 match(WITH); 03502 { 03503 if ((LA(1) == NuLL) && (LA(2) == RECORD)) { 03504 RefAdaAST tmp100_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03505 if ( inputState->guessing == 0 ) { 03506 tmp100_AST = astFactory->create(LT(1)); 03507 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp100_AST.get())); 03508 } 03509 match(NuLL); 03510 match(RECORD); 03511 } 03512 else if ((_tokenSet_44.member(LA(1))) && (_tokenSet_46.member(LA(2)))) { 03513 value_s(); 03514 if (inputState->guessing==0) { 03515 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03516 } 03517 } 03518 else { 03519 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03520 } 03521 03522 } 03523 break; 03524 } 03525 case RPAREN: 03526 { 03527 break; 03528 } 03529 default: 03530 { 03531 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03532 } 03533 } 03534 } 03535 if ( inputState->guessing==0 ) { 03536 extension_opt_AST = RefAdaAST(currentAST.root); 03537 #line 298 "ada.g" 03538 extension_opt_AST = 03539 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXTENSION_OPT,"EXTENSION_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(extension_opt_AST.get())))); 03540 #line 3541 "AdaParser.cpp" 03541 currentAST.root = extension_opt_AST; 03542 if ( extension_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03543 extension_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03544 currentAST.child = extension_opt_AST->getFirstChild(); 03545 else 03546 currentAST.child = extension_opt_AST; 03547 currentAST.advanceChildToEnd(); 03548 } 03549 extension_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03550 } 03551 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03552 if( inputState->guessing == 0 ) { 03553 reportError(ex); 03554 consume(); 03555 consumeUntil(_tokenSet_47); 03556 } else { 03557 throw; 03558 } 03559 } 03560 returnAST = extension_opt_AST; 03561 } 03562 03563 void AdaParser::separate_or_abstract( 03564 RefAdaAST t 03565 ) { 03566 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03567 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03568 RefAdaAST separate_or_abstract_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03569 03570 try { // for error handling 03571 switch ( LA(1)) { 03572 case SEPARATE: 03573 { 03574 match(SEPARATE); 03575 if ( inputState->guessing==0 ) { 03576 #line 314 "ada.g" 03577 pop_def_id(); 03578 if (t->getType() == AdaTokenTypes::PROCEDURE) 03579 Set(t, PROCEDURE_BODY_STUB); 03580 else 03581 Set(t, FUNCTION_BODY_STUB); 03582 03583 #line 3584 "AdaParser.cpp" 03584 } 03585 break; 03586 } 03587 case ABSTRACT: 03588 { 03589 match(ABSTRACT); 03590 if ( inputState->guessing==0 ) { 03591 #line 321 "ada.g" 03592 pop_def_id(); 03593 if (t->getType() == AdaTokenTypes::PROCEDURE) 03594 Set(t, ABSTRACT_PROCEDURE_DECLARATION); 03595 else 03596 Set(t, ABSTRACT_FUNCTION_DECLARATION); 03597 03598 #line 3599 "AdaParser.cpp" 03599 } 03600 break; 03601 } 03602 default: 03603 { 03604 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03605 } 03606 } 03607 } 03608 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03609 if( inputState->guessing == 0 ) { 03610 reportError(ex); 03611 consume(); 03612 consumeUntil(_tokenSet_4); 03613 } else { 03614 throw; 03615 } 03616 } 03617 returnAST = separate_or_abstract_AST; 03618 } 03619 03620 RefAdaAST AdaParser::designator() { 03621 #line 335 "ada.g" 03622 RefAdaAST d; 03623 #line 3624 "AdaParser.cpp" 03624 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03625 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03626 RefAdaAST designator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03627 ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; 03628 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03629 #line 335 "ada.g" 03630 RefAdaAST op; 03631 #line 3632 "AdaParser.cpp" 03632 03633 try { // for error handling 03634 switch ( LA(1)) { 03635 case CHAR_STRING: 03636 { 03637 op=definable_operator_symbol(); 03638 if (inputState->guessing==0) { 03639 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03640 } 03641 if ( inputState->guessing==0 ) { 03642 #line 337 "ada.g" 03643 d = op; 03644 #line 3645 "AdaParser.cpp" 03645 } 03646 designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03647 break; 03648 } 03649 case IDENTIFIER: 03650 { 03651 n = LT(1); 03652 if ( inputState->guessing == 0 ) { 03653 n_AST = astFactory->create(n); 03654 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get())); 03655 } 03656 match(IDENTIFIER); 03657 if ( inputState->guessing==0 ) { 03658 #line 338 "ada.g" 03659 d = n_AST; 03660 #line 3661 "AdaParser.cpp" 03661 } 03662 designator_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03663 break; 03664 } 03665 default: 03666 { 03667 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03668 } 03669 } 03670 } 03671 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03672 if( inputState->guessing == 0 ) { 03673 reportError(ex); 03674 consume(); 03675 consumeUntil(_tokenSet_26); 03676 } else { 03677 throw; 03678 } 03679 } 03680 returnAST = designator_AST; 03681 return d; 03682 } 03683 03684 void AdaParser::func_formal_part_opt() { 03685 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03686 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03687 RefAdaAST func_formal_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03688 03689 try { // for error handling 03690 { 03691 switch ( LA(1)) { 03692 case LPAREN: 03693 { 03694 match(LPAREN); 03695 func_param(); 03696 if (inputState->guessing==0) { 03697 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03698 } 03699 { // ( ... )* 03700 for (;;) { 03701 if ((LA(1) == SEMI)) { 03702 match(SEMI); 03703 func_param(); 03704 if (inputState->guessing==0) { 03705 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03706 } 03707 } 03708 else { 03709 goto _loop104; 03710 } 03711 03712 } 03713 _loop104:; 03714 } // ( ... )* 03715 match(RPAREN); 03716 break; 03717 } 03718 case RETURN: 03719 { 03720 break; 03721 } 03722 default: 03723 { 03724 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03725 } 03726 } 03727 } 03728 if ( inputState->guessing==0 ) { 03729 func_formal_part_opt_AST = RefAdaAST(currentAST.root); 03730 #line 347 "ada.g" 03731 func_formal_part_opt_AST = 03732 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(FORMAL_PART_OPT,"FORMAL_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(func_formal_part_opt_AST.get())))); 03733 #line 3734 "AdaParser.cpp" 03734 currentAST.root = func_formal_part_opt_AST; 03735 if ( func_formal_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03736 func_formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03737 currentAST.child = func_formal_part_opt_AST->getFirstChild(); 03738 else 03739 currentAST.child = func_formal_part_opt_AST; 03740 currentAST.advanceChildToEnd(); 03741 } 03742 func_formal_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03743 } 03744 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03745 if( inputState->guessing == 0 ) { 03746 reportError(ex); 03747 consume(); 03748 consumeUntil(_tokenSet_48); 03749 } else { 03750 throw; 03751 } 03752 } 03753 returnAST = func_formal_part_opt_AST; 03754 } 03755 03756 void AdaParser::func_param() { 03757 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03758 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03759 RefAdaAST func_param_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03760 03761 try { // for error handling 03762 def_ids_colon(); 03763 if (inputState->guessing==0) { 03764 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03765 } 03766 in_access_opt(); 03767 if (inputState->guessing==0) { 03768 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03769 } 03770 subtype_mark(); 03771 if (inputState->guessing==0) { 03772 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03773 } 03774 init_opt(); 03775 if (inputState->guessing==0) { 03776 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03777 } 03778 if ( inputState->guessing==0 ) { 03779 func_param_AST = RefAdaAST(currentAST.root); 03780 #line 353 "ada.g" 03781 func_param_AST = 03782 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PARAMETER_SPECIFICATION,"PARAMETER_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(func_param_AST.get())))); 03783 #line 3784 "AdaParser.cpp" 03784 currentAST.root = func_param_AST; 03785 if ( func_param_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03786 func_param_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03787 currentAST.child = func_param_AST->getFirstChild(); 03788 else 03789 currentAST.child = func_param_AST; 03790 currentAST.advanceChildToEnd(); 03791 } 03792 func_param_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03793 } 03794 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03795 if( inputState->guessing == 0 ) { 03796 reportError(ex); 03797 consume(); 03798 consumeUntil(_tokenSet_37); 03799 } else { 03800 throw; 03801 } 03802 } 03803 returnAST = func_param_AST; 03804 } 03805 03806 void AdaParser::in_access_opt() { 03807 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03808 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03809 RefAdaAST in_access_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03810 03811 try { // for error handling 03812 { 03813 switch ( LA(1)) { 03814 case IN: 03815 { 03816 match(IN); 03817 break; 03818 } 03819 case ACCESS: 03820 { 03821 RefAdaAST tmp108_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03822 if ( inputState->guessing == 0 ) { 03823 tmp108_AST = astFactory->create(LT(1)); 03824 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp108_AST.get())); 03825 } 03826 match(ACCESS); 03827 break; 03828 } 03829 case IDENTIFIER: 03830 { 03831 break; 03832 } 03833 default: 03834 { 03835 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03836 } 03837 } 03838 } 03839 if ( inputState->guessing==0 ) { 03840 in_access_opt_AST = RefAdaAST(currentAST.root); 03841 #line 359 "ada.g" 03842 in_access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(in_access_opt_AST.get())))); 03843 #line 3844 "AdaParser.cpp" 03844 currentAST.root = in_access_opt_AST; 03845 if ( in_access_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03846 in_access_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03847 currentAST.child = in_access_opt_AST->getFirstChild(); 03848 else 03849 currentAST.child = in_access_opt_AST; 03850 currentAST.advanceChildToEnd(); 03851 } 03852 in_access_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03853 } 03854 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03855 if( inputState->guessing == 0 ) { 03856 reportError(ex); 03857 consume(); 03858 consumeUntil(_tokenSet_39); 03859 } else { 03860 throw; 03861 } 03862 } 03863 returnAST = in_access_opt_AST; 03864 } 03865 03866 void AdaParser::pkg_spec_part() { 03867 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03868 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03869 RefAdaAST pkg_spec_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03870 03871 try { // for error handling 03872 basic_declarative_items_opt(); 03873 if (inputState->guessing==0) { 03874 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03875 } 03876 { 03877 switch ( LA(1)) { 03878 case PRIVATE: 03879 { 03880 match(PRIVATE); 03881 basic_declarative_items_opt(); 03882 if (inputState->guessing==0) { 03883 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03884 } 03885 break; 03886 } 03887 case END: 03888 { 03889 break; 03890 } 03891 default: 03892 { 03893 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 03894 } 03895 } 03896 } 03897 end_id_opt(); 03898 pkg_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03899 } 03900 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03901 if( inputState->guessing == 0 ) { 03902 reportError(ex); 03903 consume(); 03904 consumeUntil(_tokenSet_4); 03905 } else { 03906 throw; 03907 } 03908 } 03909 returnAST = pkg_spec_part_AST; 03910 } 03911 03912 void AdaParser::basic_declarative_items_opt() { 03913 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03914 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03915 RefAdaAST basic_declarative_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03916 03917 try { // for error handling 03918 { // ( ... )* 03919 for (;;) { 03920 switch ( LA(1)) { 03921 case IDENTIFIER: 03922 case USE: 03923 case TYPE: 03924 case PACKAGE: 03925 case PROCEDURE: 03926 case FUNCTION: 03927 case TASK: 03928 case PROTECTED: 03929 case FOR: 03930 case SUBTYPE: 03931 case GENERIC: 03932 { 03933 basic_decl_item(); 03934 if (inputState->guessing==0) { 03935 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03936 } 03937 break; 03938 } 03939 case PRAGMA: 03940 { 03941 pragma(); 03942 if (inputState->guessing==0) { 03943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 03944 } 03945 break; 03946 } 03947 default: 03948 { 03949 goto _loop115; 03950 } 03951 } 03952 } 03953 _loop115:; 03954 } // ( ... )* 03955 if ( inputState->guessing==0 ) { 03956 basic_declarative_items_opt_AST = RefAdaAST(currentAST.root); 03957 #line 377 "ada.g" 03958 basic_declarative_items_opt_AST = 03959 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(basic_declarative_items_opt_AST.get())))); 03960 #line 3961 "AdaParser.cpp" 03961 currentAST.root = basic_declarative_items_opt_AST; 03962 if ( basic_declarative_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 03963 basic_declarative_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 03964 currentAST.child = basic_declarative_items_opt_AST->getFirstChild(); 03965 else 03966 currentAST.child = basic_declarative_items_opt_AST; 03967 currentAST.advanceChildToEnd(); 03968 } 03969 basic_declarative_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 03970 } 03971 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 03972 if( inputState->guessing == 0 ) { 03973 reportError(ex); 03974 consume(); 03975 consumeUntil(_tokenSet_49); 03976 } else { 03977 throw; 03978 } 03979 } 03980 returnAST = basic_declarative_items_opt_AST; 03981 } 03982 03983 void AdaParser::basic_decl_item() { 03984 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03985 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 03986 RefAdaAST basic_decl_item_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03987 ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken; 03988 RefAdaAST pkg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03989 ANTLR_USE_NAMESPACE(antlr)RefToken tsk = ANTLR_USE_NAMESPACE(antlr)nullToken; 03990 RefAdaAST tsk_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03991 ANTLR_USE_NAMESPACE(antlr)RefToken pro = ANTLR_USE_NAMESPACE(antlr)nullToken; 03992 RefAdaAST pro_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 03993 03994 try { // for error handling 03995 switch ( LA(1)) { 03996 case PACKAGE: 03997 { 03998 pkg = LT(1); 03999 if ( inputState->guessing == 0 ) { 04000 pkg_AST = astFactory->create(pkg); 04001 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get())); 04002 } 04003 match(PACKAGE); 04004 def_id(false); 04005 if (inputState->guessing==0) { 04006 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04007 } 04008 spec_decl_part(pkg_AST); 04009 if (inputState->guessing==0) { 04010 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04011 } 04012 basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04013 break; 04014 } 04015 case TASK: 04016 { 04017 tsk = LT(1); 04018 if ( inputState->guessing == 0 ) { 04019 tsk_AST = astFactory->create(tsk); 04020 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tsk_AST.get())); 04021 } 04022 match(TASK); 04023 task_type_or_single_decl(tsk_AST); 04024 if (inputState->guessing==0) { 04025 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04026 } 04027 basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04028 break; 04029 } 04030 case PROTECTED: 04031 { 04032 pro = LT(1); 04033 if ( inputState->guessing == 0 ) { 04034 pro_AST = astFactory->create(pro); 04035 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pro_AST.get())); 04036 } 04037 match(PROTECTED); 04038 prot_type_or_single_decl(pro_AST); 04039 if (inputState->guessing==0) { 04040 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04041 } 04042 match(SEMI); 04043 basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04044 break; 04045 } 04046 case PROCEDURE: 04047 case FUNCTION: 04048 { 04049 subprog_decl(false); 04050 if (inputState->guessing==0) { 04051 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04052 } 04053 basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04054 break; 04055 } 04056 case IDENTIFIER: 04057 case USE: 04058 case TYPE: 04059 case FOR: 04060 case SUBTYPE: 04061 case GENERIC: 04062 { 04063 decl_common(); 04064 if (inputState->guessing==0) { 04065 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04066 } 04067 basic_decl_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04068 break; 04069 } 04070 default: 04071 { 04072 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04073 } 04074 } 04075 } 04076 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04077 if( inputState->guessing == 0 ) { 04078 reportError(ex); 04079 consume(); 04080 consumeUntil(_tokenSet_23); 04081 } else { 04082 throw; 04083 } 04084 } 04085 returnAST = basic_decl_item_AST; 04086 } 04087 04088 void AdaParser::basic_declarative_items() { 04089 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04090 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04091 RefAdaAST basic_declarative_items_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04092 04093 try { // for error handling 04094 { // ( ... )+ 04095 int _cnt118=0; 04096 for (;;) { 04097 switch ( LA(1)) { 04098 case IDENTIFIER: 04099 case USE: 04100 case TYPE: 04101 case PACKAGE: 04102 case PROCEDURE: 04103 case FUNCTION: 04104 case TASK: 04105 case PROTECTED: 04106 case FOR: 04107 case SUBTYPE: 04108 case GENERIC: 04109 { 04110 basic_decl_item(); 04111 if (inputState->guessing==0) { 04112 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04113 } 04114 break; 04115 } 04116 case PRAGMA: 04117 { 04118 pragma(); 04119 if (inputState->guessing==0) { 04120 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04121 } 04122 break; 04123 } 04124 default: 04125 { 04126 if ( _cnt118>=1 ) { goto _loop118; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} 04127 } 04128 } 04129 _cnt118++; 04130 } 04131 _loop118:; 04132 } // ( ... )+ 04133 if ( inputState->guessing==0 ) { 04134 basic_declarative_items_AST = RefAdaAST(currentAST.root); 04135 #line 384 "ada.g" 04136 basic_declarative_items_AST = 04137 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BASIC_DECLARATIVE_ITEMS_OPT,"BASIC_DECLARATIVE_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(basic_declarative_items_AST.get())))); 04138 #line 4139 "AdaParser.cpp" 04139 currentAST.root = basic_declarative_items_AST; 04140 if ( basic_declarative_items_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 04141 basic_declarative_items_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 04142 currentAST.child = basic_declarative_items_AST->getFirstChild(); 04143 else 04144 currentAST.child = basic_declarative_items_AST; 04145 currentAST.advanceChildToEnd(); 04146 } 04147 basic_declarative_items_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04148 } 04149 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04150 if( inputState->guessing == 0 ) { 04151 reportError(ex); 04152 consume(); 04153 consumeUntil(_tokenSet_0); 04154 } else { 04155 throw; 04156 } 04157 } 04158 returnAST = basic_declarative_items_AST; 04159 } 04160 04161 void AdaParser::task_type_or_single_decl( 04162 RefAdaAST tsk 04163 ) { 04164 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04165 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04166 RefAdaAST task_type_or_single_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04167 04168 try { // for error handling 04169 switch ( LA(1)) { 04170 case TYPE: 04171 { 04172 match(TYPE); 04173 def_id(false); 04174 if (inputState->guessing==0) { 04175 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04176 } 04177 discrim_part_opt(); 04178 if (inputState->guessing==0) { 04179 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04180 } 04181 task_definition_opt(); 04182 if (inputState->guessing==0) { 04183 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04184 } 04185 if ( inputState->guessing==0 ) { 04186 #line 400 "ada.g" 04187 Set(tsk, TASK_TYPE_DECLARATION); 04188 #line 4189 "AdaParser.cpp" 04189 } 04190 task_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04191 break; 04192 } 04193 case IDENTIFIER: 04194 { 04195 def_id(false); 04196 if (inputState->guessing==0) { 04197 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04198 } 04199 task_definition_opt(); 04200 if (inputState->guessing==0) { 04201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04202 } 04203 if ( inputState->guessing==0 ) { 04204 #line 402 "ada.g" 04205 Set(tsk, SINGLE_TASK_DECLARATION); 04206 #line 4207 "AdaParser.cpp" 04207 } 04208 task_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04209 break; 04210 } 04211 default: 04212 { 04213 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04214 } 04215 } 04216 } 04217 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04218 if( inputState->guessing == 0 ) { 04219 reportError(ex); 04220 consume(); 04221 consumeUntil(_tokenSet_18); 04222 } else { 04223 throw; 04224 } 04225 } 04226 returnAST = task_type_or_single_decl_AST; 04227 } 04228 04229 void AdaParser::prot_type_or_single_decl( 04230 RefAdaAST pro 04231 ) { 04232 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04233 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04234 RefAdaAST prot_type_or_single_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04235 04236 try { // for error handling 04237 switch ( LA(1)) { 04238 case TYPE: 04239 { 04240 match(TYPE); 04241 def_id(false); 04242 if (inputState->guessing==0) { 04243 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04244 } 04245 discrim_part_opt(); 04246 if (inputState->guessing==0) { 04247 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04248 } 04249 protected_definition(); 04250 if (inputState->guessing==0) { 04251 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04252 } 04253 if ( inputState->guessing==0 ) { 04254 #line 531 "ada.g" 04255 Set(pro, PROTECTED_TYPE_DECLARATION); 04256 #line 4257 "AdaParser.cpp" 04257 } 04258 prot_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04259 break; 04260 } 04261 case IDENTIFIER: 04262 { 04263 def_id(false); 04264 if (inputState->guessing==0) { 04265 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04266 } 04267 protected_definition(); 04268 if (inputState->guessing==0) { 04269 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04270 } 04271 if ( inputState->guessing==0 ) { 04272 #line 533 "ada.g" 04273 Set(pro, SINGLE_PROTECTED_DECLARATION); 04274 #line 4275 "AdaParser.cpp" 04275 } 04276 prot_type_or_single_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04277 break; 04278 } 04279 default: 04280 { 04281 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04282 } 04283 } 04284 } 04285 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04286 if( inputState->guessing == 0 ) { 04287 reportError(ex); 04288 consume(); 04289 consumeUntil(_tokenSet_4); 04290 } else { 04291 throw; 04292 } 04293 } 04294 returnAST = prot_type_or_single_decl_AST; 04295 } 04296 04297 void AdaParser::decl_common() { 04298 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04299 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04300 RefAdaAST decl_common_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04301 ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; 04302 RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04303 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 04304 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04305 ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; 04306 RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04307 ANTLR_USE_NAMESPACE(antlr)RefToken erd = ANTLR_USE_NAMESPACE(antlr)nullToken; 04308 RefAdaAST erd_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04309 ANTLR_USE_NAMESPACE(antlr)RefToken ord = ANTLR_USE_NAMESPACE(antlr)nullToken; 04310 RefAdaAST ord_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04311 ANTLR_USE_NAMESPACE(antlr)RefToken od = ANTLR_USE_NAMESPACE(antlr)nullToken; 04312 RefAdaAST od_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04313 04314 try { // for error handling 04315 switch ( LA(1)) { 04316 case TYPE: 04317 { 04318 t = LT(1); 04319 if ( inputState->guessing == 0 ) { 04320 t_AST = astFactory->create(t); 04321 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get())); 04322 } 04323 match(TYPE); 04324 RefAdaAST tmp113_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04325 if ( inputState->guessing == 0 ) { 04326 tmp113_AST = astFactory->create(LT(1)); 04327 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp113_AST.get())); 04328 } 04329 match(IDENTIFIER); 04330 { 04331 switch ( LA(1)) { 04332 case IS: 04333 { 04334 match(IS); 04335 type_def(t_AST); 04336 if (inputState->guessing==0) { 04337 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04338 } 04339 break; 04340 } 04341 case SEMI: 04342 case LPAREN: 04343 { 04344 { 04345 switch ( LA(1)) { 04346 case LPAREN: 04347 { 04348 discrim_part(); 04349 if (inputState->guessing==0) { 04350 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04351 } 04352 { 04353 switch ( LA(1)) { 04354 case IS: 04355 { 04356 match(IS); 04357 derived_or_private_or_record(t_AST, true); 04358 if (inputState->guessing==0) { 04359 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04360 } 04361 break; 04362 } 04363 case SEMI: 04364 { 04365 if ( inputState->guessing==0 ) { 04366 #line 573 "ada.g" 04367 Set(t_AST, INCOMPLETE_TYPE_DECLARATION); 04368 #line 4369 "AdaParser.cpp" 04369 } 04370 break; 04371 } 04372 default: 04373 { 04374 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04375 } 04376 } 04377 } 04378 break; 04379 } 04380 case SEMI: 04381 { 04382 empty_discrim_opt(); 04383 if (inputState->guessing==0) { 04384 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04385 } 04386 if ( inputState->guessing==0 ) { 04387 #line 576 "ada.g" 04388 Set(t_AST, INCOMPLETE_TYPE_DECLARATION); 04389 #line 4390 "AdaParser.cpp" 04390 } 04391 break; 04392 } 04393 default: 04394 { 04395 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04396 } 04397 } 04398 } 04399 break; 04400 } 04401 default: 04402 { 04403 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04404 } 04405 } 04406 } 04407 match(SEMI); 04408 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04409 break; 04410 } 04411 case SUBTYPE: 04412 { 04413 s = LT(1); 04414 if ( inputState->guessing == 0 ) { 04415 s_AST = astFactory->create(s); 04416 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 04417 } 04418 match(SUBTYPE); 04419 RefAdaAST tmp117_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04420 if ( inputState->guessing == 0 ) { 04421 tmp117_AST = astFactory->create(LT(1)); 04422 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp117_AST.get())); 04423 } 04424 match(IDENTIFIER); 04425 match(IS); 04426 subtype_ind(); 04427 if (inputState->guessing==0) { 04428 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04429 } 04430 match(SEMI); 04431 if ( inputState->guessing==0 ) { 04432 #line 590 "ada.g" 04433 Set(s_AST, SUBTYPE_DECLARATION); 04434 #line 4435 "AdaParser.cpp" 04435 } 04436 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04437 break; 04438 } 04439 case GENERIC: 04440 { 04441 generic_decl(false); 04442 if (inputState->guessing==0) { 04443 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04444 } 04445 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04446 break; 04447 } 04448 case USE: 04449 { 04450 use_clause(); 04451 if (inputState->guessing==0) { 04452 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04453 } 04454 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04455 break; 04456 } 04457 case FOR: 04458 { 04459 r = LT(1); 04460 if ( inputState->guessing == 0 ) { 04461 r_AST = astFactory->create(r); 04462 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get())); 04463 } 04464 match(FOR); 04465 { 04466 bool synPredMatched182 = false; 04467 if (((LA(1) == IDENTIFIER) && (LA(2) == USE))) { 04468 int _m182 = mark(); 04469 synPredMatched182 = true; 04470 inputState->guessing++; 04471 try { 04472 { 04473 local_enum_name(); 04474 match(USE); 04475 match(LPAREN); 04476 } 04477 } 04478 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 04479 synPredMatched182 = false; 04480 } 04481 rewind(_m182); 04482 inputState->guessing--; 04483 } 04484 if ( synPredMatched182 ) { 04485 local_enum_name(); 04486 if (inputState->guessing==0) { 04487 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04488 } 04489 match(USE); 04490 enumeration_aggregate(); 04491 if (inputState->guessing==0) { 04492 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04493 } 04494 if ( inputState->guessing==0 ) { 04495 #line 595 "ada.g" 04496 Set(r_AST, ENUMERATION_REPESENTATION_CLAUSE); 04497 #line 4498 "AdaParser.cpp" 04498 } 04499 } 04500 else if ((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == USE || LA(2) == TIC)) { 04501 subtype_mark(); 04502 if (inputState->guessing==0) { 04503 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04504 } 04505 match(USE); 04506 rep_spec_part(r_AST); 04507 if (inputState->guessing==0) { 04508 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04509 } 04510 } 04511 else { 04512 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04513 } 04514 04515 } 04516 match(SEMI); 04517 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04518 break; 04519 } 04520 default: 04521 bool synPredMatched184 = false; 04522 if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) { 04523 int _m184 = mark(); 04524 synPredMatched184 = true; 04525 inputState->guessing++; 04526 try { 04527 { 04528 match(IDENTIFIER); 04529 match(COLON); 04530 match(EXCEPTION); 04531 match(RENAMES); 04532 } 04533 } 04534 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 04535 synPredMatched184 = false; 04536 } 04537 rewind(_m184); 04538 inputState->guessing--; 04539 } 04540 if ( synPredMatched184 ) { 04541 RefAdaAST tmp123_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04542 if ( inputState->guessing == 0 ) { 04543 tmp123_AST = astFactory->create(LT(1)); 04544 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp123_AST.get())); 04545 } 04546 match(IDENTIFIER); 04547 erd = LT(1); 04548 if ( inputState->guessing == 0 ) { 04549 erd_AST = astFactory->create(erd); 04550 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(erd_AST.get())); 04551 } 04552 match(COLON); 04553 match(EXCEPTION); 04554 match(RENAMES); 04555 compound_name(); 04556 if (inputState->guessing==0) { 04557 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04558 } 04559 match(SEMI); 04560 if ( inputState->guessing==0 ) { 04561 #line 601 "ada.g" 04562 Set(erd_AST, EXCEPTION_RENAMING_DECLARATION); 04563 #line 4564 "AdaParser.cpp" 04564 } 04565 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04566 } 04567 else { 04568 bool synPredMatched186 = false; 04569 if (((LA(1) == IDENTIFIER) && (LA(2) == COLON))) { 04570 int _m186 = mark(); 04571 synPredMatched186 = true; 04572 inputState->guessing++; 04573 try { 04574 { 04575 match(IDENTIFIER); 04576 match(COLON); 04577 subtype_mark(); 04578 match(RENAMES); 04579 } 04580 } 04581 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 04582 synPredMatched186 = false; 04583 } 04584 rewind(_m186); 04585 inputState->guessing--; 04586 } 04587 if ( synPredMatched186 ) { 04588 RefAdaAST tmp127_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04589 if ( inputState->guessing == 0 ) { 04590 tmp127_AST = astFactory->create(LT(1)); 04591 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp127_AST.get())); 04592 } 04593 match(IDENTIFIER); 04594 ord = LT(1); 04595 if ( inputState->guessing == 0 ) { 04596 ord_AST = astFactory->create(ord); 04597 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(ord_AST.get())); 04598 } 04599 match(COLON); 04600 subtype_mark(); 04601 if (inputState->guessing==0) { 04602 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04603 } 04604 match(RENAMES); 04605 name(); 04606 if (inputState->guessing==0) { 04607 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04608 } 04609 match(SEMI); 04610 if ( inputState->guessing==0 ) { 04611 #line 604 "ada.g" 04612 Set(ord_AST, OBJECT_RENAMING_DECLARATION); 04613 #line 4614 "AdaParser.cpp" 04614 } 04615 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04616 } 04617 else if ((LA(1) == IDENTIFIER) && (LA(2) == COMMA || LA(2) == COLON)) { 04618 defining_identifier_list(); 04619 if (inputState->guessing==0) { 04620 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04621 } 04622 od = LT(1); 04623 if ( inputState->guessing == 0 ) { 04624 od_AST = astFactory->create(od); 04625 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(od_AST.get())); 04626 } 04627 match(COLON); 04628 { 04629 if ((LA(1) == EXCEPTION)) { 04630 match(EXCEPTION); 04631 if ( inputState->guessing==0 ) { 04632 #line 607 "ada.g" 04633 Set(od_AST, EXCEPTION_DECLARATION); 04634 #line 4635 "AdaParser.cpp" 04635 } 04636 } 04637 else { 04638 bool synPredMatched189 = false; 04639 if (((LA(1) == CONSTANT) && (LA(2) == ASSIGN))) { 04640 int _m189 = mark(); 04641 synPredMatched189 = true; 04642 inputState->guessing++; 04643 try { 04644 { 04645 match(CONSTANT); 04646 match(ASSIGN); 04647 } 04648 } 04649 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 04650 synPredMatched189 = false; 04651 } 04652 rewind(_m189); 04653 inputState->guessing--; 04654 } 04655 if ( synPredMatched189 ) { 04656 match(CONSTANT); 04657 match(ASSIGN); 04658 expression(); 04659 if (inputState->guessing==0) { 04660 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04661 } 04662 if ( inputState->guessing==0 ) { 04663 #line 609 "ada.g" 04664 Set(od_AST, NUMBER_DECLARATION); 04665 #line 4666 "AdaParser.cpp" 04666 } 04667 } 04668 else if ((_tokenSet_50.member(LA(1))) && (_tokenSet_51.member(LA(2)))) { 04669 aliased_constant_opt(); 04670 if (inputState->guessing==0) { 04671 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04672 } 04673 { 04674 switch ( LA(1)) { 04675 case ARRAY: 04676 { 04677 array_type_definition(od_AST); 04678 if (inputState->guessing==0) { 04679 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04680 } 04681 init_opt(); 04682 if (inputState->guessing==0) { 04683 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04684 } 04685 if ( inputState->guessing==0 ) { 04686 #line 612 "ada.g" 04687 Set(od_AST, ARRAY_OBJECT_DECLARATION); 04688 #line 4689 "AdaParser.cpp" 04689 } 04690 break; 04691 } 04692 case IDENTIFIER: 04693 { 04694 subtype_ind(); 04695 if (inputState->guessing==0) { 04696 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04697 } 04698 init_opt(); 04699 if (inputState->guessing==0) { 04700 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04701 } 04702 if ( inputState->guessing==0 ) { 04703 #line 616 "ada.g" 04704 Set(od_AST, OBJECT_DECLARATION); 04705 #line 4706 "AdaParser.cpp" 04706 } 04707 break; 04708 } 04709 default: 04710 { 04711 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04712 } 04713 } 04714 } 04715 } 04716 else { 04717 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04718 } 04719 } 04720 } 04721 match(SEMI); 04722 decl_common_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04723 } 04724 else { 04725 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04726 } 04727 }} 04728 } 04729 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04730 if( inputState->guessing == 0 ) { 04731 reportError(ex); 04732 consume(); 04733 consumeUntil(_tokenSet_18); 04734 } else { 04735 throw; 04736 } 04737 } 04738 returnAST = decl_common_AST; 04739 } 04740 04741 void AdaParser::discrim_part_opt() { 04742 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04743 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04744 RefAdaAST discrim_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04745 04746 try { // for error handling 04747 { 04748 switch ( LA(1)) { 04749 case LPAREN: 04750 { 04751 discrim_part_text(); 04752 if (inputState->guessing==0) { 04753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04754 } 04755 break; 04756 } 04757 case SEMI: 04758 case IS: 04759 { 04760 break; 04761 } 04762 default: 04763 { 04764 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04765 } 04766 } 04767 } 04768 if ( inputState->guessing==0 ) { 04769 discrim_part_opt_AST = RefAdaAST(currentAST.root); 04770 #line 412 "ada.g" 04771 discrim_part_opt_AST = 04772 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrim_part_opt_AST.get())))); 04773 #line 4774 "AdaParser.cpp" 04774 currentAST.root = discrim_part_opt_AST; 04775 if ( discrim_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 04776 discrim_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 04777 currentAST.child = discrim_part_opt_AST->getFirstChild(); 04778 else 04779 currentAST.child = discrim_part_opt_AST; 04780 currentAST.advanceChildToEnd(); 04781 } 04782 discrim_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04783 } 04784 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04785 if( inputState->guessing == 0 ) { 04786 reportError(ex); 04787 consume(); 04788 consumeUntil(_tokenSet_52); 04789 } else { 04790 throw; 04791 } 04792 } 04793 returnAST = discrim_part_opt_AST; 04794 } 04795 04796 void AdaParser::task_definition_opt() { 04797 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04798 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04799 RefAdaAST task_definition_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04800 04801 try { // for error handling 04802 switch ( LA(1)) { 04803 case IS: 04804 { 04805 match(IS); 04806 task_items_opt(); 04807 if (inputState->guessing==0) { 04808 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04809 } 04810 private_task_items_opt(); 04811 if (inputState->guessing==0) { 04812 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04813 } 04814 end_id_opt(); 04815 match(SEMI); 04816 task_definition_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04817 break; 04818 } 04819 case SEMI: 04820 { 04821 match(SEMI); 04822 if ( inputState->guessing==0 ) { 04823 #line 407 "ada.g" 04824 pop_def_id(); 04825 #line 4826 "AdaParser.cpp" 04826 } 04827 task_definition_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04828 break; 04829 } 04830 default: 04831 { 04832 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04833 } 04834 } 04835 } 04836 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04837 if( inputState->guessing == 0 ) { 04838 reportError(ex); 04839 consume(); 04840 consumeUntil(_tokenSet_18); 04841 } else { 04842 throw; 04843 } 04844 } 04845 returnAST = task_definition_opt_AST; 04846 } 04847 04848 void AdaParser::task_items_opt() { 04849 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04850 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04851 RefAdaAST task_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04852 04853 try { // for error handling 04854 { // ( ... )* 04855 for (;;) { 04856 if ((LA(1) == PRAGMA)) { 04857 pragma(); 04858 if (inputState->guessing==0) { 04859 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04860 } 04861 } 04862 else { 04863 goto _loop139; 04864 } 04865 04866 } 04867 _loop139:; 04868 } // ( ... )* 04869 entrydecls_repspecs_opt(); 04870 if (inputState->guessing==0) { 04871 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04872 } 04873 if ( inputState->guessing==0 ) { 04874 task_items_opt_AST = RefAdaAST(currentAST.root); 04875 #line 465 "ada.g" 04876 task_items_opt_AST = 04877 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TASK_ITEMS_OPT,"TASK_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(task_items_opt_AST.get())))); 04878 #line 4879 "AdaParser.cpp" 04879 currentAST.root = task_items_opt_AST; 04880 if ( task_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 04881 task_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 04882 currentAST.child = task_items_opt_AST->getFirstChild(); 04883 else 04884 currentAST.child = task_items_opt_AST; 04885 currentAST.advanceChildToEnd(); 04886 } 04887 task_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04888 } 04889 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04890 if( inputState->guessing == 0 ) { 04891 reportError(ex); 04892 consume(); 04893 consumeUntil(_tokenSet_49); 04894 } else { 04895 throw; 04896 } 04897 } 04898 returnAST = task_items_opt_AST; 04899 } 04900 04901 void AdaParser::private_task_items_opt() { 04902 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04903 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04904 RefAdaAST private_task_items_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04905 04906 try { // for error handling 04907 { 04908 switch ( LA(1)) { 04909 case PRIVATE: 04910 { 04911 match(PRIVATE); 04912 { // ( ... )* 04913 for (;;) { 04914 if ((LA(1) == PRAGMA)) { 04915 pragma(); 04916 if (inputState->guessing==0) { 04917 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04918 } 04919 } 04920 else { 04921 goto _loop164; 04922 } 04923 04924 } 04925 _loop164:; 04926 } // ( ... )* 04927 entrydecls_repspecs_opt(); 04928 if (inputState->guessing==0) { 04929 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04930 } 04931 break; 04932 } 04933 case END: 04934 { 04935 break; 04936 } 04937 default: 04938 { 04939 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 04940 } 04941 } 04942 } 04943 if ( inputState->guessing==0 ) { 04944 private_task_items_opt_AST = RefAdaAST(currentAST.root); 04945 #line 522 "ada.g" 04946 private_task_items_opt_AST = 04947 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PRIVATE_TASK_ITEMS_OPT,"PRIVATE_TASK_ITEMS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(private_task_items_opt_AST.get())))); 04948 #line 4949 "AdaParser.cpp" 04949 currentAST.root = private_task_items_opt_AST; 04950 if ( private_task_items_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 04951 private_task_items_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 04952 currentAST.child = private_task_items_opt_AST->getFirstChild(); 04953 else 04954 currentAST.child = private_task_items_opt_AST; 04955 currentAST.advanceChildToEnd(); 04956 } 04957 private_task_items_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 04958 } 04959 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 04960 if( inputState->guessing == 0 ) { 04961 reportError(ex); 04962 consume(); 04963 consumeUntil(_tokenSet_21); 04964 } else { 04965 throw; 04966 } 04967 } 04968 returnAST = private_task_items_opt_AST; 04969 } 04970 04971 void AdaParser::discrim_part_text() { 04972 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04973 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 04974 RefAdaAST discrim_part_text_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04975 04976 try { // for error handling 04977 match(LPAREN); 04978 { 04979 switch ( LA(1)) { 04980 case BOX: 04981 { 04982 RefAdaAST tmp139_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 04983 if ( inputState->guessing == 0 ) { 04984 tmp139_AST = astFactory->create(LT(1)); 04985 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp139_AST.get())); 04986 } 04987 match(BOX); 04988 break; 04989 } 04990 case IDENTIFIER: 04991 { 04992 discriminant_specifications(); 04993 if (inputState->guessing==0) { 04994 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 04995 } 04996 break; 04997 } 04998 default: 04999 { 05000 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05001 } 05002 } 05003 } 05004 match(RPAREN); 05005 discrim_part_text_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05006 } 05007 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05008 if( inputState->guessing == 0 ) { 05009 reportError(ex); 05010 consume(); 05011 consumeUntil(_tokenSet_52); 05012 } else { 05013 throw; 05014 } 05015 } 05016 returnAST = discrim_part_text_AST; 05017 } 05018 05019 void AdaParser::discriminant_specifications() { 05020 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05021 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05022 RefAdaAST discriminant_specifications_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05023 05024 try { // for error handling 05025 discriminant_specification(); 05026 if (inputState->guessing==0) { 05027 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05028 } 05029 { // ( ... )* 05030 for (;;) { 05031 if ((LA(1) == SEMI)) { 05032 match(SEMI); 05033 discriminant_specification(); 05034 if (inputState->guessing==0) { 05035 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05036 } 05037 } 05038 else { 05039 goto _loop131; 05040 } 05041 05042 } 05043 _loop131:; 05044 } // ( ... )* 05045 if ( inputState->guessing==0 ) { 05046 discriminant_specifications_AST = RefAdaAST(currentAST.root); 05047 #line 442 "ada.g" 05048 discriminant_specifications_AST = 05049 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_SPECIFICATIONS,"DISCRIMINANT_SPECIFICATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_specifications_AST.get())))); 05050 #line 5051 "AdaParser.cpp" 05051 currentAST.root = discriminant_specifications_AST; 05052 if ( discriminant_specifications_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05053 discriminant_specifications_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05054 currentAST.child = discriminant_specifications_AST->getFirstChild(); 05055 else 05056 currentAST.child = discriminant_specifications_AST; 05057 currentAST.advanceChildToEnd(); 05058 } 05059 discriminant_specifications_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05060 } 05061 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05062 if( inputState->guessing == 0 ) { 05063 reportError(ex); 05064 consume(); 05065 consumeUntil(_tokenSet_47); 05066 } else { 05067 throw; 05068 } 05069 } 05070 returnAST = discriminant_specifications_AST; 05071 } 05072 05073 void AdaParser::known_discrim_part() { 05074 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05075 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05076 RefAdaAST known_discrim_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05077 05078 try { // for error handling 05079 match(LPAREN); 05080 discriminant_specifications(); 05081 if (inputState->guessing==0) { 05082 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05083 } 05084 match(RPAREN); 05085 if ( inputState->guessing==0 ) { 05086 known_discrim_part_AST = RefAdaAST(currentAST.root); 05087 #line 422 "ada.g" 05088 known_discrim_part_AST = 05089 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(known_discrim_part_AST.get())))); 05090 #line 5091 "AdaParser.cpp" 05091 currentAST.root = known_discrim_part_AST; 05092 if ( known_discrim_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05093 known_discrim_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05094 currentAST.child = known_discrim_part_AST->getFirstChild(); 05095 else 05096 currentAST.child = known_discrim_part_AST; 05097 currentAST.advanceChildToEnd(); 05098 } 05099 known_discrim_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05100 } 05101 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05102 if( inputState->guessing == 0 ) { 05103 reportError(ex); 05104 consume(); 05105 consumeUntil(_tokenSet_0); 05106 } else { 05107 throw; 05108 } 05109 } 05110 returnAST = known_discrim_part_AST; 05111 } 05112 05113 void AdaParser::empty_discrim_opt() { 05114 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05115 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05116 RefAdaAST empty_discrim_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05117 05118 try { // for error handling 05119 if ( inputState->guessing==0 ) { 05120 empty_discrim_opt_AST = RefAdaAST(currentAST.root); 05121 #line 428 "ada.g" 05122 empty_discrim_opt_AST = 05123 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(empty_discrim_opt_AST.get())))); 05124 #line 5125 "AdaParser.cpp" 05125 currentAST.root = empty_discrim_opt_AST; 05126 if ( empty_discrim_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05127 empty_discrim_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05128 currentAST.child = empty_discrim_opt_AST->getFirstChild(); 05129 else 05130 currentAST.child = empty_discrim_opt_AST; 05131 currentAST.advanceChildToEnd(); 05132 } 05133 empty_discrim_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05134 } 05135 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05136 if( inputState->guessing == 0 ) { 05137 reportError(ex); 05138 consume(); 05139 consumeUntil(_tokenSet_53); 05140 } else { 05141 throw; 05142 } 05143 } 05144 returnAST = empty_discrim_opt_AST; 05145 } 05146 05147 void AdaParser::discrim_part() { 05148 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05149 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05150 RefAdaAST discrim_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05151 05152 try { // for error handling 05153 discrim_part_text(); 05154 if (inputState->guessing==0) { 05155 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05156 } 05157 if ( inputState->guessing==0 ) { 05158 discrim_part_AST = RefAdaAST(currentAST.root); 05159 #line 435 "ada.g" 05160 discrim_part_AST = 05161 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIM_PART_OPT,"DISCRIM_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrim_part_AST.get())))); 05162 #line 5163 "AdaParser.cpp" 05163 currentAST.root = discrim_part_AST; 05164 if ( discrim_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05165 discrim_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05166 currentAST.child = discrim_part_AST->getFirstChild(); 05167 else 05168 currentAST.child = discrim_part_AST; 05169 currentAST.advanceChildToEnd(); 05170 } 05171 discrim_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05172 } 05173 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05174 if( inputState->guessing == 0 ) { 05175 reportError(ex); 05176 consume(); 05177 consumeUntil(_tokenSet_52); 05178 } else { 05179 throw; 05180 } 05181 } 05182 returnAST = discrim_part_AST; 05183 } 05184 05185 void AdaParser::discriminant_specification() { 05186 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05187 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05188 RefAdaAST discriminant_specification_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05189 05190 try { // for error handling 05191 def_ids_colon(); 05192 if (inputState->guessing==0) { 05193 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05194 } 05195 access_opt(); 05196 if (inputState->guessing==0) { 05197 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05198 } 05199 subtype_mark(); 05200 if (inputState->guessing==0) { 05201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05202 } 05203 init_opt(); 05204 if (inputState->guessing==0) { 05205 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05206 } 05207 if ( inputState->guessing==0 ) { 05208 discriminant_specification_AST = RefAdaAST(currentAST.root); 05209 #line 449 "ada.g" 05210 discriminant_specification_AST = 05211 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_SPECIFICATION,"DISCRIMINANT_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_specification_AST.get())))); 05212 #line 5213 "AdaParser.cpp" 05213 currentAST.root = discriminant_specification_AST; 05214 if ( discriminant_specification_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05215 discriminant_specification_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05216 currentAST.child = discriminant_specification_AST->getFirstChild(); 05217 else 05218 currentAST.child = discriminant_specification_AST; 05219 currentAST.advanceChildToEnd(); 05220 } 05221 discriminant_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05222 } 05223 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05224 if( inputState->guessing == 0 ) { 05225 reportError(ex); 05226 consume(); 05227 consumeUntil(_tokenSet_37); 05228 } else { 05229 throw; 05230 } 05231 } 05232 returnAST = discriminant_specification_AST; 05233 } 05234 05235 void AdaParser::access_opt() { 05236 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05237 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05238 RefAdaAST access_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05239 05240 try { // for error handling 05241 { 05242 switch ( LA(1)) { 05243 case ACCESS: 05244 { 05245 RefAdaAST tmp144_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05246 if ( inputState->guessing == 0 ) { 05247 tmp144_AST = astFactory->create(LT(1)); 05248 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp144_AST.get())); 05249 } 05250 match(ACCESS); 05251 break; 05252 } 05253 case IDENTIFIER: 05254 { 05255 break; 05256 } 05257 default: 05258 { 05259 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05260 } 05261 } 05262 } 05263 if ( inputState->guessing==0 ) { 05264 access_opt_AST = RefAdaAST(currentAST.root); 05265 #line 456 "ada.g" 05266 access_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(access_opt_AST.get())))); 05267 #line 5268 "AdaParser.cpp" 05268 currentAST.root = access_opt_AST; 05269 if ( access_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05270 access_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05271 currentAST.child = access_opt_AST->getFirstChild(); 05272 else 05273 currentAST.child = access_opt_AST; 05274 currentAST.advanceChildToEnd(); 05275 } 05276 access_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05277 } 05278 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05279 if( inputState->guessing == 0 ) { 05280 reportError(ex); 05281 consume(); 05282 consumeUntil(_tokenSet_39); 05283 } else { 05284 throw; 05285 } 05286 } 05287 returnAST = access_opt_AST; 05288 } 05289 05290 void AdaParser::entrydecls_repspecs_opt() { 05291 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05292 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05293 RefAdaAST entrydecls_repspecs_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05294 05295 try { // for error handling 05296 { // ( ... )* 05297 for (;;) { 05298 if ((LA(1) == ENTRY)) { 05299 entry_declaration(); 05300 if (inputState->guessing==0) { 05301 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05302 } 05303 { // ( ... )* 05304 for (;;) { 05305 switch ( LA(1)) { 05306 case PRAGMA: 05307 { 05308 pragma(); 05309 if (inputState->guessing==0) { 05310 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05311 } 05312 break; 05313 } 05314 case FOR: 05315 { 05316 rep_spec(); 05317 if (inputState->guessing==0) { 05318 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05319 } 05320 break; 05321 } 05322 default: 05323 { 05324 goto _loop143; 05325 } 05326 } 05327 } 05328 _loop143:; 05329 } // ( ... )* 05330 } 05331 else { 05332 goto _loop144; 05333 } 05334 05335 } 05336 _loop144:; 05337 } // ( ... )* 05338 entrydecls_repspecs_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05339 } 05340 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05341 if( inputState->guessing == 0 ) { 05342 reportError(ex); 05343 consume(); 05344 consumeUntil(_tokenSet_49); 05345 } else { 05346 throw; 05347 } 05348 } 05349 returnAST = entrydecls_repspecs_opt_AST; 05350 } 05351 05352 void AdaParser::entry_declaration() { 05353 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05354 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05355 RefAdaAST entry_declaration_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05356 ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken; 05357 RefAdaAST e_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05358 05359 try { // for error handling 05360 e = LT(1); 05361 if ( inputState->guessing == 0 ) { 05362 e_AST = astFactory->create(e); 05363 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(e_AST.get())); 05364 } 05365 match(ENTRY); 05366 RefAdaAST tmp145_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05367 if ( inputState->guessing == 0 ) { 05368 tmp145_AST = astFactory->create(LT(1)); 05369 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp145_AST.get())); 05370 } 05371 match(IDENTIFIER); 05372 discrete_subtype_def_opt(); 05373 if (inputState->guessing==0) { 05374 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05375 } 05376 formal_part_opt(); 05377 if (inputState->guessing==0) { 05378 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05379 } 05380 match(SEMI); 05381 if ( inputState->guessing==0 ) { 05382 #line 474 "ada.g" 05383 Set (e_AST, ENTRY_DECLARATION); 05384 #line 5385 "AdaParser.cpp" 05385 } 05386 entry_declaration_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05387 } 05388 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05389 if( inputState->guessing == 0 ) { 05390 reportError(ex); 05391 consume(); 05392 consumeUntil(_tokenSet_54); 05393 } else { 05394 throw; 05395 } 05396 } 05397 returnAST = entry_declaration_AST; 05398 } 05399 05400 void AdaParser::rep_spec() { 05401 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05402 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05403 RefAdaAST rep_spec_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05404 ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; 05405 RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05406 05407 try { // for error handling 05408 r = LT(1); 05409 if ( inputState->guessing == 0 ) { 05410 r_AST = astFactory->create(r); 05411 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get())); 05412 } 05413 match(FOR); 05414 subtype_mark(); 05415 if (inputState->guessing==0) { 05416 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05417 } 05418 match(USE); 05419 rep_spec_part(r_AST); 05420 if (inputState->guessing==0) { 05421 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05422 } 05423 match(SEMI); 05424 rep_spec_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05425 } 05426 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05427 if( inputState->guessing == 0 ) { 05428 reportError(ex); 05429 consume(); 05430 consumeUntil(_tokenSet_54); 05431 } else { 05432 throw; 05433 } 05434 } 05435 returnAST = rep_spec_AST; 05436 } 05437 05438 void AdaParser::discrete_subtype_def_opt() { 05439 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05440 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05441 RefAdaAST discrete_subtype_def_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05442 05443 try { // for error handling 05444 { 05445 bool synPredMatched149 = false; 05446 if (((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2))))) { 05447 int _m149 = mark(); 05448 synPredMatched149 = true; 05449 inputState->guessing++; 05450 try { 05451 { 05452 match(LPAREN); 05453 discrete_subtype_definition(); 05454 match(RPAREN); 05455 } 05456 } 05457 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 05458 synPredMatched149 = false; 05459 } 05460 rewind(_m149); 05461 inputState->guessing--; 05462 } 05463 if ( synPredMatched149 ) { 05464 match(LPAREN); 05465 discrete_subtype_definition(); 05466 if (inputState->guessing==0) { 05467 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05468 } 05469 match(RPAREN); 05470 } 05471 else if ((LA(1) == SEMI || LA(1) == LPAREN) && (_tokenSet_54.member(LA(2)))) { 05472 } 05473 else { 05474 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05475 } 05476 05477 } 05478 if ( inputState->guessing==0 ) { 05479 discrete_subtype_def_opt_AST = RefAdaAST(currentAST.root); 05480 #line 481 "ada.g" 05481 discrete_subtype_def_opt_AST = 05482 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRETE_SUBTYPE_DEF_OPT,"DISCRETE_SUBTYPE_DEF_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discrete_subtype_def_opt_AST.get())))); 05483 #line 5484 "AdaParser.cpp" 05484 currentAST.root = discrete_subtype_def_opt_AST; 05485 if ( discrete_subtype_def_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05486 discrete_subtype_def_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05487 currentAST.child = discrete_subtype_def_opt_AST->getFirstChild(); 05488 else 05489 currentAST.child = discrete_subtype_def_opt_AST; 05490 currentAST.advanceChildToEnd(); 05491 } 05492 discrete_subtype_def_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05493 } 05494 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05495 if( inputState->guessing == 0 ) { 05496 reportError(ex); 05497 consume(); 05498 consumeUntil(_tokenSet_55); 05499 } else { 05500 throw; 05501 } 05502 } 05503 returnAST = discrete_subtype_def_opt_AST; 05504 } 05505 05506 void AdaParser::discrete_subtype_definition() { 05507 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05508 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05509 RefAdaAST discrete_subtype_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05510 05511 try { // for error handling 05512 { 05513 bool synPredMatched153 = false; 05514 if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) { 05515 int _m153 = mark(); 05516 synPredMatched153 = true; 05517 inputState->guessing++; 05518 try { 05519 { 05520 range(); 05521 } 05522 } 05523 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 05524 synPredMatched153 = false; 05525 } 05526 rewind(_m153); 05527 inputState->guessing--; 05528 } 05529 if ( synPredMatched153 ) { 05530 range(); 05531 if (inputState->guessing==0) { 05532 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05533 } 05534 } 05535 else if ((LA(1) == IDENTIFIER) && (_tokenSet_56.member(LA(2)))) { 05536 subtype_ind(); 05537 if (inputState->guessing==0) { 05538 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05539 } 05540 } 05541 else { 05542 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05543 } 05544 05545 } 05546 discrete_subtype_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05547 } 05548 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05549 if( inputState->guessing == 0 ) { 05550 reportError(ex); 05551 consume(); 05552 consumeUntil(_tokenSet_57); 05553 } else { 05554 throw; 05555 } 05556 } 05557 returnAST = discrete_subtype_definition_AST; 05558 } 05559 05560 void AdaParser::subtype_ind() { 05561 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05562 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05563 RefAdaAST subtype_ind_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05564 05565 try { // for error handling 05566 subtype_mark(); 05567 if (inputState->guessing==0) { 05568 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05569 } 05570 constraint_opt(); 05571 if (inputState->guessing==0) { 05572 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05573 } 05574 if ( inputState->guessing==0 ) { 05575 subtype_ind_AST = RefAdaAST(currentAST.root); 05576 #line 679 "ada.g" 05577 subtype_ind_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SUBTYPE_INDICATION,"SUBTYPE_INDICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(subtype_ind_AST.get())))); 05578 #line 5579 "AdaParser.cpp" 05579 currentAST.root = subtype_ind_AST; 05580 if ( subtype_ind_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05581 subtype_ind_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05582 currentAST.child = subtype_ind_AST->getFirstChild(); 05583 else 05584 currentAST.child = subtype_ind_AST; 05585 currentAST.advanceChildToEnd(); 05586 } 05587 subtype_ind_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05588 } 05589 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05590 if( inputState->guessing == 0 ) { 05591 reportError(ex); 05592 consume(); 05593 consumeUntil(_tokenSet_58); 05594 } else { 05595 throw; 05596 } 05597 } 05598 returnAST = subtype_ind_AST; 05599 } 05600 05601 void AdaParser::rep_spec_part( 05602 RefAdaAST t 05603 ) { 05604 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05605 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05606 RefAdaAST rep_spec_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05607 05608 try { // for error handling 05609 switch ( LA(1)) { 05610 case RECORD: 05611 { 05612 match(RECORD); 05613 align_opt(); 05614 if (inputState->guessing==0) { 05615 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05616 } 05617 comp_loc_s(); 05618 if (inputState->guessing==0) { 05619 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05620 } 05621 match(END); 05622 match(RECORD); 05623 if ( inputState->guessing==0 ) { 05624 #line 504 "ada.g" 05625 Set(t, RECORD_REPRESENTATION_CLAUSE); 05626 #line 5627 "AdaParser.cpp" 05627 } 05628 rep_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05629 break; 05630 } 05631 case AT: 05632 { 05633 match(AT); 05634 expression(); 05635 if (inputState->guessing==0) { 05636 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05637 } 05638 if ( inputState->guessing==0 ) { 05639 #line 506 "ada.g" 05640 Set(t, AT_CLAUSE); 05641 #line 5642 "AdaParser.cpp" 05642 } 05643 rep_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05644 break; 05645 } 05646 case IDENTIFIER: 05647 case LPAREN: 05648 case NEW: 05649 case CHARACTER_LITERAL: 05650 case CHAR_STRING: 05651 case NuLL: 05652 case NOT: 05653 case PLUS: 05654 case MINUS: 05655 case ABS: 05656 case NUMERIC_LIT: 05657 { 05658 expression(); 05659 if (inputState->guessing==0) { 05660 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05661 } 05662 if ( inputState->guessing==0 ) { 05663 #line 509 "ada.g" 05664 Set(t, ATTRIBUTE_DEFINITION_CLAUSE); 05665 #line 5666 "AdaParser.cpp" 05666 } 05667 rep_spec_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05668 break; 05669 } 05670 default: 05671 { 05672 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05673 } 05674 } 05675 } 05676 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05677 if( inputState->guessing == 0 ) { 05678 reportError(ex); 05679 consume(); 05680 consumeUntil(_tokenSet_4); 05681 } else { 05682 throw; 05683 } 05684 } 05685 returnAST = rep_spec_part_AST; 05686 } 05687 05688 void AdaParser::align_opt() { 05689 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05690 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05691 RefAdaAST align_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05692 05693 try { // for error handling 05694 { 05695 switch ( LA(1)) { 05696 case AT: 05697 { 05698 match(AT); 05699 match(MOD); 05700 expression(); 05701 if (inputState->guessing==0) { 05702 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05703 } 05704 match(SEMI); 05705 break; 05706 } 05707 case PRAGMA: 05708 case IDENTIFIER: 05709 case END: 05710 { 05711 break; 05712 } 05713 default: 05714 { 05715 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05716 } 05717 } 05718 } 05719 if ( inputState->guessing==0 ) { 05720 align_opt_AST = RefAdaAST(currentAST.root); 05721 #line 513 "ada.g" 05722 align_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MOD_CLAUSE_OPT,"MOD_CLAUSE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(align_opt_AST.get())))); 05723 #line 5724 "AdaParser.cpp" 05724 currentAST.root = align_opt_AST; 05725 if ( align_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05726 align_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05727 currentAST.child = align_opt_AST->getFirstChild(); 05728 else 05729 currentAST.child = align_opt_AST; 05730 currentAST.advanceChildToEnd(); 05731 } 05732 align_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05733 } 05734 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05735 if( inputState->guessing == 0 ) { 05736 reportError(ex); 05737 consume(); 05738 consumeUntil(_tokenSet_59); 05739 } else { 05740 throw; 05741 } 05742 } 05743 returnAST = align_opt_AST; 05744 } 05745 05746 void AdaParser::comp_loc_s() { 05747 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05748 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05749 RefAdaAST comp_loc_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05750 05751 try { // for error handling 05752 { // ( ... )* 05753 for (;;) { 05754 switch ( LA(1)) { 05755 case PRAGMA: 05756 { 05757 pragma(); 05758 if (inputState->guessing==0) { 05759 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05760 } 05761 break; 05762 } 05763 case IDENTIFIER: 05764 { 05765 subtype_mark(); 05766 if (inputState->guessing==0) { 05767 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05768 } 05769 match(AT); 05770 expression(); 05771 if (inputState->guessing==0) { 05772 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05773 } 05774 match(RANGE); 05775 range(); 05776 if (inputState->guessing==0) { 05777 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05778 } 05779 match(SEMI); 05780 break; 05781 } 05782 default: 05783 { 05784 goto _loop160; 05785 } 05786 } 05787 } 05788 _loop160:; 05789 } // ( ... )* 05790 if ( inputState->guessing==0 ) { 05791 comp_loc_s_AST = RefAdaAST(currentAST.root); 05792 #line 517 "ada.g" 05793 comp_loc_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_CLAUSES_OPT,"COMPONENT_CLAUSES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(comp_loc_s_AST.get())))); 05794 #line 5795 "AdaParser.cpp" 05795 currentAST.root = comp_loc_s_AST; 05796 if ( comp_loc_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05797 comp_loc_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05798 currentAST.child = comp_loc_s_AST->getFirstChild(); 05799 else 05800 currentAST.child = comp_loc_s_AST; 05801 currentAST.advanceChildToEnd(); 05802 } 05803 comp_loc_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05804 } 05805 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05806 if( inputState->guessing == 0 ) { 05807 reportError(ex); 05808 consume(); 05809 consumeUntil(_tokenSet_21); 05810 } else { 05811 throw; 05812 } 05813 } 05814 returnAST = comp_loc_s_AST; 05815 } 05816 05817 void AdaParser::protected_definition() { 05818 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05819 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05820 RefAdaAST protected_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05821 05822 try { // for error handling 05823 match(IS); 05824 prot_op_decl_s(); 05825 if (inputState->guessing==0) { 05826 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05827 } 05828 { 05829 switch ( LA(1)) { 05830 case PRIVATE: 05831 { 05832 match(PRIVATE); 05833 prot_member_decl_s(); 05834 if (inputState->guessing==0) { 05835 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05836 } 05837 break; 05838 } 05839 case END: 05840 { 05841 break; 05842 } 05843 default: 05844 { 05845 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 05846 } 05847 } 05848 } 05849 end_id_opt(); 05850 protected_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05851 } 05852 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05853 if( inputState->guessing == 0 ) { 05854 reportError(ex); 05855 consume(); 05856 consumeUntil(_tokenSet_4); 05857 } else { 05858 throw; 05859 } 05860 } 05861 returnAST = protected_definition_AST; 05862 } 05863 05864 void AdaParser::prot_op_decl_s() { 05865 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05866 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05867 RefAdaAST prot_op_decl_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05868 05869 try { // for error handling 05870 { // ( ... )* 05871 for (;;) { 05872 if ((_tokenSet_60.member(LA(1)))) { 05873 prot_op_decl(); 05874 if (inputState->guessing==0) { 05875 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05876 } 05877 } 05878 else { 05879 goto _loop170; 05880 } 05881 05882 } 05883 _loop170:; 05884 } // ( ... )* 05885 if ( inputState->guessing==0 ) { 05886 prot_op_decl_s_AST = RefAdaAST(currentAST.root); 05887 #line 541 "ada.g" 05888 prot_op_decl_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_OP_DECLARATIONS,"PROT_OP_DECLARATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_op_decl_s_AST.get())))); 05889 #line 5890 "AdaParser.cpp" 05890 currentAST.root = prot_op_decl_s_AST; 05891 if ( prot_op_decl_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05892 prot_op_decl_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05893 currentAST.child = prot_op_decl_s_AST->getFirstChild(); 05894 else 05895 currentAST.child = prot_op_decl_s_AST; 05896 currentAST.advanceChildToEnd(); 05897 } 05898 prot_op_decl_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05899 } 05900 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05901 if( inputState->guessing == 0 ) { 05902 reportError(ex); 05903 consume(); 05904 consumeUntil(_tokenSet_49); 05905 } else { 05906 throw; 05907 } 05908 } 05909 returnAST = prot_op_decl_s_AST; 05910 } 05911 05912 void AdaParser::prot_member_decl_s() { 05913 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05914 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05915 RefAdaAST prot_member_decl_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05916 05917 try { // for error handling 05918 { // ( ... )* 05919 for (;;) { 05920 switch ( LA(1)) { 05921 case PRAGMA: 05922 case PROCEDURE: 05923 case FUNCTION: 05924 case ENTRY: 05925 case FOR: 05926 { 05927 prot_op_decl(); 05928 if (inputState->guessing==0) { 05929 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05930 } 05931 break; 05932 } 05933 case IDENTIFIER: 05934 { 05935 comp_decl(); 05936 if (inputState->guessing==0) { 05937 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05938 } 05939 break; 05940 } 05941 default: 05942 { 05943 goto _loop174; 05944 } 05945 } 05946 } 05947 _loop174:; 05948 } // ( ... )* 05949 if ( inputState->guessing==0 ) { 05950 prot_member_decl_s_AST = RefAdaAST(currentAST.root); 05951 #line 555 "ada.g" 05952 prot_member_decl_s_AST = 05953 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_MEMBER_DECLARATIONS,"PROT_MEMBER_DECLARATIONS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_member_decl_s_AST.get())))); 05954 #line 5955 "AdaParser.cpp" 05955 currentAST.root = prot_member_decl_s_AST; 05956 if ( prot_member_decl_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 05957 prot_member_decl_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 05958 currentAST.child = prot_member_decl_s_AST->getFirstChild(); 05959 else 05960 currentAST.child = prot_member_decl_s_AST; 05961 currentAST.advanceChildToEnd(); 05962 } 05963 prot_member_decl_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05964 } 05965 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 05966 if( inputState->guessing == 0 ) { 05967 reportError(ex); 05968 consume(); 05969 consumeUntil(_tokenSet_21); 05970 } else { 05971 throw; 05972 } 05973 } 05974 returnAST = prot_member_decl_s_AST; 05975 } 05976 05977 void AdaParser::prot_op_decl() { 05978 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05979 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 05980 RefAdaAST prot_op_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05981 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 05982 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05983 ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; 05984 RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 05985 05986 try { // for error handling 05987 switch ( LA(1)) { 05988 case ENTRY: 05989 { 05990 entry_declaration(); 05991 if (inputState->guessing==0) { 05992 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 05993 } 05994 prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 05995 break; 05996 } 05997 case PROCEDURE: 05998 { 05999 p = LT(1); 06000 if ( inputState->guessing == 0 ) { 06001 p_AST = astFactory->create(p); 06002 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 06003 } 06004 match(PROCEDURE); 06005 def_id(false); 06006 if (inputState->guessing==0) { 06007 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06008 } 06009 formal_part_opt(); 06010 if (inputState->guessing==0) { 06011 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06012 } 06013 match(SEMI); 06014 if ( inputState->guessing==0 ) { 06015 #line 547 "ada.g" 06016 pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION); 06017 #line 6018 "AdaParser.cpp" 06018 } 06019 prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06020 break; 06021 } 06022 case FUNCTION: 06023 { 06024 f = LT(1); 06025 if ( inputState->guessing == 0 ) { 06026 f_AST = astFactory->create(f); 06027 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get())); 06028 } 06029 match(FUNCTION); 06030 def_designator(false); 06031 if (inputState->guessing==0) { 06032 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06033 } 06034 function_tail(); 06035 if (inputState->guessing==0) { 06036 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06037 } 06038 match(SEMI); 06039 if ( inputState->guessing==0 ) { 06040 #line 549 "ada.g" 06041 pop_def_id(); Set(f_AST, FUNCTION_DECLARATION); 06042 #line 6043 "AdaParser.cpp" 06043 } 06044 prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06045 break; 06046 } 06047 case FOR: 06048 { 06049 rep_spec(); 06050 if (inputState->guessing==0) { 06051 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06052 } 06053 prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06054 break; 06055 } 06056 case PRAGMA: 06057 { 06058 pragma(); 06059 if (inputState->guessing==0) { 06060 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06061 } 06062 prot_op_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06063 break; 06064 } 06065 default: 06066 { 06067 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06068 } 06069 } 06070 } 06071 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06072 if( inputState->guessing == 0 ) { 06073 reportError(ex); 06074 consume(); 06075 consumeUntil(_tokenSet_54); 06076 } else { 06077 throw; 06078 } 06079 } 06080 returnAST = prot_op_decl_AST; 06081 } 06082 06083 void AdaParser::comp_decl() { 06084 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06085 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06086 RefAdaAST comp_decl_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06087 06088 try { // for error handling 06089 def_ids_colon(); 06090 if (inputState->guessing==0) { 06091 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06092 } 06093 component_subtype_def(); 06094 if (inputState->guessing==0) { 06095 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06096 } 06097 init_opt(); 06098 if (inputState->guessing==0) { 06099 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06100 } 06101 match(SEMI); 06102 if ( inputState->guessing==0 ) { 06103 comp_decl_AST = RefAdaAST(currentAST.root); 06104 #line 561 "ada.g" 06105 comp_decl_AST = 06106 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_DECLARATION,"COMPONENT_DECLARATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(comp_decl_AST.get())))); 06107 #line 6108 "AdaParser.cpp" 06108 currentAST.root = comp_decl_AST; 06109 if ( comp_decl_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 06110 comp_decl_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 06111 currentAST.child = comp_decl_AST->getFirstChild(); 06112 else 06113 currentAST.child = comp_decl_AST; 06114 currentAST.advanceChildToEnd(); 06115 } 06116 comp_decl_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06117 } 06118 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06119 if( inputState->guessing == 0 ) { 06120 reportError(ex); 06121 consume(); 06122 consumeUntil(_tokenSet_61); 06123 } else { 06124 throw; 06125 } 06126 } 06127 returnAST = comp_decl_AST; 06128 } 06129 06130 void AdaParser::component_subtype_def() { 06131 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06132 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06133 RefAdaAST component_subtype_def_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06134 06135 try { // for error handling 06136 aliased_opt(); 06137 if (inputState->guessing==0) { 06138 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06139 } 06140 subtype_ind(); 06141 if (inputState->guessing==0) { 06142 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06143 } 06144 component_subtype_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06145 } 06146 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06147 if( inputState->guessing == 0 ) { 06148 reportError(ex); 06149 consume(); 06150 consumeUntil(_tokenSet_62); 06151 } else { 06152 throw; 06153 } 06154 } 06155 returnAST = component_subtype_def_AST; 06156 } 06157 06158 void AdaParser::type_def( 06159 RefAdaAST t 06160 ) { 06161 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06162 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06163 RefAdaAST type_def_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06164 06165 try { // for error handling 06166 switch ( LA(1)) { 06167 case LPAREN: 06168 { 06169 match(LPAREN); 06170 enum_id_s(); 06171 if (inputState->guessing==0) { 06172 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06173 } 06174 match(RPAREN); 06175 if ( inputState->guessing==0 ) { 06176 #line 624 "ada.g" 06177 Set(t, ENUMERATION_TYPE_DECLARATION); 06178 #line 6179 "AdaParser.cpp" 06179 } 06180 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06181 break; 06182 } 06183 case RANGE: 06184 { 06185 match(RANGE); 06186 range(); 06187 if (inputState->guessing==0) { 06188 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06189 } 06190 if ( inputState->guessing==0 ) { 06191 #line 626 "ada.g" 06192 Set(t, SIGNED_INTEGER_TYPE_DECLARATION); 06193 #line 6194 "AdaParser.cpp" 06194 } 06195 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06196 break; 06197 } 06198 case MOD: 06199 { 06200 match(MOD); 06201 expression(); 06202 if (inputState->guessing==0) { 06203 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06204 } 06205 if ( inputState->guessing==0 ) { 06206 #line 628 "ada.g" 06207 Set(t, MODULAR_TYPE_DECLARATION); 06208 #line 6209 "AdaParser.cpp" 06209 } 06210 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06211 break; 06212 } 06213 case DIGITS: 06214 { 06215 match(DIGITS); 06216 expression(); 06217 if (inputState->guessing==0) { 06218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06219 } 06220 range_constraint_opt(); 06221 if (inputState->guessing==0) { 06222 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06223 } 06224 if ( inputState->guessing==0 ) { 06225 #line 630 "ada.g" 06226 Set(t, FLOATING_POINT_DECLARATION); 06227 #line 6228 "AdaParser.cpp" 06228 } 06229 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06230 break; 06231 } 06232 case DELTA: 06233 { 06234 match(DELTA); 06235 expression(); 06236 if (inputState->guessing==0) { 06237 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06238 } 06239 { 06240 switch ( LA(1)) { 06241 case RANGE: 06242 { 06243 match(RANGE); 06244 range(); 06245 if (inputState->guessing==0) { 06246 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06247 } 06248 if ( inputState->guessing==0 ) { 06249 #line 633 "ada.g" 06250 Set(t, ORDINARY_FIXED_POINT_DECLARATION); 06251 #line 6252 "AdaParser.cpp" 06252 } 06253 break; 06254 } 06255 case DIGITS: 06256 { 06257 match(DIGITS); 06258 expression(); 06259 if (inputState->guessing==0) { 06260 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06261 } 06262 range_constraint_opt(); 06263 if (inputState->guessing==0) { 06264 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06265 } 06266 if ( inputState->guessing==0 ) { 06267 #line 635 "ada.g" 06268 Set(t, DECIMAL_FIXED_POINT_DECLARATION); 06269 #line 6270 "AdaParser.cpp" 06270 } 06271 break; 06272 } 06273 default: 06274 { 06275 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06276 } 06277 } 06278 } 06279 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06280 break; 06281 } 06282 case ARRAY: 06283 { 06284 array_type_definition(t); 06285 if (inputState->guessing==0) { 06286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06287 } 06288 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06289 break; 06290 } 06291 case ACCESS: 06292 { 06293 access_type_definition(t); 06294 if (inputState->guessing==0) { 06295 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06296 } 06297 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06298 break; 06299 } 06300 case PRIVATE: 06301 case NEW: 06302 case NuLL: 06303 case RECORD: 06304 case ABSTRACT: 06305 case TAGGED: 06306 case LIMITED: 06307 { 06308 empty_discrim_opt(); 06309 if (inputState->guessing==0) { 06310 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06311 } 06312 derived_or_private_or_record(t, false); 06313 if (inputState->guessing==0) { 06314 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06315 } 06316 type_def_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06317 break; 06318 } 06319 default: 06320 { 06321 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06322 } 06323 } 06324 } 06325 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06326 if( inputState->guessing == 0 ) { 06327 reportError(ex); 06328 consume(); 06329 consumeUntil(_tokenSet_4); 06330 } else { 06331 throw; 06332 } 06333 } 06334 returnAST = type_def_AST; 06335 } 06336 06337 void AdaParser::derived_or_private_or_record( 06338 RefAdaAST t, bool has_discrim 06339 ) { 06340 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06341 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06342 RefAdaAST derived_or_private_or_record_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06343 06344 try { // for error handling 06345 bool synPredMatched244 = false; 06346 if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) { 06347 int _m244 = mark(); 06348 synPredMatched244 = true; 06349 inputState->guessing++; 06350 try { 06351 { 06352 { 06353 switch ( LA(1)) { 06354 case ABSTRACT: 06355 { 06356 match(ABSTRACT); 06357 break; 06358 } 06359 case NEW: 06360 { 06361 break; 06362 } 06363 default: 06364 { 06365 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06366 } 06367 } 06368 } 06369 match(NEW); 06370 subtype_ind(); 06371 match(WITH); 06372 } 06373 } 06374 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 06375 synPredMatched244 = false; 06376 } 06377 rewind(_m244); 06378 inputState->guessing--; 06379 } 06380 if ( synPredMatched244 ) { 06381 abstract_opt(); 06382 if (inputState->guessing==0) { 06383 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06384 } 06385 match(NEW); 06386 subtype_ind(); 06387 if (inputState->guessing==0) { 06388 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06389 } 06390 match(WITH); 06391 { 06392 switch ( LA(1)) { 06393 case PRIVATE: 06394 { 06395 match(PRIVATE); 06396 if ( inputState->guessing==0 ) { 06397 #line 758 "ada.g" 06398 Set(t, PRIVATE_EXTENSION_DECLARATION); 06399 #line 6400 "AdaParser.cpp" 06400 } 06401 break; 06402 } 06403 case NuLL: 06404 case RECORD: 06405 { 06406 record_definition(has_discrim); 06407 if (inputState->guessing==0) { 06408 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06409 } 06410 if ( inputState->guessing==0 ) { 06411 #line 760 "ada.g" 06412 Set(t, DERIVED_RECORD_EXTENSION); 06413 #line 6414 "AdaParser.cpp" 06414 } 06415 break; 06416 } 06417 default: 06418 { 06419 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06420 } 06421 } 06422 } 06423 derived_or_private_or_record_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06424 } 06425 else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) { 06426 match(NEW); 06427 subtype_ind(); 06428 if (inputState->guessing==0) { 06429 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06430 } 06431 if ( inputState->guessing==0 ) { 06432 #line 762 "ada.g" 06433 Set(t, ORDINARY_DERIVED_TYPE_DECLARATION); 06434 #line 6435 "AdaParser.cpp" 06435 } 06436 derived_or_private_or_record_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06437 } 06438 else if ((_tokenSet_63.member(LA(1))) && (_tokenSet_64.member(LA(2)))) { 06439 abstract_tagged_limited_opt(); 06440 if (inputState->guessing==0) { 06441 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06442 } 06443 { 06444 switch ( LA(1)) { 06445 case PRIVATE: 06446 { 06447 match(PRIVATE); 06448 if ( inputState->guessing==0 ) { 06449 #line 764 "ada.g" 06450 Set(t, PRIVATE_TYPE_DECLARATION); 06451 #line 6452 "AdaParser.cpp" 06452 } 06453 break; 06454 } 06455 case NuLL: 06456 case RECORD: 06457 { 06458 record_definition(has_discrim); 06459 if (inputState->guessing==0) { 06460 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06461 } 06462 if ( inputState->guessing==0 ) { 06463 #line 766 "ada.g" 06464 Set(t, RECORD_TYPE_DECLARATION); 06465 #line 6466 "AdaParser.cpp" 06466 } 06467 break; 06468 } 06469 default: 06470 { 06471 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06472 } 06473 } 06474 } 06475 derived_or_private_or_record_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06476 } 06477 else { 06478 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06479 } 06480 06481 } 06482 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06483 if( inputState->guessing == 0 ) { 06484 reportError(ex); 06485 consume(); 06486 consumeUntil(_tokenSet_4); 06487 } else { 06488 throw; 06489 } 06490 } 06491 returnAST = derived_or_private_or_record_AST; 06492 } 06493 06494 void AdaParser::local_enum_name() { 06495 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06496 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06497 RefAdaAST local_enum_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06498 06499 try { // for error handling 06500 RefAdaAST tmp179_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06501 if ( inputState->guessing == 0 ) { 06502 tmp179_AST = astFactory->create(LT(1)); 06503 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp179_AST.get())); 06504 } 06505 match(IDENTIFIER); 06506 local_enum_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06507 } 06508 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06509 if( inputState->guessing == 0 ) { 06510 reportError(ex); 06511 consume(); 06512 consumeUntil(_tokenSet_65); 06513 } else { 06514 throw; 06515 } 06516 } 06517 returnAST = local_enum_name_AST; 06518 } 06519 06520 void AdaParser::enumeration_aggregate() { 06521 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06522 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06523 RefAdaAST enumeration_aggregate_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06524 06525 try { // for error handling 06526 parenth_values(); 06527 if (inputState->guessing==0) { 06528 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06529 } 06530 enumeration_aggregate_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06531 } 06532 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06533 if( inputState->guessing == 0 ) { 06534 reportError(ex); 06535 consume(); 06536 consumeUntil(_tokenSet_4); 06537 } else { 06538 throw; 06539 } 06540 } 06541 returnAST = enumeration_aggregate_AST; 06542 } 06543 06544 void AdaParser::aliased_constant_opt() { 06545 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06546 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06547 RefAdaAST aliased_constant_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06548 06549 try { // for error handling 06550 { 06551 switch ( LA(1)) { 06552 case ALIASED: 06553 { 06554 RefAdaAST tmp180_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06555 if ( inputState->guessing == 0 ) { 06556 tmp180_AST = astFactory->create(LT(1)); 06557 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp180_AST.get())); 06558 } 06559 match(ALIASED); 06560 break; 06561 } 06562 case IDENTIFIER: 06563 case CONSTANT: 06564 case ARRAY: 06565 { 06566 break; 06567 } 06568 default: 06569 { 06570 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06571 } 06572 } 06573 } 06574 { 06575 switch ( LA(1)) { 06576 case CONSTANT: 06577 { 06578 RefAdaAST tmp181_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06579 if ( inputState->guessing == 0 ) { 06580 tmp181_AST = astFactory->create(LT(1)); 06581 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp181_AST.get())); 06582 } 06583 match(CONSTANT); 06584 break; 06585 } 06586 case IDENTIFIER: 06587 case ARRAY: 06588 { 06589 break; 06590 } 06591 default: 06592 { 06593 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06594 } 06595 } 06596 } 06597 if ( inputState->guessing==0 ) { 06598 aliased_constant_opt_AST = RefAdaAST(currentAST.root); 06599 #line 844 "ada.g" 06600 aliased_constant_opt_AST = 06601 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(aliased_constant_opt_AST.get())))); 06602 #line 6603 "AdaParser.cpp" 06603 currentAST.root = aliased_constant_opt_AST; 06604 if ( aliased_constant_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 06605 aliased_constant_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 06606 currentAST.child = aliased_constant_opt_AST->getFirstChild(); 06607 else 06608 currentAST.child = aliased_constant_opt_AST; 06609 currentAST.advanceChildToEnd(); 06610 } 06611 aliased_constant_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06612 } 06613 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06614 if( inputState->guessing == 0 ) { 06615 reportError(ex); 06616 consume(); 06617 consumeUntil(_tokenSet_66); 06618 } else { 06619 throw; 06620 } 06621 } 06622 returnAST = aliased_constant_opt_AST; 06623 } 06624 06625 void AdaParser::array_type_definition( 06626 RefAdaAST t 06627 ) { 06628 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06629 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06630 RefAdaAST array_type_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06631 06632 try { // for error handling 06633 match(ARRAY); 06634 match(LPAREN); 06635 index_or_discrete_range_s(); 06636 if (inputState->guessing==0) { 06637 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06638 } 06639 match(RPAREN); 06640 match(OF); 06641 component_subtype_def(); 06642 if (inputState->guessing==0) { 06643 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06644 } 06645 if ( inputState->guessing==0 ) { 06646 #line 655 "ada.g" 06647 Set(t, ARRAY_TYPE_DECLARATION); 06648 #line 6649 "AdaParser.cpp" 06649 } 06650 array_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06651 } 06652 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06653 if( inputState->guessing == 0 ) { 06654 reportError(ex); 06655 consume(); 06656 consumeUntil(_tokenSet_62); 06657 } else { 06658 throw; 06659 } 06660 } 06661 returnAST = array_type_definition_AST; 06662 } 06663 06664 void AdaParser::enum_id_s() { 06665 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06666 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06667 RefAdaAST enum_id_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06668 06669 try { // for error handling 06670 enumeration_literal_specification(); 06671 if (inputState->guessing==0) { 06672 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06673 } 06674 { // ( ... )* 06675 for (;;) { 06676 if ((LA(1) == COMMA)) { 06677 match(COMMA); 06678 enumeration_literal_specification(); 06679 if (inputState->guessing==0) { 06680 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06681 } 06682 } 06683 else { 06684 goto _loop195; 06685 } 06686 06687 } 06688 _loop195:; 06689 } // ( ... )* 06690 enum_id_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06691 } 06692 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06693 if( inputState->guessing == 0 ) { 06694 reportError(ex); 06695 consume(); 06696 consumeUntil(_tokenSet_47); 06697 } else { 06698 throw; 06699 } 06700 } 06701 returnAST = enum_id_s_AST; 06702 } 06703 06704 void AdaParser::range_constraint_opt() { 06705 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06706 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06707 RefAdaAST range_constraint_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06708 06709 try { // for error handling 06710 { 06711 switch ( LA(1)) { 06712 case RANGE: 06713 { 06714 range_constraint(); 06715 if (inputState->guessing==0) { 06716 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06717 } 06718 break; 06719 } 06720 case SEMI: 06721 case COMMA: 06722 case RPAREN: 06723 case WITH: 06724 case ASSIGN: 06725 case LOOP: 06726 { 06727 break; 06728 } 06729 default: 06730 { 06731 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06732 } 06733 } 06734 } 06735 range_constraint_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06736 } 06737 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06738 if( inputState->guessing == 0 ) { 06739 reportError(ex); 06740 consume(); 06741 consumeUntil(_tokenSet_58); 06742 } else { 06743 throw; 06744 } 06745 } 06746 returnAST = range_constraint_opt_AST; 06747 } 06748 06749 void AdaParser::access_type_definition( 06750 RefAdaAST t 06751 ) { 06752 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06753 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06754 RefAdaAST access_type_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06755 06756 try { // for error handling 06757 match(ACCESS); 06758 { 06759 switch ( LA(1)) { 06760 case PROCEDURE: 06761 case FUNCTION: 06762 case PROTECTED: 06763 { 06764 protected_opt(); 06765 if (inputState->guessing==0) { 06766 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06767 } 06768 { 06769 switch ( LA(1)) { 06770 case PROCEDURE: 06771 { 06772 match(PROCEDURE); 06773 formal_part_opt(); 06774 if (inputState->guessing==0) { 06775 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06776 } 06777 if ( inputState->guessing==0 ) { 06778 #line 737 "ada.g" 06779 Set(t, ACCESS_TO_PROCEDURE_DECLARATION); 06780 #line 6781 "AdaParser.cpp" 06781 } 06782 break; 06783 } 06784 case FUNCTION: 06785 { 06786 match(FUNCTION); 06787 func_formal_part_opt(); 06788 if (inputState->guessing==0) { 06789 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06790 } 06791 match(RETURN); 06792 subtype_mark(); 06793 if (inputState->guessing==0) { 06794 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06795 } 06796 if ( inputState->guessing==0 ) { 06797 #line 739 "ada.g" 06798 Set(t, ACCESS_TO_FUNCTION_DECLARATION); 06799 #line 6800 "AdaParser.cpp" 06800 } 06801 break; 06802 } 06803 default: 06804 { 06805 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06806 } 06807 } 06808 } 06809 break; 06810 } 06811 case IDENTIFIER: 06812 case ALL: 06813 case CONSTANT: 06814 { 06815 constant_all_opt(); 06816 if (inputState->guessing==0) { 06817 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06818 } 06819 subtype_ind(); 06820 if (inputState->guessing==0) { 06821 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06822 } 06823 if ( inputState->guessing==0 ) { 06824 #line 742 "ada.g" 06825 Set(t, ACCESS_TO_OBJECT_DECLARATION); 06826 #line 6827 "AdaParser.cpp" 06827 } 06828 break; 06829 } 06830 default: 06831 { 06832 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06833 } 06834 } 06835 } 06836 access_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06837 } 06838 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06839 if( inputState->guessing == 0 ) { 06840 reportError(ex); 06841 consume(); 06842 consumeUntil(_tokenSet_4); 06843 } else { 06844 throw; 06845 } 06846 } 06847 returnAST = access_type_definition_AST; 06848 } 06849 06850 void AdaParser::enumeration_literal_specification() { 06851 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06852 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06853 RefAdaAST enumeration_literal_specification_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06854 06855 try { // for error handling 06856 switch ( LA(1)) { 06857 case IDENTIFIER: 06858 { 06859 RefAdaAST tmp191_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06860 if ( inputState->guessing == 0 ) { 06861 tmp191_AST = astFactory->create(LT(1)); 06862 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp191_AST.get())); 06863 } 06864 match(IDENTIFIER); 06865 enumeration_literal_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06866 break; 06867 } 06868 case CHARACTER_LITERAL: 06869 { 06870 RefAdaAST tmp192_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06871 if ( inputState->guessing == 0 ) { 06872 tmp192_AST = astFactory->create(LT(1)); 06873 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp192_AST.get())); 06874 } 06875 match(CHARACTER_LITERAL); 06876 enumeration_literal_specification_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06877 break; 06878 } 06879 default: 06880 { 06881 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 06882 } 06883 } 06884 } 06885 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06886 if( inputState->guessing == 0 ) { 06887 reportError(ex); 06888 consume(); 06889 consumeUntil(_tokenSet_7); 06890 } else { 06891 throw; 06892 } 06893 } 06894 returnAST = enumeration_literal_specification_AST; 06895 } 06896 06897 void AdaParser::index_or_discrete_range_s() { 06898 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06899 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06900 RefAdaAST index_or_discrete_range_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06901 06902 try { // for error handling 06903 index_or_discrete_range(); 06904 if (inputState->guessing==0) { 06905 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06906 } 06907 { // ( ... )* 06908 for (;;) { 06909 if ((LA(1) == COMMA)) { 06910 RefAdaAST tmp193_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06911 if ( inputState->guessing == 0 ) { 06912 tmp193_AST = astFactory->create(LT(1)); 06913 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp193_AST.get())); 06914 } 06915 match(COMMA); 06916 index_or_discrete_range(); 06917 if (inputState->guessing==0) { 06918 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06919 } 06920 } 06921 else { 06922 goto _loop202; 06923 } 06924 06925 } 06926 _loop202:; 06927 } // ( ... )* 06928 index_or_discrete_range_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 06929 } 06930 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 06931 if( inputState->guessing == 0 ) { 06932 reportError(ex); 06933 consume(); 06934 consumeUntil(_tokenSet_47); 06935 } else { 06936 throw; 06937 } 06938 } 06939 returnAST = index_or_discrete_range_s_AST; 06940 } 06941 06942 void AdaParser::index_or_discrete_range() { 06943 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06944 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 06945 RefAdaAST index_or_discrete_range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06946 06947 try { // for error handling 06948 simple_expression(); 06949 if (inputState->guessing==0) { 06950 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06951 } 06952 { 06953 switch ( LA(1)) { 06954 case DOT_DOT: 06955 { 06956 RefAdaAST tmp194_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06957 if ( inputState->guessing == 0 ) { 06958 tmp194_AST = astFactory->create(LT(1)); 06959 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp194_AST.get())); 06960 } 06961 match(DOT_DOT); 06962 simple_expression(); 06963 if (inputState->guessing==0) { 06964 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 06965 } 06966 break; 06967 } 06968 case RANGE: 06969 { 06970 RefAdaAST tmp195_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06971 if ( inputState->guessing == 0 ) { 06972 tmp195_AST = astFactory->create(LT(1)); 06973 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp195_AST.get())); 06974 } 06975 match(RANGE); 06976 { 06977 switch ( LA(1)) { 06978 case BOX: 06979 { 06980 RefAdaAST tmp196_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 06981 if ( inputState->guessing == 0 ) { 06982 tmp196_AST = astFactory->create(LT(1)); 06983 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp196_AST.get())); 06984 } 06985 match(BOX); 06986 break; 06987 } 06988 case IDENTIFIER: 06989 case LPAREN: 06990 case NEW: 06991 case CHARACTER_LITERAL: 06992 case CHAR_STRING: 06993 case NuLL: 06994 case NOT: 06995 case PLUS: 06996 case MINUS: 06997 case ABS: 06998 case NUMERIC_LIT: 06999 { 07000 range(); 07001 if (inputState->guessing==0) { 07002 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07003 } 07004 break; 07005 } 07006 default: 07007 { 07008 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07009 } 07010 } 07011 } 07012 break; 07013 } 07014 case COMMA: 07015 case RPAREN: 07016 { 07017 break; 07018 } 07019 default: 07020 { 07021 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07022 } 07023 } 07024 } 07025 index_or_discrete_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07026 } 07027 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07028 if( inputState->guessing == 0 ) { 07029 reportError(ex); 07030 consume(); 07031 consumeUntil(_tokenSet_7); 07032 } else { 07033 throw; 07034 } 07035 } 07036 returnAST = index_or_discrete_range_AST; 07037 } 07038 07039 void AdaParser::aliased_opt() { 07040 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07041 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07042 RefAdaAST aliased_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07043 07044 try { // for error handling 07045 { 07046 switch ( LA(1)) { 07047 case ALIASED: 07048 { 07049 RefAdaAST tmp197_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07050 if ( inputState->guessing == 0 ) { 07051 tmp197_AST = astFactory->create(LT(1)); 07052 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp197_AST.get())); 07053 } 07054 match(ALIASED); 07055 break; 07056 } 07057 case IDENTIFIER: 07058 { 07059 break; 07060 } 07061 default: 07062 { 07063 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07064 } 07065 } 07066 } 07067 if ( inputState->guessing==0 ) { 07068 aliased_opt_AST = RefAdaAST(currentAST.root); 07069 #line 675 "ada.g" 07070 aliased_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(aliased_opt_AST.get())))); 07071 #line 7072 "AdaParser.cpp" 07072 currentAST.root = aliased_opt_AST; 07073 if ( aliased_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07074 aliased_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07075 currentAST.child = aliased_opt_AST->getFirstChild(); 07076 else 07077 currentAST.child = aliased_opt_AST; 07078 currentAST.advanceChildToEnd(); 07079 } 07080 aliased_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07081 } 07082 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07083 if( inputState->guessing == 0 ) { 07084 reportError(ex); 07085 consume(); 07086 consumeUntil(_tokenSet_39); 07087 } else { 07088 throw; 07089 } 07090 } 07091 returnAST = aliased_opt_AST; 07092 } 07093 07094 void AdaParser::constraint_opt() { 07095 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07096 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07097 RefAdaAST constraint_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07098 07099 try { // for error handling 07100 { 07101 switch ( LA(1)) { 07102 case RANGE: 07103 { 07104 range_constraint(); 07105 if (inputState->guessing==0) { 07106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07107 } 07108 break; 07109 } 07110 case DIGITS: 07111 { 07112 digits_constraint(); 07113 if (inputState->guessing==0) { 07114 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07115 } 07116 break; 07117 } 07118 case DELTA: 07119 { 07120 delta_constraint(); 07121 if (inputState->guessing==0) { 07122 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07123 } 07124 break; 07125 } 07126 case SEMI: 07127 case COMMA: 07128 case RPAREN: 07129 case WITH: 07130 case ASSIGN: 07131 case LOOP: 07132 { 07133 break; 07134 } 07135 default: 07136 bool synPredMatched213 = false; 07137 if (((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2))))) { 07138 int _m213 = mark(); 07139 synPredMatched213 = true; 07140 inputState->guessing++; 07141 try { 07142 { 07143 index_constraint(); 07144 } 07145 } 07146 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 07147 synPredMatched213 = false; 07148 } 07149 rewind(_m213); 07150 inputState->guessing--; 07151 } 07152 if ( synPredMatched213 ) { 07153 index_constraint(); 07154 if (inputState->guessing==0) { 07155 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07156 } 07157 } 07158 else if ((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2)))) { 07159 discriminant_constraint(); 07160 if (inputState->guessing==0) { 07161 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07162 } 07163 } 07164 else { 07165 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07166 } 07167 } 07168 } 07169 constraint_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07170 } 07171 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07172 if( inputState->guessing == 0 ) { 07173 reportError(ex); 07174 consume(); 07175 consumeUntil(_tokenSet_58); 07176 } else { 07177 throw; 07178 } 07179 } 07180 returnAST = constraint_opt_AST; 07181 } 07182 07183 void AdaParser::digits_constraint() { 07184 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07185 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07186 RefAdaAST digits_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07187 ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken; 07188 RefAdaAST d_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07189 07190 try { // for error handling 07191 d = LT(1); 07192 if ( inputState->guessing == 0 ) { 07193 d_AST = astFactory->create(d); 07194 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get())); 07195 } 07196 match(DIGITS); 07197 expression(); 07198 if (inputState->guessing==0) { 07199 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07200 } 07201 range_constraint_opt(); 07202 if (inputState->guessing==0) { 07203 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07204 } 07205 if ( inputState->guessing==0 ) { 07206 #line 692 "ada.g" 07207 Set(d_AST, DIGITS_CONSTRAINT); 07208 #line 7209 "AdaParser.cpp" 07209 } 07210 digits_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07211 } 07212 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07213 if( inputState->guessing == 0 ) { 07214 reportError(ex); 07215 consume(); 07216 consumeUntil(_tokenSet_58); 07217 } else { 07218 throw; 07219 } 07220 } 07221 returnAST = digits_constraint_AST; 07222 } 07223 07224 void AdaParser::delta_constraint() { 07225 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07226 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07227 RefAdaAST delta_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07228 ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken; 07229 RefAdaAST d_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07230 07231 try { // for error handling 07232 d = LT(1); 07233 if ( inputState->guessing == 0 ) { 07234 d_AST = astFactory->create(d); 07235 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get())); 07236 } 07237 match(DELTA); 07238 expression(); 07239 if (inputState->guessing==0) { 07240 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07241 } 07242 range_constraint_opt(); 07243 if (inputState->guessing==0) { 07244 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07245 } 07246 if ( inputState->guessing==0 ) { 07247 #line 696 "ada.g" 07248 Set(d_AST, DELTA_CONSTRAINT); 07249 #line 7250 "AdaParser.cpp" 07250 } 07251 delta_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07252 } 07253 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07254 if( inputState->guessing == 0 ) { 07255 reportError(ex); 07256 consume(); 07257 consumeUntil(_tokenSet_58); 07258 } else { 07259 throw; 07260 } 07261 } 07262 returnAST = delta_constraint_AST; 07263 } 07264 07265 void AdaParser::index_constraint() { 07266 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07267 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07268 RefAdaAST index_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07269 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 07270 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07271 07272 try { // for error handling 07273 p = LT(1); 07274 if ( inputState->guessing == 0 ) { 07275 p_AST = astFactory->create(p); 07276 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 07277 } 07278 match(LPAREN); 07279 discrete_range(); 07280 if (inputState->guessing==0) { 07281 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07282 } 07283 { // ( ... )* 07284 for (;;) { 07285 if ((LA(1) == COMMA)) { 07286 match(COMMA); 07287 discrete_range(); 07288 if (inputState->guessing==0) { 07289 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07290 } 07291 } 07292 else { 07293 goto _loop218; 07294 } 07295 07296 } 07297 _loop218:; 07298 } // ( ... )* 07299 match(RPAREN); 07300 if ( inputState->guessing==0 ) { 07301 #line 700 "ada.g" 07302 Set(p_AST, INDEX_CONSTRAINT); 07303 #line 7304 "AdaParser.cpp" 07304 } 07305 index_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07306 } 07307 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07308 if( inputState->guessing == 0 ) { 07309 reportError(ex); 07310 consume(); 07311 consumeUntil(_tokenSet_58); 07312 } else { 07313 throw; 07314 } 07315 } 07316 returnAST = index_constraint_AST; 07317 } 07318 07319 void AdaParser::discriminant_constraint() { 07320 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07321 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07322 RefAdaAST discriminant_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07323 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 07324 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07325 07326 try { // for error handling 07327 p = LT(1); 07328 if ( inputState->guessing == 0 ) { 07329 p_AST = astFactory->create(p); 07330 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 07331 } 07332 match(LPAREN); 07333 discriminant_association(); 07334 if (inputState->guessing==0) { 07335 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07336 } 07337 { // ( ... )* 07338 for (;;) { 07339 if ((LA(1) == COMMA)) { 07340 match(COMMA); 07341 discriminant_association(); 07342 if (inputState->guessing==0) { 07343 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07344 } 07345 } 07346 else { 07347 goto _loop224; 07348 } 07349 07350 } 07351 _loop224:; 07352 } // ( ... )* 07353 match(RPAREN); 07354 if ( inputState->guessing==0 ) { 07355 #line 710 "ada.g" 07356 Set(p_AST, DISCRIMINANT_CONSTRAINT); 07357 #line 7358 "AdaParser.cpp" 07358 } 07359 discriminant_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07360 } 07361 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07362 if( inputState->guessing == 0 ) { 07363 reportError(ex); 07364 consume(); 07365 consumeUntil(_tokenSet_58); 07366 } else { 07367 throw; 07368 } 07369 } 07370 returnAST = discriminant_constraint_AST; 07371 } 07372 07373 void AdaParser::discrete_range() { 07374 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07375 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07376 RefAdaAST discrete_range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07377 07378 try { // for error handling 07379 bool synPredMatched221 = false; 07380 if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) { 07381 int _m221 = mark(); 07382 synPredMatched221 = true; 07383 inputState->guessing++; 07384 try { 07385 { 07386 range(); 07387 } 07388 } 07389 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 07390 synPredMatched221 = false; 07391 } 07392 rewind(_m221); 07393 inputState->guessing--; 07394 } 07395 if ( synPredMatched221 ) { 07396 range(); 07397 if (inputState->guessing==0) { 07398 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07399 } 07400 discrete_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07401 } 07402 else if ((LA(1) == IDENTIFIER) && (_tokenSet_67.member(LA(2)))) { 07403 subtype_ind(); 07404 if (inputState->guessing==0) { 07405 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07406 } 07407 discrete_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07408 } 07409 else { 07410 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07411 } 07412 07413 } 07414 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07415 if( inputState->guessing == 0 ) { 07416 reportError(ex); 07417 consume(); 07418 consumeUntil(_tokenSet_7); 07419 } else { 07420 throw; 07421 } 07422 } 07423 returnAST = discrete_range_AST; 07424 } 07425 07426 void AdaParser::discriminant_association() { 07427 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07428 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07429 RefAdaAST discriminant_association_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07430 07431 try { // for error handling 07432 selector_names_opt(); 07433 if (inputState->guessing==0) { 07434 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07435 } 07436 expression(); 07437 if (inputState->guessing==0) { 07438 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07439 } 07440 if ( inputState->guessing==0 ) { 07441 discriminant_association_AST = RefAdaAST(currentAST.root); 07442 #line 714 "ada.g" 07443 discriminant_association_AST = 07444 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DISCRIMINANT_ASSOCIATION,"DISCRIMINANT_ASSOCIATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(discriminant_association_AST.get())))); 07445 #line 7446 "AdaParser.cpp" 07446 currentAST.root = discriminant_association_AST; 07447 if ( discriminant_association_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07448 discriminant_association_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07449 currentAST.child = discriminant_association_AST->getFirstChild(); 07450 else 07451 currentAST.child = discriminant_association_AST; 07452 currentAST.advanceChildToEnd(); 07453 } 07454 discriminant_association_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07455 } 07456 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07457 if( inputState->guessing == 0 ) { 07458 reportError(ex); 07459 consume(); 07460 consumeUntil(_tokenSet_7); 07461 } else { 07462 throw; 07463 } 07464 } 07465 returnAST = discriminant_association_AST; 07466 } 07467 07468 void AdaParser::selector_names_opt() { 07469 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07470 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07471 RefAdaAST selector_names_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07472 07473 try { // for error handling 07474 { 07475 bool synPredMatched229 = false; 07476 if (((LA(1) == IDENTIFIER) && (LA(2) == RIGHT_SHAFT || LA(2) == PIPE))) { 07477 int _m229 = mark(); 07478 synPredMatched229 = true; 07479 inputState->guessing++; 07480 try { 07481 { 07482 association_head(); 07483 } 07484 } 07485 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 07486 synPredMatched229 = false; 07487 } 07488 rewind(_m229); 07489 inputState->guessing--; 07490 } 07491 if ( synPredMatched229 ) { 07492 association_head(); 07493 if (inputState->guessing==0) { 07494 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07495 } 07496 } 07497 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_6.member(LA(2)))) { 07498 } 07499 else { 07500 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07501 } 07502 07503 } 07504 if ( inputState->guessing==0 ) { 07505 selector_names_opt_AST = RefAdaAST(currentAST.root); 07506 #line 722 "ada.g" 07507 selector_names_opt_AST = 07508 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SELECTOR_NAMES_OPT,"SELECTOR_NAMES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(selector_names_opt_AST.get())))); 07509 #line 7510 "AdaParser.cpp" 07510 currentAST.root = selector_names_opt_AST; 07511 if ( selector_names_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07512 selector_names_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07513 currentAST.child = selector_names_opt_AST->getFirstChild(); 07514 else 07515 currentAST.child = selector_names_opt_AST; 07516 currentAST.advanceChildToEnd(); 07517 } 07518 selector_names_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07519 } 07520 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07521 if( inputState->guessing == 0 ) { 07522 reportError(ex); 07523 consume(); 07524 consumeUntil(_tokenSet_5); 07525 } else { 07526 throw; 07527 } 07528 } 07529 returnAST = selector_names_opt_AST; 07530 } 07531 07532 void AdaParser::association_head() { 07533 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07534 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07535 RefAdaAST association_head_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07536 07537 try { // for error handling 07538 selector_name(); 07539 if (inputState->guessing==0) { 07540 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07541 } 07542 { // ( ... )* 07543 for (;;) { 07544 if ((LA(1) == PIPE)) { 07545 match(PIPE); 07546 selector_name(); 07547 if (inputState->guessing==0) { 07548 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07549 } 07550 } 07551 else { 07552 goto _loop232; 07553 } 07554 07555 } 07556 _loop232:; 07557 } // ( ... )* 07558 match(RIGHT_SHAFT); 07559 association_head_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07560 } 07561 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07562 if( inputState->guessing == 0 ) { 07563 reportError(ex); 07564 consume(); 07565 consumeUntil(_tokenSet_5); 07566 } else { 07567 throw; 07568 } 07569 } 07570 returnAST = association_head_AST; 07571 } 07572 07573 void AdaParser::selector_name() { 07574 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07575 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07576 RefAdaAST selector_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07577 07578 try { // for error handling 07579 RefAdaAST tmp204_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07580 if ( inputState->guessing == 0 ) { 07581 tmp204_AST = astFactory->create(LT(1)); 07582 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp204_AST.get())); 07583 } 07584 match(IDENTIFIER); 07585 selector_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07586 } 07587 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07588 if( inputState->guessing == 0 ) { 07589 reportError(ex); 07590 consume(); 07591 consumeUntil(_tokenSet_68); 07592 } else { 07593 throw; 07594 } 07595 } 07596 returnAST = selector_name_AST; 07597 } 07598 07599 void AdaParser::protected_opt() { 07600 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07601 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07602 RefAdaAST protected_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07603 07604 try { // for error handling 07605 { 07606 switch ( LA(1)) { 07607 case PROTECTED: 07608 { 07609 RefAdaAST tmp205_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07610 if ( inputState->guessing == 0 ) { 07611 tmp205_AST = astFactory->create(LT(1)); 07612 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp205_AST.get())); 07613 } 07614 match(PROTECTED); 07615 break; 07616 } 07617 case PROCEDURE: 07618 case FUNCTION: 07619 { 07620 break; 07621 } 07622 default: 07623 { 07624 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07625 } 07626 } 07627 } 07628 if ( inputState->guessing==0 ) { 07629 protected_opt_AST = RefAdaAST(currentAST.root); 07630 #line 747 "ada.g" 07631 protected_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(protected_opt_AST.get())))); 07632 #line 7633 "AdaParser.cpp" 07633 currentAST.root = protected_opt_AST; 07634 if ( protected_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07635 protected_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07636 currentAST.child = protected_opt_AST->getFirstChild(); 07637 else 07638 currentAST.child = protected_opt_AST; 07639 currentAST.advanceChildToEnd(); 07640 } 07641 protected_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07642 } 07643 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07644 if( inputState->guessing == 0 ) { 07645 reportError(ex); 07646 consume(); 07647 consumeUntil(_tokenSet_69); 07648 } else { 07649 throw; 07650 } 07651 } 07652 returnAST = protected_opt_AST; 07653 } 07654 07655 void AdaParser::constant_all_opt() { 07656 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07657 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07658 RefAdaAST constant_all_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07659 07660 try { // for error handling 07661 { 07662 switch ( LA(1)) { 07663 case CONSTANT: 07664 { 07665 RefAdaAST tmp206_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07666 if ( inputState->guessing == 0 ) { 07667 tmp206_AST = astFactory->create(LT(1)); 07668 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp206_AST.get())); 07669 } 07670 match(CONSTANT); 07671 break; 07672 } 07673 case ALL: 07674 { 07675 RefAdaAST tmp207_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07676 if ( inputState->guessing == 0 ) { 07677 tmp207_AST = astFactory->create(LT(1)); 07678 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp207_AST.get())); 07679 } 07680 match(ALL); 07681 break; 07682 } 07683 case IDENTIFIER: 07684 { 07685 break; 07686 } 07687 default: 07688 { 07689 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07690 } 07691 } 07692 } 07693 if ( inputState->guessing==0 ) { 07694 constant_all_opt_AST = RefAdaAST(currentAST.root); 07695 #line 751 "ada.g" 07696 constant_all_opt_AST = 07697 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(constant_all_opt_AST.get())))); 07698 #line 7699 "AdaParser.cpp" 07699 currentAST.root = constant_all_opt_AST; 07700 if ( constant_all_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07701 constant_all_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07702 currentAST.child = constant_all_opt_AST->getFirstChild(); 07703 else 07704 currentAST.child = constant_all_opt_AST; 07705 currentAST.advanceChildToEnd(); 07706 } 07707 constant_all_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07708 } 07709 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07710 if( inputState->guessing == 0 ) { 07711 reportError(ex); 07712 consume(); 07713 consumeUntil(_tokenSet_39); 07714 } else { 07715 throw; 07716 } 07717 } 07718 returnAST = constant_all_opt_AST; 07719 } 07720 07721 void AdaParser::abstract_opt() { 07722 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07723 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07724 RefAdaAST abstract_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07725 07726 try { // for error handling 07727 { 07728 switch ( LA(1)) { 07729 case ABSTRACT: 07730 { 07731 RefAdaAST tmp208_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07732 if ( inputState->guessing == 0 ) { 07733 tmp208_AST = astFactory->create(LT(1)); 07734 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp208_AST.get())); 07735 } 07736 match(ABSTRACT); 07737 break; 07738 } 07739 case NEW: 07740 { 07741 break; 07742 } 07743 default: 07744 { 07745 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07746 } 07747 } 07748 } 07749 if ( inputState->guessing==0 ) { 07750 abstract_opt_AST = RefAdaAST(currentAST.root); 07751 #line 771 "ada.g" 07752 abstract_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abstract_opt_AST.get())))); 07753 #line 7754 "AdaParser.cpp" 07754 currentAST.root = abstract_opt_AST; 07755 if ( abstract_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07756 abstract_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07757 currentAST.child = abstract_opt_AST->getFirstChild(); 07758 else 07759 currentAST.child = abstract_opt_AST; 07760 currentAST.advanceChildToEnd(); 07761 } 07762 abstract_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07763 } 07764 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07765 if( inputState->guessing == 0 ) { 07766 reportError(ex); 07767 consume(); 07768 consumeUntil(_tokenSet_70); 07769 } else { 07770 throw; 07771 } 07772 } 07773 returnAST = abstract_opt_AST; 07774 } 07775 07776 void AdaParser::record_definition( 07777 bool has_discrim 07778 ) { 07779 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07780 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07781 RefAdaAST record_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07782 07783 try { // for error handling 07784 switch ( LA(1)) { 07785 case RECORD: 07786 { 07787 match(RECORD); 07788 component_list(has_discrim); 07789 if (inputState->guessing==0) { 07790 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07791 } 07792 match(END); 07793 match(RECORD); 07794 record_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07795 break; 07796 } 07797 case NuLL: 07798 { 07799 match(NuLL); 07800 match(RECORD); 07801 record_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07802 break; 07803 } 07804 default: 07805 { 07806 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07807 } 07808 } 07809 } 07810 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07811 if( inputState->guessing == 0 ) { 07812 reportError(ex); 07813 consume(); 07814 consumeUntil(_tokenSet_4); 07815 } else { 07816 throw; 07817 } 07818 } 07819 returnAST = record_definition_AST; 07820 } 07821 07822 void AdaParser::abstract_tagged_limited_opt() { 07823 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07824 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07825 RefAdaAST abstract_tagged_limited_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07826 07827 try { // for error handling 07828 { 07829 switch ( LA(1)) { 07830 case ABSTRACT: 07831 { 07832 RefAdaAST tmp214_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07833 if ( inputState->guessing == 0 ) { 07834 tmp214_AST = astFactory->create(LT(1)); 07835 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp214_AST.get())); 07836 } 07837 match(ABSTRACT); 07838 match(TAGGED); 07839 break; 07840 } 07841 case TAGGED: 07842 { 07843 RefAdaAST tmp216_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07844 if ( inputState->guessing == 0 ) { 07845 tmp216_AST = astFactory->create(LT(1)); 07846 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp216_AST.get())); 07847 } 07848 match(TAGGED); 07849 break; 07850 } 07851 case PRIVATE: 07852 case NuLL: 07853 case RECORD: 07854 case LIMITED: 07855 { 07856 break; 07857 } 07858 default: 07859 { 07860 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07861 } 07862 } 07863 } 07864 { 07865 switch ( LA(1)) { 07866 case LIMITED: 07867 { 07868 RefAdaAST tmp217_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07869 if ( inputState->guessing == 0 ) { 07870 tmp217_AST = astFactory->create(LT(1)); 07871 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp217_AST.get())); 07872 } 07873 match(LIMITED); 07874 break; 07875 } 07876 case PRIVATE: 07877 case NuLL: 07878 case RECORD: 07879 { 07880 break; 07881 } 07882 default: 07883 { 07884 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07885 } 07886 } 07887 } 07888 if ( inputState->guessing==0 ) { 07889 abstract_tagged_limited_opt_AST = RefAdaAST(currentAST.root); 07890 #line 833 "ada.g" 07891 abstract_tagged_limited_opt_AST = 07892 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abstract_tagged_limited_opt_AST.get())))); 07893 #line 7894 "AdaParser.cpp" 07894 currentAST.root = abstract_tagged_limited_opt_AST; 07895 if ( abstract_tagged_limited_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 07896 abstract_tagged_limited_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 07897 currentAST.child = abstract_tagged_limited_opt_AST->getFirstChild(); 07898 else 07899 currentAST.child = abstract_tagged_limited_opt_AST; 07900 currentAST.advanceChildToEnd(); 07901 } 07902 abstract_tagged_limited_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07903 } 07904 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07905 if( inputState->guessing == 0 ) { 07906 reportError(ex); 07907 consume(); 07908 consumeUntil(_tokenSet_71); 07909 } else { 07910 throw; 07911 } 07912 } 07913 returnAST = abstract_tagged_limited_opt_AST; 07914 } 07915 07916 void AdaParser::component_list( 07917 bool has_discrim 07918 ) { 07919 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07920 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 07921 RefAdaAST component_list_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 07922 07923 try { // for error handling 07924 switch ( LA(1)) { 07925 case NuLL: 07926 { 07927 match(NuLL); 07928 match(SEMI); 07929 component_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07930 break; 07931 } 07932 case PRAGMA: 07933 case IDENTIFIER: 07934 { 07935 component_items(); 07936 if (inputState->guessing==0) { 07937 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07938 } 07939 { 07940 switch ( LA(1)) { 07941 case CASE: 07942 { 07943 variant_part(); 07944 if (inputState->guessing==0) { 07945 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07946 } 07947 if (!( has_discrim )) 07948 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim "); 07949 break; 07950 } 07951 case END: 07952 case WHEN: 07953 { 07954 break; 07955 } 07956 default: 07957 { 07958 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07959 } 07960 } 07961 } 07962 component_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07963 break; 07964 } 07965 case CASE: 07966 { 07967 empty_component_items(); 07968 if (inputState->guessing==0) { 07969 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07970 } 07971 variant_part(); 07972 if (inputState->guessing==0) { 07973 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 07974 } 07975 if (!( has_discrim )) 07976 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" has_discrim "); 07977 component_list_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 07978 break; 07979 } 07980 default: 07981 { 07982 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 07983 } 07984 } 07985 } 07986 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 07987 if( inputState->guessing == 0 ) { 07988 reportError(ex); 07989 consume(); 07990 consumeUntil(_tokenSet_72); 07991 } else { 07992 throw; 07993 } 07994 } 07995 returnAST = component_list_AST; 07996 } 07997 07998 void AdaParser::component_items() { 07999 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08000 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08001 RefAdaAST component_items_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08002 08003 try { // for error handling 08004 { // ( ... )+ 08005 int _cnt254=0; 08006 for (;;) { 08007 switch ( LA(1)) { 08008 case PRAGMA: 08009 { 08010 pragma(); 08011 if (inputState->guessing==0) { 08012 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08013 } 08014 break; 08015 } 08016 case IDENTIFIER: 08017 { 08018 comp_decl(); 08019 if (inputState->guessing==0) { 08020 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08021 } 08022 break; 08023 } 08024 default: 08025 { 08026 if ( _cnt254>=1 ) { goto _loop254; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} 08027 } 08028 } 08029 _cnt254++; 08030 } 08031 _loop254:; 08032 } // ( ... )+ 08033 if ( inputState->guessing==0 ) { 08034 component_items_AST = RefAdaAST(currentAST.root); 08035 #line 786 "ada.g" 08036 component_items_AST = 08037 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(component_items_AST.get())))); 08038 #line 8039 "AdaParser.cpp" 08039 currentAST.root = component_items_AST; 08040 if ( component_items_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 08041 component_items_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 08042 currentAST.child = component_items_AST->getFirstChild(); 08043 else 08044 currentAST.child = component_items_AST; 08045 currentAST.advanceChildToEnd(); 08046 } 08047 component_items_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08048 } 08049 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08050 if( inputState->guessing == 0 ) { 08051 reportError(ex); 08052 consume(); 08053 consumeUntil(_tokenSet_73); 08054 } else { 08055 throw; 08056 } 08057 } 08058 returnAST = component_items_AST; 08059 } 08060 08061 void AdaParser::variant_part() { 08062 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08063 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08064 RefAdaAST variant_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08065 ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken; 08066 RefAdaAST c_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08067 08068 try { // for error handling 08069 c = LT(1); 08070 if ( inputState->guessing == 0 ) { 08071 c_AST = astFactory->create(c); 08072 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get())); 08073 } 08074 match(CASE); 08075 discriminant_direct_name(); 08076 if (inputState->guessing==0) { 08077 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08078 } 08079 match(IS); 08080 variant_s(); 08081 if (inputState->guessing==0) { 08082 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08083 } 08084 match(END); 08085 match(CASE); 08086 match(SEMI); 08087 if ( inputState->guessing==0 ) { 08088 #line 798 "ada.g" 08089 Set (c_AST, VARIANT_PART); 08090 #line 8091 "AdaParser.cpp" 08091 } 08092 variant_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08093 } 08094 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08095 if( inputState->guessing == 0 ) { 08096 reportError(ex); 08097 consume(); 08098 consumeUntil(_tokenSet_72); 08099 } else { 08100 throw; 08101 } 08102 } 08103 returnAST = variant_part_AST; 08104 } 08105 08106 void AdaParser::empty_component_items() { 08107 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08108 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08109 RefAdaAST empty_component_items_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08110 08111 try { // for error handling 08112 if ( inputState->guessing==0 ) { 08113 empty_component_items_AST = RefAdaAST(currentAST.root); 08114 #line 792 "ada.g" 08115 empty_component_items_AST = 08116 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(COMPONENT_ITEMS,"COMPONENT_ITEMS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(empty_component_items_AST.get())))); 08117 #line 8118 "AdaParser.cpp" 08118 currentAST.root = empty_component_items_AST; 08119 if ( empty_component_items_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 08120 empty_component_items_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 08121 currentAST.child = empty_component_items_AST->getFirstChild(); 08122 else 08123 currentAST.child = empty_component_items_AST; 08124 currentAST.advanceChildToEnd(); 08125 } 08126 empty_component_items_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08127 } 08128 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08129 if( inputState->guessing == 0 ) { 08130 reportError(ex); 08131 consume(); 08132 consumeUntil(_tokenSet_74); 08133 } else { 08134 throw; 08135 } 08136 } 08137 returnAST = empty_component_items_AST; 08138 } 08139 08140 void AdaParser::discriminant_direct_name() { 08141 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08142 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08143 RefAdaAST discriminant_direct_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08144 08145 try { // for error handling 08146 RefAdaAST tmp224_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08147 if ( inputState->guessing == 0 ) { 08148 tmp224_AST = astFactory->create(LT(1)); 08149 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp224_AST.get())); 08150 } 08151 match(IDENTIFIER); 08152 discriminant_direct_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08153 } 08154 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08155 if( inputState->guessing == 0 ) { 08156 reportError(ex); 08157 consume(); 08158 consumeUntil(_tokenSet_75); 08159 } else { 08160 throw; 08161 } 08162 } 08163 returnAST = discriminant_direct_name_AST; 08164 } 08165 08166 void AdaParser::variant_s() { 08167 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08168 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08169 RefAdaAST variant_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08170 08171 try { // for error handling 08172 { // ( ... )+ 08173 int _cnt260=0; 08174 for (;;) { 08175 if ((LA(1) == WHEN)) { 08176 variant(); 08177 if (inputState->guessing==0) { 08178 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08179 } 08180 } 08181 else { 08182 if ( _cnt260>=1 ) { goto _loop260; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} 08183 } 08184 08185 _cnt260++; 08186 } 08187 _loop260:; 08188 } // ( ... )+ 08189 if ( inputState->guessing==0 ) { 08190 variant_s_AST = RefAdaAST(currentAST.root); 08191 #line 805 "ada.g" 08192 variant_s_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(VARIANTS,"VARIANTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(variant_s_AST.get())))); 08193 #line 8194 "AdaParser.cpp" 08194 currentAST.root = variant_s_AST; 08195 if ( variant_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 08196 variant_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 08197 currentAST.child = variant_s_AST->getFirstChild(); 08198 else 08199 currentAST.child = variant_s_AST; 08200 currentAST.advanceChildToEnd(); 08201 } 08202 variant_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08203 } 08204 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08205 if( inputState->guessing == 0 ) { 08206 reportError(ex); 08207 consume(); 08208 consumeUntil(_tokenSet_21); 08209 } else { 08210 throw; 08211 } 08212 } 08213 returnAST = variant_s_AST; 08214 } 08215 08216 void AdaParser::variant() { 08217 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08218 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08219 RefAdaAST variant_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08220 ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; 08221 RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08222 08223 try { // for error handling 08224 w = LT(1); 08225 if ( inputState->guessing == 0 ) { 08226 w_AST = astFactory->create(w); 08227 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get())); 08228 } 08229 match(WHEN); 08230 choice_s(); 08231 if (inputState->guessing==0) { 08232 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08233 } 08234 match(RIGHT_SHAFT); 08235 component_list(true); 08236 if (inputState->guessing==0) { 08237 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08238 } 08239 if ( inputState->guessing==0 ) { 08240 #line 809 "ada.g" 08241 Set (w_AST, VARIANT); 08242 #line 8243 "AdaParser.cpp" 08243 } 08244 variant_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08245 } 08246 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08247 if( inputState->guessing == 0 ) { 08248 reportError(ex); 08249 consume(); 08250 consumeUntil(_tokenSet_72); 08251 } else { 08252 throw; 08253 } 08254 } 08255 returnAST = variant_AST; 08256 } 08257 08258 void AdaParser::choice_s() { 08259 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08260 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08261 RefAdaAST choice_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08262 08263 try { // for error handling 08264 choice(); 08265 if (inputState->guessing==0) { 08266 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08267 } 08268 { // ( ... )* 08269 for (;;) { 08270 if ((LA(1) == PIPE)) { 08271 RefAdaAST tmp226_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08272 if ( inputState->guessing == 0 ) { 08273 tmp226_AST = astFactory->create(LT(1)); 08274 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp226_AST.get())); 08275 } 08276 match(PIPE); 08277 choice(); 08278 if (inputState->guessing==0) { 08279 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08280 } 08281 } 08282 else { 08283 goto _loop264; 08284 } 08285 08286 } 08287 _loop264:; 08288 } // ( ... )* 08289 choice_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08290 } 08291 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08292 if( inputState->guessing == 0 ) { 08293 reportError(ex); 08294 consume(); 08295 consumeUntil(_tokenSet_76); 08296 } else { 08297 throw; 08298 } 08299 } 08300 returnAST = choice_s_AST; 08301 } 08302 08303 void AdaParser::choice() { 08304 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08305 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08306 RefAdaAST choice_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08307 08308 try { // for error handling 08309 if ((LA(1) == OTHERS)) { 08310 RefAdaAST tmp227_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08311 if ( inputState->guessing == 0 ) { 08312 tmp227_AST = astFactory->create(LT(1)); 08313 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp227_AST.get())); 08314 } 08315 match(OTHERS); 08316 choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08317 } 08318 else { 08319 bool synPredMatched267 = false; 08320 if (((_tokenSet_5.member(LA(1))) && (_tokenSet_77.member(LA(2))))) { 08321 int _m267 = mark(); 08322 synPredMatched267 = true; 08323 inputState->guessing++; 08324 try { 08325 { 08326 discrete_with_range(); 08327 } 08328 } 08329 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 08330 synPredMatched267 = false; 08331 } 08332 rewind(_m267); 08333 inputState->guessing--; 08334 } 08335 if ( synPredMatched267 ) { 08336 discrete_with_range(); 08337 if (inputState->guessing==0) { 08338 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08339 } 08340 choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08341 } 08342 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_78.member(LA(2)))) { 08343 expression(); 08344 if (inputState->guessing==0) { 08345 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08346 } 08347 choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08348 } 08349 else { 08350 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08351 } 08352 } 08353 } 08354 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08355 if( inputState->guessing == 0 ) { 08356 reportError(ex); 08357 consume(); 08358 consumeUntil(_tokenSet_68); 08359 } else { 08360 throw; 08361 } 08362 } 08363 returnAST = choice_AST; 08364 } 08365 08366 void AdaParser::discrete_with_range() { 08367 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08368 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08369 RefAdaAST discrete_with_range_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08370 08371 try { // for error handling 08372 bool synPredMatched270 = false; 08373 if (((LA(1) == IDENTIFIER) && (LA(2) == DOT || LA(2) == TIC || LA(2) == RANGE))) { 08374 int _m270 = mark(); 08375 synPredMatched270 = true; 08376 inputState->guessing++; 08377 try { 08378 { 08379 mark_with_constraint(); 08380 } 08381 } 08382 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 08383 synPredMatched270 = false; 08384 } 08385 rewind(_m270); 08386 inputState->guessing--; 08387 } 08388 if ( synPredMatched270 ) { 08389 mark_with_constraint(); 08390 if (inputState->guessing==0) { 08391 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08392 } 08393 discrete_with_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08394 } 08395 else if ((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2)))) { 08396 range(); 08397 if (inputState->guessing==0) { 08398 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08399 } 08400 discrete_with_range_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08401 } 08402 else { 08403 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08404 } 08405 08406 } 08407 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08408 if( inputState->guessing == 0 ) { 08409 reportError(ex); 08410 consume(); 08411 consumeUntil(_tokenSet_68); 08412 } else { 08413 throw; 08414 } 08415 } 08416 returnAST = discrete_with_range_AST; 08417 } 08418 08419 void AdaParser::mark_with_constraint() { 08420 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08421 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08422 RefAdaAST mark_with_constraint_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08423 08424 try { // for error handling 08425 subtype_mark(); 08426 if (inputState->guessing==0) { 08427 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08428 } 08429 range_constraint(); 08430 if (inputState->guessing==0) { 08431 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08432 } 08433 if ( inputState->guessing==0 ) { 08434 mark_with_constraint_AST = RefAdaAST(currentAST.root); 08435 #line 825 "ada.g" 08436 mark_with_constraint_AST = 08437 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MARK_WITH_CONSTRAINT,"MARK_WITH_CONSTRAINT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(mark_with_constraint_AST.get())))); 08438 #line 8439 "AdaParser.cpp" 08439 currentAST.root = mark_with_constraint_AST; 08440 if ( mark_with_constraint_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 08441 mark_with_constraint_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 08442 currentAST.child = mark_with_constraint_AST->getFirstChild(); 08443 else 08444 currentAST.child = mark_with_constraint_AST; 08445 currentAST.advanceChildToEnd(); 08446 } 08447 mark_with_constraint_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08448 } 08449 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08450 if( inputState->guessing == 0 ) { 08451 reportError(ex); 08452 consume(); 08453 consumeUntil(_tokenSet_68); 08454 } else { 08455 throw; 08456 } 08457 } 08458 returnAST = mark_with_constraint_AST; 08459 } 08460 08461 void AdaParser::generic_formal_part_opt() { 08462 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08463 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08464 RefAdaAST generic_formal_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08465 08466 try { // for error handling 08467 { // ( ... )* 08468 for (;;) { 08469 switch ( LA(1)) { 08470 case USE: 08471 { 08472 use_clause(); 08473 if (inputState->guessing==0) { 08474 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08475 } 08476 break; 08477 } 08478 case PRAGMA: 08479 { 08480 pragma(); 08481 if (inputState->guessing==0) { 08482 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08483 } 08484 break; 08485 } 08486 case IDENTIFIER: 08487 case WITH: 08488 case TYPE: 08489 { 08490 generic_formal_parameter(); 08491 if (inputState->guessing==0) { 08492 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08493 } 08494 break; 08495 } 08496 default: 08497 { 08498 goto _loop287; 08499 } 08500 } 08501 } 08502 _loop287:; 08503 } // ( ... )* 08504 if ( inputState->guessing==0 ) { 08505 generic_formal_part_opt_AST = RefAdaAST(currentAST.root); 08506 #line 871 "ada.g" 08507 generic_formal_part_opt_AST = 08508 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(GENERIC_FORMAL_PART,"GENERIC_FORMAL_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(generic_formal_part_opt_AST.get())))); 08509 #line 8510 "AdaParser.cpp" 08510 currentAST.root = generic_formal_part_opt_AST; 08511 if ( generic_formal_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 08512 generic_formal_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 08513 currentAST.child = generic_formal_part_opt_AST->getFirstChild(); 08514 else 08515 currentAST.child = generic_formal_part_opt_AST; 08516 currentAST.advanceChildToEnd(); 08517 } 08518 generic_formal_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08519 } 08520 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08521 if( inputState->guessing == 0 ) { 08522 reportError(ex); 08523 consume(); 08524 consumeUntil(_tokenSet_79); 08525 } else { 08526 throw; 08527 } 08528 } 08529 returnAST = generic_formal_part_opt_AST; 08530 } 08531 08532 void AdaParser::generic_formal_parameter() { 08533 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08534 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08535 RefAdaAST generic_formal_parameter_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08536 ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; 08537 RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08538 ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; 08539 RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08540 08541 try { // for error handling 08542 { 08543 switch ( LA(1)) { 08544 case TYPE: 08545 { 08546 t = LT(1); 08547 if ( inputState->guessing == 0 ) { 08548 t_AST = astFactory->create(t); 08549 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get())); 08550 } 08551 match(TYPE); 08552 def_id(false); 08553 if (inputState->guessing==0) { 08554 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08555 } 08556 { 08557 switch ( LA(1)) { 08558 case IS: 08559 { 08560 match(IS); 08561 { 08562 switch ( LA(1)) { 08563 case LPAREN: 08564 { 08565 match(LPAREN); 08566 match(BOX); 08567 match(RPAREN); 08568 if ( inputState->guessing==0 ) { 08569 #line 881 "ada.g" 08570 Set (t_AST, FORMAL_DISCRETE_TYPE_DECLARATION); 08571 #line 8572 "AdaParser.cpp" 08572 } 08573 break; 08574 } 08575 case RANGE: 08576 { 08577 match(RANGE); 08578 match(BOX); 08579 if ( inputState->guessing==0 ) { 08580 #line 883 "ada.g" 08581 Set (t_AST, FORMAL_SIGNED_INTEGER_TYPE_DECLARATION); 08582 #line 8583 "AdaParser.cpp" 08583 } 08584 break; 08585 } 08586 case MOD: 08587 { 08588 match(MOD); 08589 match(BOX); 08590 if ( inputState->guessing==0 ) { 08591 #line 885 "ada.g" 08592 Set (t_AST, FORMAL_MODULAR_TYPE_DECLARATION); 08593 #line 8594 "AdaParser.cpp" 08594 } 08595 break; 08596 } 08597 case DELTA: 08598 { 08599 match(DELTA); 08600 match(BOX); 08601 { 08602 switch ( LA(1)) { 08603 case DIGITS: 08604 { 08605 match(DIGITS); 08606 match(BOX); 08607 if ( inputState->guessing==0 ) { 08608 #line 888 "ada.g" 08609 Set (t_AST, FORMAL_DECIMAL_FIXED_POINT_DECLARATION); 08610 #line 8611 "AdaParser.cpp" 08611 } 08612 break; 08613 } 08614 case SEMI: 08615 { 08616 if ( inputState->guessing==0 ) { 08617 #line 889 "ada.g" 08618 Set (t_AST, FORMAL_ORDINARY_FIXED_POINT_DECLARATION); 08619 #line 8620 "AdaParser.cpp" 08620 } 08621 break; 08622 } 08623 default: 08624 { 08625 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08626 } 08627 } 08628 } 08629 break; 08630 } 08631 case DIGITS: 08632 { 08633 match(DIGITS); 08634 match(BOX); 08635 if ( inputState->guessing==0 ) { 08636 #line 892 "ada.g" 08637 Set (t_AST, FORMAL_FLOATING_POINT_DECLARATION); 08638 #line 8639 "AdaParser.cpp" 08639 } 08640 break; 08641 } 08642 case ARRAY: 08643 { 08644 array_type_definition(t_AST); 08645 if (inputState->guessing==0) { 08646 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08647 } 08648 break; 08649 } 08650 case ACCESS: 08651 { 08652 access_type_definition(t_AST); 08653 if (inputState->guessing==0) { 08654 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08655 } 08656 break; 08657 } 08658 case PRIVATE: 08659 case NEW: 08660 case ABSTRACT: 08661 case TAGGED: 08662 case LIMITED: 08663 { 08664 empty_discrim_opt(); 08665 if (inputState->guessing==0) { 08666 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08667 } 08668 discriminable_type_definition(t_AST); 08669 if (inputState->guessing==0) { 08670 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08671 } 08672 break; 08673 } 08674 default: 08675 { 08676 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08677 } 08678 } 08679 } 08680 break; 08681 } 08682 case LPAREN: 08683 { 08684 discrim_part(); 08685 if (inputState->guessing==0) { 08686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08687 } 08688 match(IS); 08689 discriminable_type_definition(t_AST); 08690 if (inputState->guessing==0) { 08691 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08692 } 08693 break; 08694 } 08695 default: 08696 { 08697 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08698 } 08699 } 08700 } 08701 if ( inputState->guessing==0 ) { 08702 #line 899 "ada.g" 08703 pop_def_id(); 08704 #line 8705 "AdaParser.cpp" 08705 } 08706 break; 08707 } 08708 case WITH: 08709 { 08710 w = LT(1); 08711 if ( inputState->guessing == 0 ) { 08712 w_AST = astFactory->create(w); 08713 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get())); 08714 } 08715 match(WITH); 08716 { 08717 switch ( LA(1)) { 08718 case PROCEDURE: 08719 { 08720 match(PROCEDURE); 08721 def_id(false); 08722 if (inputState->guessing==0) { 08723 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08724 } 08725 formal_part_opt(); 08726 if (inputState->guessing==0) { 08727 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08728 } 08729 subprogram_default_opt(); 08730 if (inputState->guessing==0) { 08731 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08732 } 08733 if ( inputState->guessing==0 ) { 08734 #line 901 "ada.g" 08735 Set(w_AST, FORMAL_PROCEDURE_DECLARATION); 08736 #line 8737 "AdaParser.cpp" 08737 } 08738 break; 08739 } 08740 case FUNCTION: 08741 { 08742 match(FUNCTION); 08743 def_designator(false); 08744 if (inputState->guessing==0) { 08745 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08746 } 08747 function_tail(); 08748 if (inputState->guessing==0) { 08749 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08750 } 08751 subprogram_default_opt(); 08752 if (inputState->guessing==0) { 08753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08754 } 08755 if ( inputState->guessing==0 ) { 08756 #line 903 "ada.g" 08757 Set(w_AST, FORMAL_FUNCTION_DECLARATION); 08758 #line 8759 "AdaParser.cpp" 08759 } 08760 break; 08761 } 08762 case PACKAGE: 08763 { 08764 match(PACKAGE); 08765 def_id(false); 08766 if (inputState->guessing==0) { 08767 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08768 } 08769 match(IS); 08770 match(NEW); 08771 compound_name(); 08772 if (inputState->guessing==0) { 08773 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08774 } 08775 formal_package_actual_part_opt(); 08776 if (inputState->guessing==0) { 08777 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08778 } 08779 if ( inputState->guessing==0 ) { 08780 #line 905 "ada.g" 08781 Set(w_AST, FORMAL_PACKAGE_DECLARATION); 08782 #line 8783 "AdaParser.cpp" 08783 } 08784 break; 08785 } 08786 default: 08787 { 08788 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08789 } 08790 } 08791 } 08792 if ( inputState->guessing==0 ) { 08793 #line 907 "ada.g" 08794 pop_def_id(); 08795 #line 8796 "AdaParser.cpp" 08796 } 08797 break; 08798 } 08799 case IDENTIFIER: 08800 { 08801 parameter_specification(); 08802 if (inputState->guessing==0) { 08803 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08804 } 08805 break; 08806 } 08807 default: 08808 { 08809 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08810 } 08811 } 08812 } 08813 match(SEMI); 08814 generic_formal_parameter_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08815 } 08816 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08817 if( inputState->guessing == 0 ) { 08818 reportError(ex); 08819 consume(); 08820 consumeUntil(_tokenSet_80); 08821 } else { 08822 throw; 08823 } 08824 } 08825 returnAST = generic_formal_parameter_AST; 08826 } 08827 08828 void AdaParser::discriminable_type_definition( 08829 RefAdaAST t 08830 ) { 08831 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08832 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08833 RefAdaAST discriminable_type_definition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08834 08835 try { // for error handling 08836 bool synPredMatched297 = false; 08837 if (((LA(1) == NEW || LA(1) == ABSTRACT) && (LA(2) == IDENTIFIER || LA(2) == NEW))) { 08838 int _m297 = mark(); 08839 synPredMatched297 = true; 08840 inputState->guessing++; 08841 try { 08842 { 08843 { 08844 switch ( LA(1)) { 08845 case ABSTRACT: 08846 { 08847 match(ABSTRACT); 08848 break; 08849 } 08850 case NEW: 08851 { 08852 break; 08853 } 08854 default: 08855 { 08856 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08857 } 08858 } 08859 } 08860 match(NEW); 08861 subtype_ind(); 08862 match(WITH); 08863 } 08864 } 08865 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 08866 synPredMatched297 = false; 08867 } 08868 rewind(_m297); 08869 inputState->guessing--; 08870 } 08871 if ( synPredMatched297 ) { 08872 abstract_opt(); 08873 if (inputState->guessing==0) { 08874 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08875 } 08876 match(NEW); 08877 subtype_ind(); 08878 if (inputState->guessing==0) { 08879 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08880 } 08881 match(WITH); 08882 match(PRIVATE); 08883 if ( inputState->guessing==0 ) { 08884 #line 916 "ada.g" 08885 Set (t, FORMAL_PRIVATE_EXTENSION_DECLARATION); 08886 #line 8887 "AdaParser.cpp" 08887 } 08888 discriminable_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08889 } 08890 else if ((LA(1) == NEW) && (LA(2) == IDENTIFIER)) { 08891 match(NEW); 08892 subtype_ind(); 08893 if (inputState->guessing==0) { 08894 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08895 } 08896 if ( inputState->guessing==0 ) { 08897 #line 918 "ada.g" 08898 Set (t, FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION); 08899 #line 8900 "AdaParser.cpp" 08900 } 08901 discriminable_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08902 } 08903 else if ((_tokenSet_81.member(LA(1))) && (_tokenSet_82.member(LA(2)))) { 08904 abstract_tagged_limited_opt(); 08905 if (inputState->guessing==0) { 08906 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08907 } 08908 match(PRIVATE); 08909 if ( inputState->guessing==0 ) { 08910 #line 920 "ada.g" 08911 Set (t, FORMAL_PRIVATE_TYPE_DECLARATION); 08912 #line 8913 "AdaParser.cpp" 08913 } 08914 discriminable_type_definition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08915 } 08916 else { 08917 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08918 } 08919 08920 } 08921 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08922 if( inputState->guessing == 0 ) { 08923 reportError(ex); 08924 consume(); 08925 consumeUntil(_tokenSet_4); 08926 } else { 08927 throw; 08928 } 08929 } 08930 returnAST = discriminable_type_definition_AST; 08931 } 08932 08933 void AdaParser::subprogram_default_opt() { 08934 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08935 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08936 RefAdaAST subprogram_default_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08937 08938 try { // for error handling 08939 { 08940 switch ( LA(1)) { 08941 case IS: 08942 { 08943 match(IS); 08944 { 08945 switch ( LA(1)) { 08946 case BOX: 08947 { 08948 RefAdaAST tmp255_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08949 if ( inputState->guessing == 0 ) { 08950 tmp255_AST = astFactory->create(LT(1)); 08951 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp255_AST.get())); 08952 } 08953 match(BOX); 08954 break; 08955 } 08956 case IDENTIFIER: 08957 { 08958 name(); 08959 if (inputState->guessing==0) { 08960 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 08961 } 08962 break; 08963 } 08964 default: 08965 { 08966 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08967 } 08968 } 08969 } 08970 break; 08971 } 08972 case SEMI: 08973 { 08974 break; 08975 } 08976 default: 08977 { 08978 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 08979 } 08980 } 08981 } 08982 subprogram_default_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 08983 } 08984 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 08985 if( inputState->guessing == 0 ) { 08986 reportError(ex); 08987 consume(); 08988 consumeUntil(_tokenSet_4); 08989 } else { 08990 throw; 08991 } 08992 } 08993 returnAST = subprogram_default_opt_AST; 08994 } 08995 08996 void AdaParser::formal_package_actual_part_opt() { 08997 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 08998 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 08999 RefAdaAST formal_package_actual_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09000 09001 try { // for error handling 09002 { 09003 switch ( LA(1)) { 09004 case LPAREN: 09005 { 09006 match(LPAREN); 09007 { 09008 switch ( LA(1)) { 09009 case BOX: 09010 { 09011 RefAdaAST tmp257_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09012 if ( inputState->guessing == 0 ) { 09013 tmp257_AST = astFactory->create(LT(1)); 09014 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp257_AST.get())); 09015 } 09016 match(BOX); 09017 break; 09018 } 09019 case IDENTIFIER: 09020 { 09021 defining_identifier_list(); 09022 if (inputState->guessing==0) { 09023 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09024 } 09025 break; 09026 } 09027 default: 09028 { 09029 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09030 } 09031 } 09032 } 09033 match(RPAREN); 09034 break; 09035 } 09036 case SEMI: 09037 { 09038 break; 09039 } 09040 default: 09041 { 09042 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09043 } 09044 } 09045 } 09046 formal_package_actual_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09047 } 09048 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09049 if( inputState->guessing == 0 ) { 09050 reportError(ex); 09051 consume(); 09052 consumeUntil(_tokenSet_4); 09053 } else { 09054 throw; 09055 } 09056 } 09057 returnAST = formal_package_actual_part_opt_AST; 09058 } 09059 09060 void AdaParser::body_part() { 09061 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09062 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09063 RefAdaAST body_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09064 09065 try { // for error handling 09066 declarative_part(); 09067 if (inputState->guessing==0) { 09068 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09069 } 09070 block_body(); 09071 if (inputState->guessing==0) { 09072 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09073 } 09074 end_id_opt(); 09075 body_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09076 } 09077 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09078 if( inputState->guessing == 0 ) { 09079 reportError(ex); 09080 consume(); 09081 consumeUntil(_tokenSet_4); 09082 } else { 09083 throw; 09084 } 09085 } 09086 returnAST = body_part_AST; 09087 } 09088 09089 void AdaParser::declarative_part() { 09090 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09091 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09092 RefAdaAST declarative_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09093 09094 try { // for error handling 09095 { // ( ... )* 09096 for (;;) { 09097 switch ( LA(1)) { 09098 case PRAGMA: 09099 { 09100 pragma(); 09101 if (inputState->guessing==0) { 09102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09103 } 09104 break; 09105 } 09106 case IDENTIFIER: 09107 case USE: 09108 case TYPE: 09109 case PACKAGE: 09110 case PROCEDURE: 09111 case FUNCTION: 09112 case TASK: 09113 case PROTECTED: 09114 case FOR: 09115 case SUBTYPE: 09116 case GENERIC: 09117 { 09118 declarative_item(); 09119 if (inputState->guessing==0) { 09120 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09121 } 09122 break; 09123 } 09124 default: 09125 { 09126 goto _loop314; 09127 } 09128 } 09129 } 09130 _loop314:; 09131 } // ( ... )* 09132 if ( inputState->guessing==0 ) { 09133 declarative_part_AST = RefAdaAST(currentAST.root); 09134 #line 964 "ada.g" 09135 declarative_part_AST = 09136 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DECLARATIVE_PART,"DECLARATIVE_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(declarative_part_AST.get())))); 09137 #line 9138 "AdaParser.cpp" 09138 currentAST.root = declarative_part_AST; 09139 if ( declarative_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 09140 declarative_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 09141 currentAST.child = declarative_part_AST->getFirstChild(); 09142 else 09143 currentAST.child = declarative_part_AST; 09144 currentAST.advanceChildToEnd(); 09145 } 09146 declarative_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09147 } 09148 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09149 if( inputState->guessing == 0 ) { 09150 reportError(ex); 09151 consume(); 09152 consumeUntil(_tokenSet_83); 09153 } else { 09154 throw; 09155 } 09156 } 09157 returnAST = declarative_part_AST; 09158 } 09159 09160 void AdaParser::block_body() { 09161 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09162 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09163 RefAdaAST block_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09164 ANTLR_USE_NAMESPACE(antlr)RefToken b = ANTLR_USE_NAMESPACE(antlr)nullToken; 09165 RefAdaAST b_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09166 09167 try { // for error handling 09168 b = LT(1); 09169 if ( inputState->guessing == 0 ) { 09170 b_AST = astFactory->create(b); 09171 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(b_AST.get())); 09172 } 09173 match(BEGIN); 09174 handled_stmt_s(); 09175 if (inputState->guessing==0) { 09176 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09177 } 09178 if ( inputState->guessing==0 ) { 09179 #line 1044 "ada.g" 09180 Set(b_AST, BLOCK_BODY); 09181 #line 9182 "AdaParser.cpp" 09182 } 09183 block_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09184 } 09185 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09186 if( inputState->guessing == 0 ) { 09187 reportError(ex); 09188 consume(); 09189 consumeUntil(_tokenSet_21); 09190 } else { 09191 throw; 09192 } 09193 } 09194 returnAST = block_body_AST; 09195 } 09196 09197 void AdaParser::declarative_item() { 09198 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09199 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09200 RefAdaAST declarative_item_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09201 ANTLR_USE_NAMESPACE(antlr)RefToken pkg = ANTLR_USE_NAMESPACE(antlr)nullToken; 09202 RefAdaAST pkg_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09203 ANTLR_USE_NAMESPACE(antlr)RefToken tsk = ANTLR_USE_NAMESPACE(antlr)nullToken; 09204 RefAdaAST tsk_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09205 ANTLR_USE_NAMESPACE(antlr)RefToken pro = ANTLR_USE_NAMESPACE(antlr)nullToken; 09206 RefAdaAST pro_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09207 09208 try { // for error handling 09209 { 09210 switch ( LA(1)) { 09211 case PACKAGE: 09212 { 09213 pkg = LT(1); 09214 if ( inputState->guessing == 0 ) { 09215 pkg_AST = astFactory->create(pkg); 09216 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pkg_AST.get())); 09217 } 09218 match(PACKAGE); 09219 { 09220 switch ( LA(1)) { 09221 case BODY: 09222 { 09223 body_is(); 09224 if (inputState->guessing==0) { 09225 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09226 } 09227 { 09228 switch ( LA(1)) { 09229 case SEPARATE: 09230 { 09231 separate(); 09232 if (inputState->guessing==0) { 09233 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09234 } 09235 if ( inputState->guessing==0 ) { 09236 #line 972 "ada.g" 09237 Set(pkg_AST, PACKAGE_BODY_STUB); 09238 #line 9239 "AdaParser.cpp" 09239 } 09240 break; 09241 } 09242 case PRAGMA: 09243 case IDENTIFIER: 09244 case USE: 09245 case TYPE: 09246 case PACKAGE: 09247 case PROCEDURE: 09248 case FUNCTION: 09249 case TASK: 09250 case PROTECTED: 09251 case FOR: 09252 case END: 09253 case SUBTYPE: 09254 case GENERIC: 09255 case BEGIN: 09256 { 09257 pkg_body_part(); 09258 if (inputState->guessing==0) { 09259 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09260 } 09261 end_id_opt(); 09262 if ( inputState->guessing==0 ) { 09263 #line 974 "ada.g" 09264 Set(pkg_AST, PACKAGE_BODY); 09265 #line 9266 "AdaParser.cpp" 09266 } 09267 break; 09268 } 09269 default: 09270 { 09271 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09272 } 09273 } 09274 } 09275 match(SEMI); 09276 break; 09277 } 09278 case IDENTIFIER: 09279 { 09280 def_id(false); 09281 if (inputState->guessing==0) { 09282 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09283 } 09284 spec_decl_part(pkg_AST); 09285 if (inputState->guessing==0) { 09286 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09287 } 09288 break; 09289 } 09290 default: 09291 { 09292 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09293 } 09294 } 09295 } 09296 break; 09297 } 09298 case TASK: 09299 { 09300 tsk = LT(1); 09301 if ( inputState->guessing == 0 ) { 09302 tsk_AST = astFactory->create(tsk); 09303 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tsk_AST.get())); 09304 } 09305 match(TASK); 09306 { 09307 switch ( LA(1)) { 09308 case BODY: 09309 { 09310 body_is(); 09311 if (inputState->guessing==0) { 09312 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09313 } 09314 { 09315 switch ( LA(1)) { 09316 case SEPARATE: 09317 { 09318 separate(); 09319 if (inputState->guessing==0) { 09320 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09321 } 09322 if ( inputState->guessing==0 ) { 09323 #line 980 "ada.g" 09324 Set(tsk_AST, TASK_BODY_STUB); 09325 #line 9326 "AdaParser.cpp" 09326 } 09327 break; 09328 } 09329 case PRAGMA: 09330 case IDENTIFIER: 09331 case USE: 09332 case TYPE: 09333 case PACKAGE: 09334 case PROCEDURE: 09335 case FUNCTION: 09336 case TASK: 09337 case PROTECTED: 09338 case FOR: 09339 case SUBTYPE: 09340 case GENERIC: 09341 case BEGIN: 09342 { 09343 body_part(); 09344 if (inputState->guessing==0) { 09345 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09346 } 09347 if ( inputState->guessing==0 ) { 09348 #line 981 "ada.g" 09349 Set(tsk_AST, TASK_BODY); 09350 #line 9351 "AdaParser.cpp" 09351 } 09352 break; 09353 } 09354 default: 09355 { 09356 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09357 } 09358 } 09359 } 09360 match(SEMI); 09361 break; 09362 } 09363 case IDENTIFIER: 09364 case TYPE: 09365 { 09366 task_type_or_single_decl(tsk_AST); 09367 if (inputState->guessing==0) { 09368 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09369 } 09370 break; 09371 } 09372 default: 09373 { 09374 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09375 } 09376 } 09377 } 09378 break; 09379 } 09380 case PROTECTED: 09381 { 09382 pro = LT(1); 09383 if ( inputState->guessing == 0 ) { 09384 pro_AST = astFactory->create(pro); 09385 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(pro_AST.get())); 09386 } 09387 match(PROTECTED); 09388 { 09389 switch ( LA(1)) { 09390 case BODY: 09391 { 09392 body_is(); 09393 if (inputState->guessing==0) { 09394 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09395 } 09396 { 09397 switch ( LA(1)) { 09398 case SEPARATE: 09399 { 09400 separate(); 09401 if (inputState->guessing==0) { 09402 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09403 } 09404 if ( inputState->guessing==0 ) { 09405 #line 988 "ada.g" 09406 Set(pro_AST, PROTECTED_BODY_STUB); 09407 #line 9408 "AdaParser.cpp" 09408 } 09409 break; 09410 } 09411 case PRAGMA: 09412 case PROCEDURE: 09413 case FUNCTION: 09414 case ENTRY: 09415 case END: 09416 { 09417 prot_op_bodies_opt(); 09418 if (inputState->guessing==0) { 09419 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09420 } 09421 end_id_opt(); 09422 if ( inputState->guessing==0 ) { 09423 #line 990 "ada.g" 09424 Set(pro_AST, PROTECTED_BODY); 09425 #line 9426 "AdaParser.cpp" 09426 } 09427 break; 09428 } 09429 default: 09430 { 09431 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09432 } 09433 } 09434 } 09435 break; 09436 } 09437 case IDENTIFIER: 09438 case TYPE: 09439 { 09440 prot_type_or_single_decl(pro_AST); 09441 if (inputState->guessing==0) { 09442 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09443 } 09444 break; 09445 } 09446 default: 09447 { 09448 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09449 } 09450 } 09451 } 09452 match(SEMI); 09453 break; 09454 } 09455 case PROCEDURE: 09456 case FUNCTION: 09457 { 09458 subprog_decl_or_rename_or_inst_or_body(false); 09459 if (inputState->guessing==0) { 09460 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09461 } 09462 break; 09463 } 09464 case IDENTIFIER: 09465 case USE: 09466 case TYPE: 09467 case FOR: 09468 case SUBTYPE: 09469 case GENERIC: 09470 { 09471 decl_common(); 09472 if (inputState->guessing==0) { 09473 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09474 } 09475 break; 09476 } 09477 default: 09478 { 09479 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09480 } 09481 } 09482 } 09483 declarative_item_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09484 } 09485 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09486 if( inputState->guessing == 0 ) { 09487 reportError(ex); 09488 consume(); 09489 consumeUntil(_tokenSet_84); 09490 } else { 09491 throw; 09492 } 09493 } 09494 returnAST = declarative_item_AST; 09495 } 09496 09497 void AdaParser::body_is() { 09498 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09499 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09500 RefAdaAST body_is_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09501 09502 try { // for error handling 09503 match(BODY); 09504 def_id(false); 09505 if (inputState->guessing==0) { 09506 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09507 } 09508 match(IS); 09509 body_is_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09510 } 09511 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09512 if( inputState->guessing == 0 ) { 09513 reportError(ex); 09514 consume(); 09515 consumeUntil(_tokenSet_85); 09516 } else { 09517 throw; 09518 } 09519 } 09520 returnAST = body_is_AST; 09521 } 09522 09523 void AdaParser::separate() { 09524 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09525 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09526 RefAdaAST separate_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09527 09528 try { // for error handling 09529 match(SEPARATE); 09530 if ( inputState->guessing==0 ) { 09531 #line 1009 "ada.g" 09532 pop_def_id(); 09533 #line 9534 "AdaParser.cpp" 09534 } 09535 separate_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09536 } 09537 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09538 if( inputState->guessing == 0 ) { 09539 reportError(ex); 09540 consume(); 09541 consumeUntil(_tokenSet_4); 09542 } else { 09543 throw; 09544 } 09545 } 09546 returnAST = separate_AST; 09547 } 09548 09549 void AdaParser::prot_op_bodies_opt() { 09550 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09551 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09552 RefAdaAST prot_op_bodies_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09553 09554 try { // for error handling 09555 { // ( ... )* 09556 for (;;) { 09557 switch ( LA(1)) { 09558 case ENTRY: 09559 { 09560 entry_body(); 09561 if (inputState->guessing==0) { 09562 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09563 } 09564 break; 09565 } 09566 case PROCEDURE: 09567 case FUNCTION: 09568 { 09569 subprog_decl_or_body(); 09570 if (inputState->guessing==0) { 09571 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09572 } 09573 break; 09574 } 09575 case PRAGMA: 09576 { 09577 pragma(); 09578 if (inputState->guessing==0) { 09579 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09580 } 09581 break; 09582 } 09583 default: 09584 { 09585 goto _loop330; 09586 } 09587 } 09588 } 09589 _loop330:; 09590 } // ( ... )* 09591 if ( inputState->guessing==0 ) { 09592 prot_op_bodies_opt_AST = RefAdaAST(currentAST.root); 09593 #line 1025 "ada.g" 09594 prot_op_bodies_opt_AST = 09595 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(PROT_OP_BODIES_OPT,"PROT_OP_BODIES_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(prot_op_bodies_opt_AST.get())))); 09596 #line 9597 "AdaParser.cpp" 09597 currentAST.root = prot_op_bodies_opt_AST; 09598 if ( prot_op_bodies_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 09599 prot_op_bodies_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 09600 currentAST.child = prot_op_bodies_opt_AST->getFirstChild(); 09601 else 09602 currentAST.child = prot_op_bodies_opt_AST; 09603 currentAST.advanceChildToEnd(); 09604 } 09605 prot_op_bodies_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09606 } 09607 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09608 if( inputState->guessing == 0 ) { 09609 reportError(ex); 09610 consume(); 09611 consumeUntil(_tokenSet_21); 09612 } else { 09613 throw; 09614 } 09615 } 09616 returnAST = prot_op_bodies_opt_AST; 09617 } 09618 09619 void AdaParser::block_body_opt() { 09620 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09621 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09622 RefAdaAST block_body_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09623 09624 try { // for error handling 09625 { 09626 switch ( LA(1)) { 09627 case BEGIN: 09628 { 09629 match(BEGIN); 09630 handled_stmt_s(); 09631 if (inputState->guessing==0) { 09632 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09633 } 09634 break; 09635 } 09636 case END: 09637 { 09638 break; 09639 } 09640 default: 09641 { 09642 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09643 } 09644 } 09645 } 09646 if ( inputState->guessing==0 ) { 09647 block_body_opt_AST = RefAdaAST(currentAST.root); 09648 #line 1016 "ada.g" 09649 block_body_opt_AST = 09650 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BLOCK_BODY_OPT,"BLOCK_BODY_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(block_body_opt_AST.get())))); 09651 #line 9652 "AdaParser.cpp" 09652 currentAST.root = block_body_opt_AST; 09653 if ( block_body_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 09654 block_body_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 09655 currentAST.child = block_body_opt_AST->getFirstChild(); 09656 else 09657 currentAST.child = block_body_opt_AST; 09658 currentAST.advanceChildToEnd(); 09659 } 09660 block_body_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09661 } 09662 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09663 if( inputState->guessing == 0 ) { 09664 reportError(ex); 09665 consume(); 09666 consumeUntil(_tokenSet_21); 09667 } else { 09668 throw; 09669 } 09670 } 09671 returnAST = block_body_opt_AST; 09672 } 09673 09674 void AdaParser::handled_stmt_s() { 09675 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09676 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09677 RefAdaAST handled_stmt_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09678 09679 try { // for error handling 09680 statements(); 09681 if (inputState->guessing==0) { 09682 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09683 } 09684 except_handler_part_opt(); 09685 if (inputState->guessing==0) { 09686 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09687 } 09688 if ( inputState->guessing==0 ) { 09689 handled_stmt_s_AST = RefAdaAST(currentAST.root); 09690 #line 1048 "ada.g" 09691 handled_stmt_s_AST = 09692 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(HANDLED_SEQUENCE_OF_STATEMENTS,"HANDLED_SEQUENCE_OF_STATEMENTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(handled_stmt_s_AST.get())))); 09693 #line 9694 "AdaParser.cpp" 09694 currentAST.root = handled_stmt_s_AST; 09695 if ( handled_stmt_s_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 09696 handled_stmt_s_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 09697 currentAST.child = handled_stmt_s_AST->getFirstChild(); 09698 else 09699 currentAST.child = handled_stmt_s_AST; 09700 currentAST.advanceChildToEnd(); 09701 } 09702 handled_stmt_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09703 } 09704 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09705 if( inputState->guessing == 0 ) { 09706 reportError(ex); 09707 consume(); 09708 consumeUntil(_tokenSet_21); 09709 } else { 09710 throw; 09711 } 09712 } 09713 returnAST = handled_stmt_s_AST; 09714 } 09715 09716 void AdaParser::entry_body() { 09717 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09718 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09719 RefAdaAST entry_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09720 ANTLR_USE_NAMESPACE(antlr)RefToken e = ANTLR_USE_NAMESPACE(antlr)nullToken; 09721 RefAdaAST e_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09722 09723 try { // for error handling 09724 e = LT(1); 09725 if ( inputState->guessing == 0 ) { 09726 e_AST = astFactory->create(e); 09727 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(e_AST.get())); 09728 } 09729 match(ENTRY); 09730 def_id(false); 09731 if (inputState->guessing==0) { 09732 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09733 } 09734 entry_body_formal_part(); 09735 if (inputState->guessing==0) { 09736 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09737 } 09738 entry_barrier(); 09739 if (inputState->guessing==0) { 09740 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09741 } 09742 match(IS); 09743 body_part(); 09744 if (inputState->guessing==0) { 09745 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09746 } 09747 match(SEMI); 09748 if ( inputState->guessing==0 ) { 09749 #line 1211 "ada.g" 09750 Set (e_AST, ENTRY_BODY); 09751 #line 9752 "AdaParser.cpp" 09752 } 09753 entry_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09754 } 09755 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09756 if( inputState->guessing == 0 ) { 09757 reportError(ex); 09758 consume(); 09759 consumeUntil(_tokenSet_86); 09760 } else { 09761 throw; 09762 } 09763 } 09764 returnAST = entry_body_AST; 09765 } 09766 09767 void AdaParser::subprog_decl_or_body() { 09768 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09769 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09770 RefAdaAST subprog_decl_or_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09771 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 09772 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09773 ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; 09774 RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09775 09776 try { // for error handling 09777 switch ( LA(1)) { 09778 case PROCEDURE: 09779 { 09780 p = LT(1); 09781 if ( inputState->guessing == 0 ) { 09782 p_AST = astFactory->create(p); 09783 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 09784 } 09785 match(PROCEDURE); 09786 def_id(false); 09787 if (inputState->guessing==0) { 09788 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09789 } 09790 formal_part_opt(); 09791 if (inputState->guessing==0) { 09792 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09793 } 09794 { 09795 switch ( LA(1)) { 09796 case IS: 09797 { 09798 match(IS); 09799 body_part(); 09800 if (inputState->guessing==0) { 09801 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09802 } 09803 if ( inputState->guessing==0 ) { 09804 #line 1032 "ada.g" 09805 Set(p_AST, PROCEDURE_BODY); 09806 #line 9807 "AdaParser.cpp" 09807 } 09808 break; 09809 } 09810 case SEMI: 09811 { 09812 if ( inputState->guessing==0 ) { 09813 #line 1033 "ada.g" 09814 pop_def_id(); Set(p_AST, PROCEDURE_DECLARATION); 09815 #line 9816 "AdaParser.cpp" 09816 } 09817 break; 09818 } 09819 default: 09820 { 09821 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09822 } 09823 } 09824 } 09825 match(SEMI); 09826 subprog_decl_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09827 break; 09828 } 09829 case FUNCTION: 09830 { 09831 f = LT(1); 09832 if ( inputState->guessing == 0 ) { 09833 f_AST = astFactory->create(f); 09834 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get())); 09835 } 09836 match(FUNCTION); 09837 def_designator(false); 09838 if (inputState->guessing==0) { 09839 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09840 } 09841 function_tail(); 09842 if (inputState->guessing==0) { 09843 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09844 } 09845 { 09846 switch ( LA(1)) { 09847 case IS: 09848 { 09849 match(IS); 09850 body_part(); 09851 if (inputState->guessing==0) { 09852 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09853 } 09854 if ( inputState->guessing==0 ) { 09855 #line 1037 "ada.g" 09856 Set(f_AST, FUNCTION_BODY); 09857 #line 9858 "AdaParser.cpp" 09858 } 09859 break; 09860 } 09861 case SEMI: 09862 { 09863 if ( inputState->guessing==0 ) { 09864 #line 1038 "ada.g" 09865 pop_def_id(); Set(f_AST, FUNCTION_DECLARATION); 09866 #line 9867 "AdaParser.cpp" 09867 } 09868 break; 09869 } 09870 default: 09871 { 09872 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09873 } 09874 } 09875 } 09876 match(SEMI); 09877 subprog_decl_or_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09878 break; 09879 } 09880 default: 09881 { 09882 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 09883 } 09884 } 09885 } 09886 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09887 if( inputState->guessing == 0 ) { 09888 reportError(ex); 09889 consume(); 09890 consumeUntil(_tokenSet_86); 09891 } else { 09892 throw; 09893 } 09894 } 09895 returnAST = subprog_decl_or_body_AST; 09896 } 09897 09898 void AdaParser::statements() { 09899 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09900 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09901 RefAdaAST statements_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09902 09903 try { // for error handling 09904 { // ( ... )+ 09905 int _cnt338=0; 09906 for (;;) { 09907 switch ( LA(1)) { 09908 case PRAGMA: 09909 { 09910 pragma(); 09911 if (inputState->guessing==0) { 09912 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09913 } 09914 break; 09915 } 09916 case IDENTIFIER: 09917 case NuLL: 09918 case RETURN: 09919 case FOR: 09920 case CASE: 09921 case BEGIN: 09922 case LT_LT: 09923 case IF: 09924 case LOOP: 09925 case WHILE: 09926 case DECLARE: 09927 case EXIT: 09928 case GOTO: 09929 case ACCEPT: 09930 case DELAY: 09931 case SELECT: 09932 case ABORT: 09933 case RAISE: 09934 case REQUEUE: 09935 { 09936 statement(); 09937 if (inputState->guessing==0) { 09938 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09939 } 09940 break; 09941 } 09942 default: 09943 { 09944 if ( _cnt338>=1 ) { goto _loop338; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} 09945 } 09946 } 09947 _cnt338++; 09948 } 09949 _loop338:; 09950 } // ( ... )+ 09951 if ( inputState->guessing==0 ) { 09952 statements_AST = RefAdaAST(currentAST.root); 09953 #line 1054 "ada.g" 09954 statements_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(SEQUENCE_OF_STATEMENTS,"SEQUENCE_OF_STATEMENTS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(statements_AST.get())))); 09955 #line 9956 "AdaParser.cpp" 09956 currentAST.root = statements_AST; 09957 if ( statements_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 09958 statements_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 09959 currentAST.child = statements_AST->getFirstChild(); 09960 else 09961 currentAST.child = statements_AST; 09962 currentAST.advanceChildToEnd(); 09963 } 09964 statements_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 09965 } 09966 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 09967 if( inputState->guessing == 0 ) { 09968 reportError(ex); 09969 consume(); 09970 consumeUntil(_tokenSet_87); 09971 } else { 09972 throw; 09973 } 09974 } 09975 returnAST = statements_AST; 09976 } 09977 09978 void AdaParser::except_handler_part_opt() { 09979 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09980 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 09981 RefAdaAST except_handler_part_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 09982 09983 try { // for error handling 09984 { 09985 switch ( LA(1)) { 09986 case EXCEPTION: 09987 { 09988 match(EXCEPTION); 09989 { // ( ... )+ 09990 int _cnt424=0; 09991 for (;;) { 09992 if ((LA(1) == WHEN)) { 09993 exception_handler(); 09994 if (inputState->guessing==0) { 09995 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 09996 } 09997 } 09998 else { 09999 if ( _cnt424>=1 ) { goto _loop424; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} 10000 } 10001 10002 _cnt424++; 10003 } 10004 _loop424:; 10005 } // ( ... )+ 10006 break; 10007 } 10008 case END: 10009 { 10010 break; 10011 } 10012 default: 10013 { 10014 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10015 } 10016 } 10017 } 10018 if ( inputState->guessing==0 ) { 10019 except_handler_part_opt_AST = RefAdaAST(currentAST.root); 10020 #line 1340 "ada.g" 10021 except_handler_part_opt_AST = 10022 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(EXCEPT_HANDLER_PART_OPT,"EXCEPT_HANDLER_PART_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(except_handler_part_opt_AST.get())))); 10023 #line 10024 "AdaParser.cpp" 10024 currentAST.root = except_handler_part_opt_AST; 10025 if ( except_handler_part_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 10026 except_handler_part_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 10027 currentAST.child = except_handler_part_opt_AST->getFirstChild(); 10028 else 10029 currentAST.child = except_handler_part_opt_AST; 10030 currentAST.advanceChildToEnd(); 10031 } 10032 except_handler_part_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10033 } 10034 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10035 if( inputState->guessing == 0 ) { 10036 reportError(ex); 10037 consume(); 10038 consumeUntil(_tokenSet_21); 10039 } else { 10040 throw; 10041 } 10042 } 10043 returnAST = except_handler_part_opt_AST; 10044 } 10045 10046 void AdaParser::statement() { 10047 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10048 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10049 RefAdaAST statement_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10050 10051 try { // for error handling 10052 def_label_opt(); 10053 if (inputState->guessing==0) { 10054 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10055 } 10056 { 10057 switch ( LA(1)) { 10058 case NuLL: 10059 { 10060 null_stmt(); 10061 if (inputState->guessing==0) { 10062 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10063 } 10064 break; 10065 } 10066 case EXIT: 10067 { 10068 exit_stmt(); 10069 if (inputState->guessing==0) { 10070 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10071 } 10072 break; 10073 } 10074 case RETURN: 10075 { 10076 return_stmt(); 10077 if (inputState->guessing==0) { 10078 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10079 } 10080 break; 10081 } 10082 case GOTO: 10083 { 10084 goto_stmt(); 10085 if (inputState->guessing==0) { 10086 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10087 } 10088 break; 10089 } 10090 case DELAY: 10091 { 10092 delay_stmt(); 10093 if (inputState->guessing==0) { 10094 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10095 } 10096 break; 10097 } 10098 case ABORT: 10099 { 10100 abort_stmt(); 10101 if (inputState->guessing==0) { 10102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10103 } 10104 break; 10105 } 10106 case RAISE: 10107 { 10108 raise_stmt(); 10109 if (inputState->guessing==0) { 10110 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10111 } 10112 break; 10113 } 10114 case REQUEUE: 10115 { 10116 requeue_stmt(); 10117 if (inputState->guessing==0) { 10118 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10119 } 10120 break; 10121 } 10122 case ACCEPT: 10123 { 10124 accept_stmt(); 10125 if (inputState->guessing==0) { 10126 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10127 } 10128 break; 10129 } 10130 case SELECT: 10131 { 10132 select_stmt(); 10133 if (inputState->guessing==0) { 10134 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10135 } 10136 break; 10137 } 10138 case IF: 10139 { 10140 if_stmt(); 10141 if (inputState->guessing==0) { 10142 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10143 } 10144 break; 10145 } 10146 case CASE: 10147 { 10148 case_stmt(); 10149 if (inputState->guessing==0) { 10150 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10151 } 10152 break; 10153 } 10154 case FOR: 10155 case LOOP: 10156 case WHILE: 10157 { 10158 loop_stmt(); 10159 if (inputState->guessing==0) { 10160 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10161 } 10162 match(SEMI); 10163 break; 10164 } 10165 case BEGIN: 10166 case DECLARE: 10167 { 10168 block(); 10169 if (inputState->guessing==0) { 10170 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10171 } 10172 match(END); 10173 match(SEMI); 10174 break; 10175 } 10176 default: 10177 if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) { 10178 statement_identifier(); 10179 if (inputState->guessing==0) { 10180 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10181 } 10182 { 10183 switch ( LA(1)) { 10184 case FOR: 10185 case LOOP: 10186 case WHILE: 10187 { 10188 loop_stmt(); 10189 if (inputState->guessing==0) { 10190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10191 } 10192 id_opt(); 10193 match(SEMI); 10194 break; 10195 } 10196 case BEGIN: 10197 case DECLARE: 10198 { 10199 block(); 10200 if (inputState->guessing==0) { 10201 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10202 } 10203 end_id_opt(); 10204 match(SEMI); 10205 break; 10206 } 10207 default: 10208 { 10209 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10210 } 10211 } 10212 } 10213 } 10214 else if ((LA(1) == IDENTIFIER) && (_tokenSet_88.member(LA(2)))) { 10215 call_or_assignment(); 10216 if (inputState->guessing==0) { 10217 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10218 } 10219 } 10220 else { 10221 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10222 } 10223 } 10224 } 10225 if ( inputState->guessing==0 ) { 10226 statement_AST = RefAdaAST(currentAST.root); 10227 #line 1080 "ada.g" 10228 statement_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(STATEMENT,"STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(statement_AST.get())))); 10229 #line 10230 "AdaParser.cpp" 10230 currentAST.root = statement_AST; 10231 if ( statement_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 10232 statement_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 10233 currentAST.child = statement_AST->getFirstChild(); 10234 else 10235 currentAST.child = statement_AST; 10236 currentAST.advanceChildToEnd(); 10237 } 10238 statement_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10239 } 10240 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10241 if( inputState->guessing == 0 ) { 10242 reportError(ex); 10243 consume(); 10244 consumeUntil(_tokenSet_89); 10245 } else { 10246 throw; 10247 } 10248 } 10249 returnAST = statement_AST; 10250 } 10251 10252 void AdaParser::def_label_opt() { 10253 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10254 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10255 RefAdaAST def_label_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10256 10257 try { // for error handling 10258 { 10259 switch ( LA(1)) { 10260 case LT_LT: 10261 { 10262 match(LT_LT); 10263 RefAdaAST tmp279_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10264 if ( inputState->guessing == 0 ) { 10265 tmp279_AST = astFactory->create(LT(1)); 10266 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp279_AST.get())); 10267 } 10268 match(IDENTIFIER); 10269 match(GT_GT); 10270 break; 10271 } 10272 case IDENTIFIER: 10273 case NuLL: 10274 case RETURN: 10275 case FOR: 10276 case CASE: 10277 case BEGIN: 10278 case IF: 10279 case LOOP: 10280 case WHILE: 10281 case DECLARE: 10282 case EXIT: 10283 case GOTO: 10284 case ACCEPT: 10285 case DELAY: 10286 case SELECT: 10287 case ABORT: 10288 case RAISE: 10289 case REQUEUE: 10290 { 10291 break; 10292 } 10293 default: 10294 { 10295 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10296 } 10297 } 10298 } 10299 if ( inputState->guessing==0 ) { 10300 def_label_opt_AST = RefAdaAST(currentAST.root); 10301 #line 1084 "ada.g" 10302 def_label_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LABEL_OPT,"LABEL_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(def_label_opt_AST.get())))); 10303 #line 10304 "AdaParser.cpp" 10304 currentAST.root = def_label_opt_AST; 10305 if ( def_label_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 10306 def_label_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 10307 currentAST.child = def_label_opt_AST->getFirstChild(); 10308 else 10309 currentAST.child = def_label_opt_AST; 10310 currentAST.advanceChildToEnd(); 10311 } 10312 def_label_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10313 } 10314 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10315 if( inputState->guessing == 0 ) { 10316 reportError(ex); 10317 consume(); 10318 consumeUntil(_tokenSet_90); 10319 } else { 10320 throw; 10321 } 10322 } 10323 returnAST = def_label_opt_AST; 10324 } 10325 10326 void AdaParser::null_stmt() { 10327 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10328 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10329 RefAdaAST null_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10330 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 10331 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10332 10333 try { // for error handling 10334 s = LT(1); 10335 if ( inputState->guessing == 0 ) { 10336 s_AST = astFactory->create(s); 10337 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 10338 } 10339 match(NuLL); 10340 match(SEMI); 10341 if ( inputState->guessing==0 ) { 10342 #line 1088 "ada.g" 10343 Set(s_AST, NULL_STATEMENT); 10344 #line 10345 "AdaParser.cpp" 10345 } 10346 null_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10347 } 10348 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10349 if( inputState->guessing == 0 ) { 10350 reportError(ex); 10351 consume(); 10352 consumeUntil(_tokenSet_89); 10353 } else { 10354 throw; 10355 } 10356 } 10357 returnAST = null_stmt_AST; 10358 } 10359 10360 void AdaParser::exit_stmt() { 10361 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10362 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10363 RefAdaAST exit_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10364 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 10365 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10366 10367 try { // for error handling 10368 s = LT(1); 10369 if ( inputState->guessing == 0 ) { 10370 s_AST = astFactory->create(s); 10371 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 10372 } 10373 match(EXIT); 10374 { 10375 switch ( LA(1)) { 10376 case IDENTIFIER: 10377 { 10378 label_name(); 10379 if (inputState->guessing==0) { 10380 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10381 } 10382 break; 10383 } 10384 case SEMI: 10385 case WHEN: 10386 { 10387 break; 10388 } 10389 default: 10390 { 10391 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10392 } 10393 } 10394 } 10395 { 10396 switch ( LA(1)) { 10397 case WHEN: 10398 { 10399 RefAdaAST tmp282_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10400 if ( inputState->guessing == 0 ) { 10401 tmp282_AST = astFactory->create(LT(1)); 10402 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp282_AST.get())); 10403 } 10404 match(WHEN); 10405 condition(); 10406 if (inputState->guessing==0) { 10407 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10408 } 10409 break; 10410 } 10411 case SEMI: 10412 { 10413 break; 10414 } 10415 default: 10416 { 10417 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10418 } 10419 } 10420 } 10421 match(SEMI); 10422 if ( inputState->guessing==0 ) { 10423 #line 1181 "ada.g" 10424 Set(s_AST, EXIT_STATEMENT); 10425 #line 10426 "AdaParser.cpp" 10426 } 10427 exit_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10428 } 10429 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10430 if( inputState->guessing == 0 ) { 10431 reportError(ex); 10432 consume(); 10433 consumeUntil(_tokenSet_89); 10434 } else { 10435 throw; 10436 } 10437 } 10438 returnAST = exit_stmt_AST; 10439 } 10440 10441 void AdaParser::return_stmt() { 10442 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10443 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10444 RefAdaAST return_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10445 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 10446 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10447 10448 try { // for error handling 10449 s = LT(1); 10450 if ( inputState->guessing == 0 ) { 10451 s_AST = astFactory->create(s); 10452 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 10453 } 10454 match(RETURN); 10455 { 10456 switch ( LA(1)) { 10457 case IDENTIFIER: 10458 case LPAREN: 10459 case NEW: 10460 case CHARACTER_LITERAL: 10461 case CHAR_STRING: 10462 case NuLL: 10463 case NOT: 10464 case PLUS: 10465 case MINUS: 10466 case ABS: 10467 case NUMERIC_LIT: 10468 { 10469 expression(); 10470 if (inputState->guessing==0) { 10471 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10472 } 10473 break; 10474 } 10475 case SEMI: 10476 { 10477 break; 10478 } 10479 default: 10480 { 10481 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10482 } 10483 } 10484 } 10485 match(SEMI); 10486 if ( inputState->guessing==0 ) { 10487 #line 1188 "ada.g" 10488 Set(s_AST, RETURN_STATEMENT); 10489 #line 10490 "AdaParser.cpp" 10490 } 10491 return_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10492 } 10493 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10494 if( inputState->guessing == 0 ) { 10495 reportError(ex); 10496 consume(); 10497 consumeUntil(_tokenSet_89); 10498 } else { 10499 throw; 10500 } 10501 } 10502 returnAST = return_stmt_AST; 10503 } 10504 10505 void AdaParser::goto_stmt() { 10506 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10507 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10508 RefAdaAST goto_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10509 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 10510 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10511 10512 try { // for error handling 10513 s = LT(1); 10514 if ( inputState->guessing == 0 ) { 10515 s_AST = astFactory->create(s); 10516 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 10517 } 10518 match(GOTO); 10519 label_name(); 10520 if (inputState->guessing==0) { 10521 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10522 } 10523 match(SEMI); 10524 if ( inputState->guessing==0 ) { 10525 #line 1192 "ada.g" 10526 Set(s_AST, GOTO_STATEMENT); 10527 #line 10528 "AdaParser.cpp" 10528 } 10529 goto_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10530 } 10531 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10532 if( inputState->guessing == 0 ) { 10533 reportError(ex); 10534 consume(); 10535 consumeUntil(_tokenSet_89); 10536 } else { 10537 throw; 10538 } 10539 } 10540 returnAST = goto_stmt_AST; 10541 } 10542 10543 void AdaParser::delay_stmt() { 10544 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10545 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10546 RefAdaAST delay_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10547 ANTLR_USE_NAMESPACE(antlr)RefToken d = ANTLR_USE_NAMESPACE(antlr)nullToken; 10548 RefAdaAST d_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10549 10550 try { // for error handling 10551 d = LT(1); 10552 if ( inputState->guessing == 0 ) { 10553 d_AST = astFactory->create(d); 10554 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(d_AST.get())); 10555 } 10556 match(DELAY); 10557 until_opt(); 10558 if (inputState->guessing==0) { 10559 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10560 } 10561 expression(); 10562 if (inputState->guessing==0) { 10563 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10564 } 10565 match(SEMI); 10566 if ( inputState->guessing==0 ) { 10567 #line 1257 "ada.g" 10568 Set (d_AST, DELAY_STATEMENT); 10569 #line 10570 "AdaParser.cpp" 10570 } 10571 delay_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10572 } 10573 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10574 if( inputState->guessing == 0 ) { 10575 reportError(ex); 10576 consume(); 10577 consumeUntil(_tokenSet_89); 10578 } else { 10579 throw; 10580 } 10581 } 10582 returnAST = delay_stmt_AST; 10583 } 10584 10585 void AdaParser::abort_stmt() { 10586 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10587 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10588 RefAdaAST abort_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10589 ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; 10590 RefAdaAST a_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10591 10592 try { // for error handling 10593 a = LT(1); 10594 if ( inputState->guessing == 0 ) { 10595 a_AST = astFactory->create(a); 10596 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get())); 10597 } 10598 match(ABORT); 10599 name(); 10600 if (inputState->guessing==0) { 10601 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10602 } 10603 { // ( ... )* 10604 for (;;) { 10605 if ((LA(1) == COMMA)) { 10606 match(COMMA); 10607 name(); 10608 if (inputState->guessing==0) { 10609 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10610 } 10611 } 10612 else { 10613 goto _loop420; 10614 } 10615 10616 } 10617 _loop420:; 10618 } // ( ... )* 10619 match(SEMI); 10620 if ( inputState->guessing==0 ) { 10621 #line 1336 "ada.g" 10622 Set (a_AST, ABORT_STATEMENT); 10623 #line 10624 "AdaParser.cpp" 10624 } 10625 abort_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10626 } 10627 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10628 if( inputState->guessing == 0 ) { 10629 reportError(ex); 10630 consume(); 10631 consumeUntil(_tokenSet_89); 10632 } else { 10633 throw; 10634 } 10635 } 10636 returnAST = abort_stmt_AST; 10637 } 10638 10639 void AdaParser::raise_stmt() { 10640 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10641 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10642 RefAdaAST raise_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10643 ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; 10644 RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10645 10646 try { // for error handling 10647 r = LT(1); 10648 if ( inputState->guessing == 0 ) { 10649 r_AST = astFactory->create(r); 10650 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get())); 10651 } 10652 match(RAISE); 10653 { 10654 switch ( LA(1)) { 10655 case IDENTIFIER: 10656 { 10657 compound_name(); 10658 if (inputState->guessing==0) { 10659 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10660 } 10661 break; 10662 } 10663 case SEMI: 10664 { 10665 break; 10666 } 10667 default: 10668 { 10669 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10670 } 10671 } 10672 } 10673 match(SEMI); 10674 if ( inputState->guessing==0 ) { 10675 #line 1364 "ada.g" 10676 Set (r_AST, RAISE_STATEMENT); 10677 #line 10678 "AdaParser.cpp" 10678 } 10679 raise_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10680 } 10681 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10682 if( inputState->guessing == 0 ) { 10683 reportError(ex); 10684 consume(); 10685 consumeUntil(_tokenSet_89); 10686 } else { 10687 throw; 10688 } 10689 } 10690 returnAST = raise_stmt_AST; 10691 } 10692 10693 void AdaParser::requeue_stmt() { 10694 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10695 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10696 RefAdaAST requeue_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10697 ANTLR_USE_NAMESPACE(antlr)RefToken r = ANTLR_USE_NAMESPACE(antlr)nullToken; 10698 RefAdaAST r_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10699 10700 try { // for error handling 10701 r = LT(1); 10702 if ( inputState->guessing == 0 ) { 10703 r_AST = astFactory->create(r); 10704 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(r_AST.get())); 10705 } 10706 match(REQUEUE); 10707 name(); 10708 if (inputState->guessing==0) { 10709 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10710 } 10711 { 10712 switch ( LA(1)) { 10713 case WITH: 10714 { 10715 match(WITH); 10716 RefAdaAST tmp291_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10717 if ( inputState->guessing == 0 ) { 10718 tmp291_AST = astFactory->create(LT(1)); 10719 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp291_AST.get())); 10720 } 10721 match(ABORT); 10722 break; 10723 } 10724 case SEMI: 10725 { 10726 break; 10727 } 10728 default: 10729 { 10730 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10731 } 10732 } 10733 } 10734 match(SEMI); 10735 if ( inputState->guessing==0 ) { 10736 #line 1368 "ada.g" 10737 Set (r_AST, REQUEUE_STATEMENT); 10738 #line 10739 "AdaParser.cpp" 10739 } 10740 requeue_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10741 } 10742 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10743 if( inputState->guessing == 0 ) { 10744 reportError(ex); 10745 consume(); 10746 consumeUntil(_tokenSet_89); 10747 } else { 10748 throw; 10749 } 10750 } 10751 returnAST = requeue_stmt_AST; 10752 } 10753 10754 void AdaParser::accept_stmt() { 10755 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10756 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10757 RefAdaAST accept_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10758 ANTLR_USE_NAMESPACE(antlr)RefToken a = ANTLR_USE_NAMESPACE(antlr)nullToken; 10759 RefAdaAST a_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10760 10761 try { // for error handling 10762 a = LT(1); 10763 if ( inputState->guessing == 0 ) { 10764 a_AST = astFactory->create(a); 10765 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(a_AST.get())); 10766 } 10767 match(ACCEPT); 10768 def_id(false); 10769 if (inputState->guessing==0) { 10770 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10771 } 10772 entry_index_opt(); 10773 if (inputState->guessing==0) { 10774 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10775 } 10776 formal_part_opt(); 10777 if (inputState->guessing==0) { 10778 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10779 } 10780 { 10781 switch ( LA(1)) { 10782 case DO: 10783 { 10784 match(DO); 10785 handled_stmt_s(); 10786 if (inputState->guessing==0) { 10787 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10788 } 10789 end_id_opt(); 10790 match(SEMI); 10791 break; 10792 } 10793 case SEMI: 10794 { 10795 match(SEMI); 10796 if ( inputState->guessing==0 ) { 10797 #line 1239 "ada.g" 10798 pop_def_id(); 10799 #line 10800 "AdaParser.cpp" 10800 } 10801 break; 10802 } 10803 default: 10804 { 10805 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10806 } 10807 } 10808 } 10809 if ( inputState->guessing==0 ) { 10810 #line 1241 "ada.g" 10811 Set (a_AST, ACCEPT_STATEMENT); 10812 #line 10813 "AdaParser.cpp" 10813 } 10814 accept_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10815 } 10816 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10817 if( inputState->guessing == 0 ) { 10818 reportError(ex); 10819 consume(); 10820 consumeUntil(_tokenSet_89); 10821 } else { 10822 throw; 10823 } 10824 } 10825 returnAST = accept_stmt_AST; 10826 } 10827 10828 void AdaParser::select_stmt() { 10829 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10830 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10831 RefAdaAST select_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10832 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 10833 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10834 10835 try { // for error handling 10836 s = LT(1); 10837 if ( inputState->guessing == 0 ) { 10838 s_AST = astFactory->create(s); 10839 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 10840 } 10841 match(SELECT); 10842 { 10843 bool synPredMatched398 = false; 10844 if (((LA(1) == IDENTIFIER || LA(1) == DELAY) && (_tokenSet_91.member(LA(2))))) { 10845 int _m398 = mark(); 10846 synPredMatched398 = true; 10847 inputState->guessing++; 10848 try { 10849 { 10850 triggering_alternative(); 10851 match(THEN); 10852 match(ABORT); 10853 } 10854 } 10855 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 10856 synPredMatched398 = false; 10857 } 10858 rewind(_m398); 10859 inputState->guessing--; 10860 } 10861 if ( synPredMatched398 ) { 10862 triggering_alternative(); 10863 if (inputState->guessing==0) { 10864 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10865 } 10866 match(THEN); 10867 match(ABORT); 10868 abortable_part(); 10869 if (inputState->guessing==0) { 10870 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10871 } 10872 if ( inputState->guessing==0 ) { 10873 #line 1272 "ada.g" 10874 Set (s_AST, ASYNCHRONOUS_SELECT); 10875 #line 10876 "AdaParser.cpp" 10876 } 10877 } 10878 else if ((_tokenSet_92.member(LA(1))) && (_tokenSet_93.member(LA(2)))) { 10879 selective_accept(); 10880 if (inputState->guessing==0) { 10881 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10882 } 10883 if ( inputState->guessing==0 ) { 10884 #line 1274 "ada.g" 10885 Set (s_AST, SELECTIVE_ACCEPT); 10886 #line 10887 "AdaParser.cpp" 10887 } 10888 } 10889 else if ((LA(1) == IDENTIFIER) && (_tokenSet_94.member(LA(2)))) { 10890 entry_call_alternative(); 10891 if (inputState->guessing==0) { 10892 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10893 } 10894 { 10895 switch ( LA(1)) { 10896 case OR: 10897 { 10898 match(OR); 10899 delay_alternative(); 10900 if (inputState->guessing==0) { 10901 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10902 } 10903 if ( inputState->guessing==0 ) { 10904 #line 1276 "ada.g" 10905 Set (s_AST, TIMED_ENTRY_CALL); 10906 #line 10907 "AdaParser.cpp" 10907 } 10908 break; 10909 } 10910 case ELSE: 10911 { 10912 match(ELSE); 10913 statements(); 10914 if (inputState->guessing==0) { 10915 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10916 } 10917 if ( inputState->guessing==0 ) { 10918 #line 1277 "ada.g" 10919 Set (s_AST, CONDITIONAL_ENTRY_CALL); 10920 #line 10921 "AdaParser.cpp" 10921 } 10922 break; 10923 } 10924 default: 10925 { 10926 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10927 } 10928 } 10929 } 10930 } 10931 else { 10932 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 10933 } 10934 10935 } 10936 match(END); 10937 match(SELECT); 10938 match(SEMI); 10939 select_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10940 } 10941 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10942 if( inputState->guessing == 0 ) { 10943 reportError(ex); 10944 consume(); 10945 consumeUntil(_tokenSet_89); 10946 } else { 10947 throw; 10948 } 10949 } 10950 returnAST = select_stmt_AST; 10951 } 10952 10953 void AdaParser::if_stmt() { 10954 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10955 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 10956 RefAdaAST if_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10957 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 10958 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 10959 10960 try { // for error handling 10961 s = LT(1); 10962 if ( inputState->guessing == 0 ) { 10963 s_AST = astFactory->create(s); 10964 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 10965 } 10966 match(IF); 10967 cond_clause(); 10968 if (inputState->guessing==0) { 10969 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10970 } 10971 elsifs_opt(); 10972 if (inputState->guessing==0) { 10973 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10974 } 10975 else_opt(); 10976 if (inputState->guessing==0) { 10977 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 10978 } 10979 match(END); 10980 match(IF); 10981 match(SEMI); 10982 if ( inputState->guessing==0 ) { 10983 #line 1094 "ada.g" 10984 Set(s_AST, IF_STATEMENT); 10985 #line 10986 "AdaParser.cpp" 10986 } 10987 if_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 10988 } 10989 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 10990 if( inputState->guessing == 0 ) { 10991 reportError(ex); 10992 consume(); 10993 consumeUntil(_tokenSet_89); 10994 } else { 10995 throw; 10996 } 10997 } 10998 returnAST = if_stmt_AST; 10999 } 11000 11001 void AdaParser::case_stmt() { 11002 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11003 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11004 RefAdaAST case_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11005 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 11006 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11007 11008 try { // for error handling 11009 s = LT(1); 11010 if ( inputState->guessing == 0 ) { 11011 s_AST = astFactory->create(s); 11012 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 11013 } 11014 match(CASE); 11015 expression(); 11016 if (inputState->guessing==0) { 11017 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11018 } 11019 match(IS); 11020 alternative_s(); 11021 if (inputState->guessing==0) { 11022 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11023 } 11024 match(END); 11025 match(CASE); 11026 match(SEMI); 11027 if ( inputState->guessing==0 ) { 11028 #line 1114 "ada.g" 11029 Set(s_AST, CASE_STATEMENT); 11030 #line 11031 "AdaParser.cpp" 11031 } 11032 case_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11033 } 11034 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11035 if( inputState->guessing == 0 ) { 11036 reportError(ex); 11037 consume(); 11038 consumeUntil(_tokenSet_89); 11039 } else { 11040 throw; 11041 } 11042 } 11043 returnAST = case_stmt_AST; 11044 } 11045 11046 void AdaParser::loop_stmt() { 11047 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11048 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11049 RefAdaAST loop_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11050 11051 try { // for error handling 11052 iteration_scheme_opt(); 11053 if (inputState->guessing==0) { 11054 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11055 } 11056 match(LOOP); 11057 statements(); 11058 if (inputState->guessing==0) { 11059 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11060 } 11061 match(END); 11062 match(LOOP); 11063 if ( inputState->guessing==0 ) { 11064 loop_stmt_AST = RefAdaAST(currentAST.root); 11065 #line 1126 "ada.g" 11066 loop_stmt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(LOOP_STATEMENT,"LOOP_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(loop_stmt_AST.get())))); 11067 #line 11068 "AdaParser.cpp" 11068 currentAST.root = loop_stmt_AST; 11069 if ( loop_stmt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11070 loop_stmt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11071 currentAST.child = loop_stmt_AST->getFirstChild(); 11072 else 11073 currentAST.child = loop_stmt_AST; 11074 currentAST.advanceChildToEnd(); 11075 } 11076 loop_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11077 } 11078 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11079 if( inputState->guessing == 0 ) { 11080 reportError(ex); 11081 consume(); 11082 consumeUntil(_tokenSet_95); 11083 } else { 11084 throw; 11085 } 11086 } 11087 returnAST = loop_stmt_AST; 11088 } 11089 11090 void AdaParser::block() { 11091 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11092 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11093 RefAdaAST block_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11094 11095 try { // for error handling 11096 declare_opt(); 11097 if (inputState->guessing==0) { 11098 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11099 } 11100 block_body(); 11101 if (inputState->guessing==0) { 11102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11103 } 11104 if ( inputState->guessing==0 ) { 11105 block_AST = RefAdaAST(currentAST.root); 11106 #line 1173 "ada.g" 11107 block_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(BLOCK_STATEMENT,"BLOCK_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(block_AST.get())))); 11108 #line 11109 "AdaParser.cpp" 11109 currentAST.root = block_AST; 11110 if ( block_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11111 block_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11112 currentAST.child = block_AST->getFirstChild(); 11113 else 11114 currentAST.child = block_AST; 11115 currentAST.advanceChildToEnd(); 11116 } 11117 block_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11118 } 11119 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11120 if( inputState->guessing == 0 ) { 11121 reportError(ex); 11122 consume(); 11123 consumeUntil(_tokenSet_21); 11124 } else { 11125 throw; 11126 } 11127 } 11128 returnAST = block_AST; 11129 } 11130 11131 void AdaParser::statement_identifier() { 11132 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11133 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11134 RefAdaAST statement_identifier_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11135 ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; 11136 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11137 11138 try { // for error handling 11139 n = LT(1); 11140 if ( inputState->guessing == 0 ) { 11141 n_AST = astFactory->create(n); 11142 } 11143 match(IDENTIFIER); 11144 match(COLON); 11145 if ( inputState->guessing==0 ) { 11146 #line 1161 "ada.g" 11147 push_def_id(n_AST); 11148 #line 11149 "AdaParser.cpp" 11149 } 11150 } 11151 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11152 if( inputState->guessing == 0 ) { 11153 reportError(ex); 11154 consume(); 11155 consumeUntil(_tokenSet_96); 11156 } else { 11157 throw; 11158 } 11159 } 11160 returnAST = statement_identifier_AST; 11161 } 11162 11163 void AdaParser::id_opt() { 11164 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11165 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11166 RefAdaAST id_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11167 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11168 #line 1141 "ada.g" 11169 RefAdaAST endid; 11170 #line 11171 "AdaParser.cpp" 11171 11172 try { // for error handling 11173 switch ( LA(1)) { 11174 case CHAR_STRING: 11175 { 11176 endid=definable_operator_symbol(); 11177 if (inputState->guessing==0) { 11178 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11179 } 11180 if (!( end_id_matches_def_id (endid) )) 11181 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (endid) "); 11182 id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11183 break; 11184 } 11185 case IDENTIFIER: 11186 { 11187 compound_name(); 11188 if (inputState->guessing==0) { 11189 n_AST = returnAST; 11190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11191 } 11192 if (!( end_id_matches_def_id (n_AST) )) 11193 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" end_id_matches_def_id (n_AST) "); 11194 id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11195 break; 11196 } 11197 case SEMI: 11198 { 11199 if ( inputState->guessing==0 ) { 11200 #line 1148 "ada.g" 11201 pop_def_id(); 11202 #line 11203 "AdaParser.cpp" 11203 } 11204 id_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11205 break; 11206 } 11207 default: 11208 { 11209 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11210 } 11211 } 11212 } 11213 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11214 if( inputState->guessing == 0 ) { 11215 reportError(ex); 11216 consume(); 11217 consumeUntil(_tokenSet_4); 11218 } else { 11219 throw; 11220 } 11221 } 11222 returnAST = id_opt_AST; 11223 } 11224 11225 void AdaParser::call_or_assignment() { 11226 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11227 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11228 RefAdaAST call_or_assignment_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11229 11230 try { // for error handling 11231 name(); 11232 if (inputState->guessing==0) { 11233 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11234 } 11235 { 11236 switch ( LA(1)) { 11237 case ASSIGN: 11238 { 11239 match(ASSIGN); 11240 expression(); 11241 if (inputState->guessing==0) { 11242 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11243 } 11244 if ( inputState->guessing==0 ) { 11245 call_or_assignment_AST = RefAdaAST(currentAST.root); 11246 #line 1197 "ada.g" 11247 call_or_assignment_AST = 11248 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ASSIGNMENT_STATEMENT,"ASSIGNMENT_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(call_or_assignment_AST.get())))); 11249 #line 11250 "AdaParser.cpp" 11250 currentAST.root = call_or_assignment_AST; 11251 if ( call_or_assignment_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11252 call_or_assignment_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11253 currentAST.child = call_or_assignment_AST->getFirstChild(); 11254 else 11255 currentAST.child = call_or_assignment_AST; 11256 currentAST.advanceChildToEnd(); 11257 } 11258 break; 11259 } 11260 case SEMI: 11261 { 11262 if ( inputState->guessing==0 ) { 11263 call_or_assignment_AST = RefAdaAST(currentAST.root); 11264 #line 1200 "ada.g" 11265 call_or_assignment_AST = 11266 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CALL_STATEMENT,"CALL_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(call_or_assignment_AST.get())))); 11267 #line 11268 "AdaParser.cpp" 11268 currentAST.root = call_or_assignment_AST; 11269 if ( call_or_assignment_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11270 call_or_assignment_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11271 currentAST.child = call_or_assignment_AST->getFirstChild(); 11272 else 11273 currentAST.child = call_or_assignment_AST; 11274 currentAST.advanceChildToEnd(); 11275 } 11276 break; 11277 } 11278 default: 11279 { 11280 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11281 } 11282 } 11283 } 11284 match(SEMI); 11285 call_or_assignment_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11286 } 11287 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11288 if( inputState->guessing == 0 ) { 11289 reportError(ex); 11290 consume(); 11291 consumeUntil(_tokenSet_89); 11292 } else { 11293 throw; 11294 } 11295 } 11296 returnAST = call_or_assignment_AST; 11297 } 11298 11299 void AdaParser::cond_clause() { 11300 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11301 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11302 RefAdaAST cond_clause_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11303 ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken; 11304 RefAdaAST c_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11305 11306 try { // for error handling 11307 condition(); 11308 if (inputState->guessing==0) { 11309 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11310 } 11311 c = LT(1); 11312 if ( inputState->guessing == 0 ) { 11313 c_AST = astFactory->create(c); 11314 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get())); 11315 } 11316 match(THEN); 11317 statements(); 11318 if (inputState->guessing==0) { 11319 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11320 } 11321 if ( inputState->guessing==0 ) { 11322 #line 1098 "ada.g" 11323 Set(c_AST, COND_CLAUSE); 11324 #line 11325 "AdaParser.cpp" 11325 } 11326 cond_clause_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11327 } 11328 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11329 if( inputState->guessing == 0 ) { 11330 reportError(ex); 11331 consume(); 11332 consumeUntil(_tokenSet_97); 11333 } else { 11334 throw; 11335 } 11336 } 11337 returnAST = cond_clause_AST; 11338 } 11339 11340 void AdaParser::elsifs_opt() { 11341 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11342 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11343 RefAdaAST elsifs_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11344 11345 try { // for error handling 11346 { // ( ... )* 11347 for (;;) { 11348 if ((LA(1) == ELSIF)) { 11349 match(ELSIF); 11350 cond_clause(); 11351 if (inputState->guessing==0) { 11352 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11353 } 11354 } 11355 else { 11356 goto _loop350; 11357 } 11358 11359 } 11360 _loop350:; 11361 } // ( ... )* 11362 if ( inputState->guessing==0 ) { 11363 elsifs_opt_AST = RefAdaAST(currentAST.root); 11364 #line 1106 "ada.g" 11365 elsifs_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELSIFS_OPT,"ELSIFS_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(elsifs_opt_AST.get())))); 11366 #line 11367 "AdaParser.cpp" 11367 currentAST.root = elsifs_opt_AST; 11368 if ( elsifs_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11369 elsifs_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11370 currentAST.child = elsifs_opt_AST->getFirstChild(); 11371 else 11372 currentAST.child = elsifs_opt_AST; 11373 currentAST.advanceChildToEnd(); 11374 } 11375 elsifs_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11376 } 11377 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11378 if( inputState->guessing == 0 ) { 11379 reportError(ex); 11380 consume(); 11381 consumeUntil(_tokenSet_98); 11382 } else { 11383 throw; 11384 } 11385 } 11386 returnAST = elsifs_opt_AST; 11387 } 11388 11389 void AdaParser::else_opt() { 11390 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11391 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11392 RefAdaAST else_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11393 11394 try { // for error handling 11395 { 11396 switch ( LA(1)) { 11397 case ELSE: 11398 { 11399 match(ELSE); 11400 statements(); 11401 if (inputState->guessing==0) { 11402 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11403 } 11404 break; 11405 } 11406 case END: 11407 { 11408 break; 11409 } 11410 default: 11411 { 11412 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11413 } 11414 } 11415 } 11416 if ( inputState->guessing==0 ) { 11417 else_opt_AST = RefAdaAST(currentAST.root); 11418 #line 1110 "ada.g" 11419 else_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ELSE_OPT,"ELSE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(else_opt_AST.get())))); 11420 #line 11421 "AdaParser.cpp" 11421 currentAST.root = else_opt_AST; 11422 if ( else_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11423 else_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11424 currentAST.child = else_opt_AST->getFirstChild(); 11425 else 11426 currentAST.child = else_opt_AST; 11427 currentAST.advanceChildToEnd(); 11428 } 11429 else_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11430 } 11431 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11432 if( inputState->guessing == 0 ) { 11433 reportError(ex); 11434 consume(); 11435 consumeUntil(_tokenSet_21); 11436 } else { 11437 throw; 11438 } 11439 } 11440 returnAST = else_opt_AST; 11441 } 11442 11443 void AdaParser::condition() { 11444 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11445 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11446 RefAdaAST condition_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11447 11448 try { // for error handling 11449 expression(); 11450 if (inputState->guessing==0) { 11451 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11452 } 11453 condition_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11454 } 11455 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11456 if( inputState->guessing == 0 ) { 11457 reportError(ex); 11458 consume(); 11459 consumeUntil(_tokenSet_99); 11460 } else { 11461 throw; 11462 } 11463 } 11464 returnAST = condition_AST; 11465 } 11466 11467 void AdaParser::alternative_s() { 11468 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11469 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11470 RefAdaAST alternative_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11471 11472 try { // for error handling 11473 { // ( ... )+ 11474 int _cnt356=0; 11475 for (;;) { 11476 if ((LA(1) == WHEN)) { 11477 case_statement_alternative(); 11478 if (inputState->guessing==0) { 11479 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11480 } 11481 } 11482 else { 11483 if ( _cnt356>=1 ) { goto _loop356; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());} 11484 } 11485 11486 _cnt356++; 11487 } 11488 _loop356:; 11489 } // ( ... )+ 11490 alternative_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11491 } 11492 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11493 if( inputState->guessing == 0 ) { 11494 reportError(ex); 11495 consume(); 11496 consumeUntil(_tokenSet_21); 11497 } else { 11498 throw; 11499 } 11500 } 11501 returnAST = alternative_s_AST; 11502 } 11503 11504 void AdaParser::case_statement_alternative() { 11505 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11506 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11507 RefAdaAST case_statement_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11508 ANTLR_USE_NAMESPACE(antlr)RefToken s = ANTLR_USE_NAMESPACE(antlr)nullToken; 11509 RefAdaAST s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11510 11511 try { // for error handling 11512 s = LT(1); 11513 if ( inputState->guessing == 0 ) { 11514 s_AST = astFactory->create(s); 11515 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get())); 11516 } 11517 match(WHEN); 11518 choice_s(); 11519 if (inputState->guessing==0) { 11520 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11521 } 11522 match(RIGHT_SHAFT); 11523 statements(); 11524 if (inputState->guessing==0) { 11525 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11526 } 11527 if ( inputState->guessing==0 ) { 11528 #line 1121 "ada.g" 11529 Set(s_AST, CASE_STATEMENT_ALTERNATIVE); 11530 #line 11531 "AdaParser.cpp" 11531 } 11532 case_statement_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11533 } 11534 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11535 if( inputState->guessing == 0 ) { 11536 reportError(ex); 11537 consume(); 11538 consumeUntil(_tokenSet_72); 11539 } else { 11540 throw; 11541 } 11542 } 11543 returnAST = case_statement_alternative_AST; 11544 } 11545 11546 void AdaParser::iteration_scheme_opt() { 11547 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11548 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11549 RefAdaAST iteration_scheme_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11550 11551 try { // for error handling 11552 { 11553 switch ( LA(1)) { 11554 case WHILE: 11555 { 11556 RefAdaAST tmp319_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11557 if ( inputState->guessing == 0 ) { 11558 tmp319_AST = astFactory->create(LT(1)); 11559 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp319_AST.get())); 11560 } 11561 match(WHILE); 11562 condition(); 11563 if (inputState->guessing==0) { 11564 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11565 } 11566 break; 11567 } 11568 case FOR: 11569 { 11570 RefAdaAST tmp320_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11571 if ( inputState->guessing == 0 ) { 11572 tmp320_AST = astFactory->create(LT(1)); 11573 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp320_AST.get())); 11574 } 11575 match(FOR); 11576 RefAdaAST tmp321_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11577 if ( inputState->guessing == 0 ) { 11578 tmp321_AST = astFactory->create(LT(1)); 11579 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp321_AST.get())); 11580 } 11581 match(IDENTIFIER); 11582 match(IN); 11583 reverse_opt(); 11584 if (inputState->guessing==0) { 11585 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11586 } 11587 discrete_subtype_definition(); 11588 if (inputState->guessing==0) { 11589 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11590 } 11591 break; 11592 } 11593 case LOOP: 11594 { 11595 break; 11596 } 11597 default: 11598 { 11599 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11600 } 11601 } 11602 } 11603 if ( inputState->guessing==0 ) { 11604 iteration_scheme_opt_AST = RefAdaAST(currentAST.root); 11605 #line 1132 "ada.g" 11606 iteration_scheme_opt_AST = 11607 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ITERATION_SCHEME_OPT,"ITERATION_SCHEME_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(iteration_scheme_opt_AST.get())))); 11608 #line 11609 "AdaParser.cpp" 11609 currentAST.root = iteration_scheme_opt_AST; 11610 if ( iteration_scheme_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11611 iteration_scheme_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11612 currentAST.child = iteration_scheme_opt_AST->getFirstChild(); 11613 else 11614 currentAST.child = iteration_scheme_opt_AST; 11615 currentAST.advanceChildToEnd(); 11616 } 11617 iteration_scheme_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11618 } 11619 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11620 if( inputState->guessing == 0 ) { 11621 reportError(ex); 11622 consume(); 11623 consumeUntil(_tokenSet_100); 11624 } else { 11625 throw; 11626 } 11627 } 11628 returnAST = iteration_scheme_opt_AST; 11629 } 11630 11631 void AdaParser::reverse_opt() { 11632 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11633 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11634 RefAdaAST reverse_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11635 11636 try { // for error handling 11637 { 11638 switch ( LA(1)) { 11639 case REVERSE: 11640 { 11641 RefAdaAST tmp323_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11642 if ( inputState->guessing == 0 ) { 11643 tmp323_AST = astFactory->create(LT(1)); 11644 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp323_AST.get())); 11645 } 11646 match(REVERSE); 11647 break; 11648 } 11649 case IDENTIFIER: 11650 case LPAREN: 11651 case NEW: 11652 case CHARACTER_LITERAL: 11653 case CHAR_STRING: 11654 case NuLL: 11655 case NOT: 11656 case PLUS: 11657 case MINUS: 11658 case ABS: 11659 case NUMERIC_LIT: 11660 { 11661 break; 11662 } 11663 default: 11664 { 11665 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11666 } 11667 } 11668 } 11669 if ( inputState->guessing==0 ) { 11670 reverse_opt_AST = RefAdaAST(currentAST.root); 11671 #line 1138 "ada.g" 11672 reverse_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(reverse_opt_AST.get())))); 11673 #line 11674 "AdaParser.cpp" 11674 currentAST.root = reverse_opt_AST; 11675 if ( reverse_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11676 reverse_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11677 currentAST.child = reverse_opt_AST->getFirstChild(); 11678 else 11679 currentAST.child = reverse_opt_AST; 11680 currentAST.advanceChildToEnd(); 11681 } 11682 reverse_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11683 } 11684 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11685 if( inputState->guessing == 0 ) { 11686 reportError(ex); 11687 consume(); 11688 consumeUntil(_tokenSet_5); 11689 } else { 11690 throw; 11691 } 11692 } 11693 returnAST = reverse_opt_AST; 11694 } 11695 11696 void AdaParser::declare_opt() { 11697 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11698 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11699 RefAdaAST declare_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11700 11701 try { // for error handling 11702 { 11703 switch ( LA(1)) { 11704 case DECLARE: 11705 { 11706 match(DECLARE); 11707 declarative_part(); 11708 if (inputState->guessing==0) { 11709 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11710 } 11711 break; 11712 } 11713 case BEGIN: 11714 { 11715 break; 11716 } 11717 default: 11718 { 11719 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11720 } 11721 } 11722 } 11723 if ( inputState->guessing==0 ) { 11724 declare_opt_AST = RefAdaAST(currentAST.root); 11725 #line 1177 "ada.g" 11726 declare_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DECLARE_OPT,"DECLARE_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(declare_opt_AST.get())))); 11727 #line 11728 "AdaParser.cpp" 11728 currentAST.root = declare_opt_AST; 11729 if ( declare_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11730 declare_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11731 currentAST.child = declare_opt_AST->getFirstChild(); 11732 else 11733 currentAST.child = declare_opt_AST; 11734 currentAST.advanceChildToEnd(); 11735 } 11736 declare_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11737 } 11738 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11739 if( inputState->guessing == 0 ) { 11740 reportError(ex); 11741 consume(); 11742 consumeUntil(_tokenSet_101); 11743 } else { 11744 throw; 11745 } 11746 } 11747 returnAST = declare_opt_AST; 11748 } 11749 11750 void AdaParser::label_name() { 11751 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11752 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11753 RefAdaAST label_name_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11754 11755 try { // for error handling 11756 RefAdaAST tmp325_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11757 if ( inputState->guessing == 0 ) { 11758 tmp325_AST = astFactory->create(LT(1)); 11759 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp325_AST.get())); 11760 } 11761 match(IDENTIFIER); 11762 label_name_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11763 } 11764 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11765 if( inputState->guessing == 0 ) { 11766 reportError(ex); 11767 consume(); 11768 consumeUntil(_tokenSet_102); 11769 } else { 11770 throw; 11771 } 11772 } 11773 returnAST = label_name_AST; 11774 } 11775 11776 void AdaParser::entry_body_formal_part() { 11777 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11778 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11779 RefAdaAST entry_body_formal_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11780 11781 try { // for error handling 11782 entry_index_spec_opt(); 11783 if (inputState->guessing==0) { 11784 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11785 } 11786 formal_part_opt(); 11787 if (inputState->guessing==0) { 11788 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11789 } 11790 entry_body_formal_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11791 } 11792 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11793 if( inputState->guessing == 0 ) { 11794 reportError(ex); 11795 consume(); 11796 consumeUntil(_tokenSet_103); 11797 } else { 11798 throw; 11799 } 11800 } 11801 returnAST = entry_body_formal_part_AST; 11802 } 11803 11804 void AdaParser::entry_barrier() { 11805 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11806 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11807 RefAdaAST entry_barrier_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11808 11809 try { // for error handling 11810 match(WHEN); 11811 condition(); 11812 if (inputState->guessing==0) { 11813 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11814 } 11815 entry_barrier_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11816 } 11817 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11818 if( inputState->guessing == 0 ) { 11819 reportError(ex); 11820 consume(); 11821 consumeUntil(_tokenSet_75); 11822 } else { 11823 throw; 11824 } 11825 } 11826 returnAST = entry_barrier_AST; 11827 } 11828 11829 void AdaParser::entry_index_spec_opt() { 11830 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11831 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11832 RefAdaAST entry_index_spec_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11833 11834 try { // for error handling 11835 { 11836 bool synPredMatched383 = false; 11837 if (((LA(1) == LPAREN) && (LA(2) == FOR))) { 11838 int _m383 = mark(); 11839 synPredMatched383 = true; 11840 inputState->guessing++; 11841 try { 11842 { 11843 match(LPAREN); 11844 match(FOR); 11845 } 11846 } 11847 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 11848 synPredMatched383 = false; 11849 } 11850 rewind(_m383); 11851 inputState->guessing--; 11852 } 11853 if ( synPredMatched383 ) { 11854 match(LPAREN); 11855 match(FOR); 11856 def_id(false); 11857 if (inputState->guessing==0) { 11858 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11859 } 11860 match(IN); 11861 discrete_subtype_definition(); 11862 if (inputState->guessing==0) { 11863 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11864 } 11865 match(RPAREN); 11866 } 11867 else if ((LA(1) == LPAREN || LA(1) == WHEN) && (_tokenSet_5.member(LA(2)))) { 11868 } 11869 else { 11870 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11871 } 11872 11873 } 11874 if ( inputState->guessing==0 ) { 11875 entry_index_spec_opt_AST = RefAdaAST(currentAST.root); 11876 #line 1222 "ada.g" 11877 entry_index_spec_opt_AST = 11878 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_INDEX_SPECIFICATION,"ENTRY_INDEX_SPECIFICATION").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_index_spec_opt_AST.get())))); 11879 #line 11880 "AdaParser.cpp" 11880 currentAST.root = entry_index_spec_opt_AST; 11881 if ( entry_index_spec_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11882 entry_index_spec_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11883 currentAST.child = entry_index_spec_opt_AST->getFirstChild(); 11884 else 11885 currentAST.child = entry_index_spec_opt_AST; 11886 currentAST.advanceChildToEnd(); 11887 } 11888 entry_index_spec_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11889 } 11890 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11891 if( inputState->guessing == 0 ) { 11892 reportError(ex); 11893 consume(); 11894 consumeUntil(_tokenSet_104); 11895 } else { 11896 throw; 11897 } 11898 } 11899 returnAST = entry_index_spec_opt_AST; 11900 } 11901 11902 void AdaParser::entry_call_stmt() { 11903 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11904 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11905 RefAdaAST entry_call_stmt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11906 11907 try { // for error handling 11908 name(); 11909 if (inputState->guessing==0) { 11910 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11911 } 11912 match(SEMI); 11913 if ( inputState->guessing==0 ) { 11914 entry_call_stmt_AST = RefAdaAST(currentAST.root); 11915 #line 1232 "ada.g" 11916 entry_call_stmt_AST = 11917 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_CALL_STATEMENT,"ENTRY_CALL_STATEMENT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_call_stmt_AST.get())))); 11918 #line 11919 "AdaParser.cpp" 11919 currentAST.root = entry_call_stmt_AST; 11920 if ( entry_call_stmt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11921 entry_call_stmt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11922 currentAST.child = entry_call_stmt_AST->getFirstChild(); 11923 else 11924 currentAST.child = entry_call_stmt_AST; 11925 currentAST.advanceChildToEnd(); 11926 } 11927 entry_call_stmt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11928 } 11929 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11930 if( inputState->guessing == 0 ) { 11931 reportError(ex); 11932 consume(); 11933 consumeUntil(_tokenSet_105); 11934 } else { 11935 throw; 11936 } 11937 } 11938 returnAST = entry_call_stmt_AST; 11939 } 11940 11941 void AdaParser::entry_index_opt() { 11942 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11943 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 11944 RefAdaAST entry_index_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 11945 11946 try { // for error handling 11947 { 11948 bool synPredMatched391 = false; 11949 if (((LA(1) == LPAREN) && (_tokenSet_5.member(LA(2))))) { 11950 int _m391 = mark(); 11951 synPredMatched391 = true; 11952 inputState->guessing++; 11953 try { 11954 { 11955 match(LPAREN); 11956 expression(); 11957 match(RPAREN); 11958 } 11959 } 11960 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 11961 synPredMatched391 = false; 11962 } 11963 rewind(_m391); 11964 inputState->guessing--; 11965 } 11966 if ( synPredMatched391 ) { 11967 match(LPAREN); 11968 expression(); 11969 if (inputState->guessing==0) { 11970 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 11971 } 11972 match(RPAREN); 11973 } 11974 else if ((LA(1) == SEMI || LA(1) == LPAREN || LA(1) == DO) && (_tokenSet_89.member(LA(2)))) { 11975 } 11976 else { 11977 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 11978 } 11979 11980 } 11981 if ( inputState->guessing==0 ) { 11982 entry_index_opt_AST = RefAdaAST(currentAST.root); 11983 #line 1251 "ada.g" 11984 entry_index_opt_AST = 11985 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_INDEX_OPT,"ENTRY_INDEX_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_index_opt_AST.get())))); 11986 #line 11987 "AdaParser.cpp" 11987 currentAST.root = entry_index_opt_AST; 11988 if ( entry_index_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 11989 entry_index_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 11990 currentAST.child = entry_index_opt_AST->getFirstChild(); 11991 else 11992 currentAST.child = entry_index_opt_AST; 11993 currentAST.advanceChildToEnd(); 11994 } 11995 entry_index_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 11996 } 11997 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 11998 if( inputState->guessing == 0 ) { 11999 reportError(ex); 12000 consume(); 12001 consumeUntil(_tokenSet_106); 12002 } else { 12003 throw; 12004 } 12005 } 12006 returnAST = entry_index_opt_AST; 12007 } 12008 12009 void AdaParser::until_opt() { 12010 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12011 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12012 RefAdaAST until_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12013 12014 try { // for error handling 12015 { 12016 switch ( LA(1)) { 12017 case UNTIL: 12018 { 12019 RefAdaAST tmp334_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12020 if ( inputState->guessing == 0 ) { 12021 tmp334_AST = astFactory->create(LT(1)); 12022 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp334_AST.get())); 12023 } 12024 match(UNTIL); 12025 break; 12026 } 12027 case IDENTIFIER: 12028 case LPAREN: 12029 case NEW: 12030 case CHARACTER_LITERAL: 12031 case CHAR_STRING: 12032 case NuLL: 12033 case NOT: 12034 case PLUS: 12035 case MINUS: 12036 case ABS: 12037 case NUMERIC_LIT: 12038 { 12039 break; 12040 } 12041 default: 12042 { 12043 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12044 } 12045 } 12046 } 12047 if ( inputState->guessing==0 ) { 12048 until_opt_AST = RefAdaAST(currentAST.root); 12049 #line 1261 "ada.g" 12050 until_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(MODIFIERS,"MODIFIERS").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(until_opt_AST.get())))); 12051 #line 12052 "AdaParser.cpp" 12052 currentAST.root = until_opt_AST; 12053 if ( until_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12054 until_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12055 currentAST.child = until_opt_AST->getFirstChild(); 12056 else 12057 currentAST.child = until_opt_AST; 12058 currentAST.advanceChildToEnd(); 12059 } 12060 until_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12061 } 12062 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12063 if( inputState->guessing == 0 ) { 12064 reportError(ex); 12065 consume(); 12066 consumeUntil(_tokenSet_5); 12067 } else { 12068 throw; 12069 } 12070 } 12071 returnAST = until_opt_AST; 12072 } 12073 12074 void AdaParser::triggering_alternative() { 12075 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12076 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12077 RefAdaAST triggering_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12078 12079 try { // for error handling 12080 { 12081 switch ( LA(1)) { 12082 case DELAY: 12083 { 12084 delay_stmt(); 12085 if (inputState->guessing==0) { 12086 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12087 } 12088 break; 12089 } 12090 case IDENTIFIER: 12091 { 12092 entry_call_stmt(); 12093 if (inputState->guessing==0) { 12094 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12095 } 12096 break; 12097 } 12098 default: 12099 { 12100 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12101 } 12102 } 12103 } 12104 stmts_opt(); 12105 if (inputState->guessing==0) { 12106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12107 } 12108 if ( inputState->guessing==0 ) { 12109 triggering_alternative_AST = RefAdaAST(currentAST.root); 12110 #line 1285 "ada.g" 12111 triggering_alternative_AST = 12112 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(TRIGGERING_ALTERNATIVE,"TRIGGERING_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(triggering_alternative_AST.get())))); 12113 #line 12114 "AdaParser.cpp" 12114 currentAST.root = triggering_alternative_AST; 12115 if ( triggering_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12116 triggering_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12117 currentAST.child = triggering_alternative_AST->getFirstChild(); 12118 else 12119 currentAST.child = triggering_alternative_AST; 12120 currentAST.advanceChildToEnd(); 12121 } 12122 triggering_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12123 } 12124 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12125 if( inputState->guessing == 0 ) { 12126 reportError(ex); 12127 consume(); 12128 consumeUntil(_tokenSet_107); 12129 } else { 12130 throw; 12131 } 12132 } 12133 returnAST = triggering_alternative_AST; 12134 } 12135 12136 void AdaParser::abortable_part() { 12137 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12138 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12139 RefAdaAST abortable_part_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12140 12141 try { // for error handling 12142 stmts_opt(); 12143 if (inputState->guessing==0) { 12144 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12145 } 12146 if ( inputState->guessing==0 ) { 12147 abortable_part_AST = RefAdaAST(currentAST.root); 12148 #line 1291 "ada.g" 12149 abortable_part_AST = 12150 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ABORTABLE_PART,"ABORTABLE_PART").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(abortable_part_AST.get())))); 12151 #line 12152 "AdaParser.cpp" 12152 currentAST.root = abortable_part_AST; 12153 if ( abortable_part_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12154 abortable_part_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12155 currentAST.child = abortable_part_AST->getFirstChild(); 12156 else 12157 currentAST.child = abortable_part_AST; 12158 currentAST.advanceChildToEnd(); 12159 } 12160 abortable_part_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12161 } 12162 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12163 if( inputState->guessing == 0 ) { 12164 reportError(ex); 12165 consume(); 12166 consumeUntil(_tokenSet_21); 12167 } else { 12168 throw; 12169 } 12170 } 12171 returnAST = abortable_part_AST; 12172 } 12173 12174 void AdaParser::selective_accept() { 12175 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12176 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12177 RefAdaAST selective_accept_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12178 12179 try { // for error handling 12180 guard_opt(); 12181 if (inputState->guessing==0) { 12182 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12183 } 12184 select_alternative(); 12185 if (inputState->guessing==0) { 12186 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12187 } 12188 or_select_opt(); 12189 if (inputState->guessing==0) { 12190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12191 } 12192 else_opt(); 12193 if (inputState->guessing==0) { 12194 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12195 } 12196 selective_accept_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12197 } 12198 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12199 if( inputState->guessing == 0 ) { 12200 reportError(ex); 12201 consume(); 12202 consumeUntil(_tokenSet_21); 12203 } else { 12204 throw; 12205 } 12206 } 12207 returnAST = selective_accept_AST; 12208 } 12209 12210 void AdaParser::entry_call_alternative() { 12211 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12212 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12213 RefAdaAST entry_call_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12214 12215 try { // for error handling 12216 entry_call_stmt(); 12217 if (inputState->guessing==0) { 12218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12219 } 12220 stmts_opt(); 12221 if (inputState->guessing==0) { 12222 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12223 } 12224 if ( inputState->guessing==0 ) { 12225 entry_call_alternative_AST = RefAdaAST(currentAST.root); 12226 #line 1297 "ada.g" 12227 entry_call_alternative_AST = 12228 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ENTRY_CALL_ALTERNATIVE,"ENTRY_CALL_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(entry_call_alternative_AST.get())))); 12229 #line 12230 "AdaParser.cpp" 12230 currentAST.root = entry_call_alternative_AST; 12231 if ( entry_call_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12232 entry_call_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12233 currentAST.child = entry_call_alternative_AST->getFirstChild(); 12234 else 12235 currentAST.child = entry_call_alternative_AST; 12236 currentAST.advanceChildToEnd(); 12237 } 12238 entry_call_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12239 } 12240 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12241 if( inputState->guessing == 0 ) { 12242 reportError(ex); 12243 consume(); 12244 consumeUntil(_tokenSet_108); 12245 } else { 12246 throw; 12247 } 12248 } 12249 returnAST = entry_call_alternative_AST; 12250 } 12251 12252 void AdaParser::delay_alternative() { 12253 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12254 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12255 RefAdaAST delay_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12256 12257 try { // for error handling 12258 delay_stmt(); 12259 if (inputState->guessing==0) { 12260 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12261 } 12262 stmts_opt(); 12263 if (inputState->guessing==0) { 12264 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12265 } 12266 if ( inputState->guessing==0 ) { 12267 delay_alternative_AST = RefAdaAST(currentAST.root); 12268 #line 1322 "ada.g" 12269 delay_alternative_AST = 12270 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(DELAY_ALTERNATIVE,"DELAY_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(delay_alternative_AST.get())))); 12271 #line 12272 "AdaParser.cpp" 12272 currentAST.root = delay_alternative_AST; 12273 if ( delay_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12274 delay_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12275 currentAST.child = delay_alternative_AST->getFirstChild(); 12276 else 12277 currentAST.child = delay_alternative_AST; 12278 currentAST.advanceChildToEnd(); 12279 } 12280 delay_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12281 } 12282 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12283 if( inputState->guessing == 0 ) { 12284 reportError(ex); 12285 consume(); 12286 consumeUntil(_tokenSet_109); 12287 } else { 12288 throw; 12289 } 12290 } 12291 returnAST = delay_alternative_AST; 12292 } 12293 12294 void AdaParser::stmts_opt() { 12295 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12296 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12297 RefAdaAST stmts_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12298 12299 try { // for error handling 12300 { // ( ... )* 12301 for (;;) { 12302 switch ( LA(1)) { 12303 case PRAGMA: 12304 { 12305 pragma(); 12306 if (inputState->guessing==0) { 12307 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12308 } 12309 break; 12310 } 12311 case IDENTIFIER: 12312 case NuLL: 12313 case RETURN: 12314 case FOR: 12315 case CASE: 12316 case BEGIN: 12317 case LT_LT: 12318 case IF: 12319 case LOOP: 12320 case WHILE: 12321 case DECLARE: 12322 case EXIT: 12323 case GOTO: 12324 case ACCEPT: 12325 case DELAY: 12326 case SELECT: 12327 case ABORT: 12328 case RAISE: 12329 case REQUEUE: 12330 { 12331 statement(); 12332 if (inputState->guessing==0) { 12333 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12334 } 12335 break; 12336 } 12337 default: 12338 { 12339 goto _loop414; 12340 } 12341 } 12342 } 12343 _loop414:; 12344 } // ( ... )* 12345 stmts_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12346 } 12347 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12348 if( inputState->guessing == 0 ) { 12349 reportError(ex); 12350 consume(); 12351 consumeUntil(_tokenSet_110); 12352 } else { 12353 throw; 12354 } 12355 } 12356 returnAST = stmts_opt_AST; 12357 } 12358 12359 void AdaParser::guard_opt() { 12360 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12361 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12362 RefAdaAST guard_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12363 12364 try { // for error handling 12365 { 12366 switch ( LA(1)) { 12367 case WHEN: 12368 { 12369 match(WHEN); 12370 condition(); 12371 if (inputState->guessing==0) { 12372 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12373 } 12374 match(RIGHT_SHAFT); 12375 { // ( ... )* 12376 for (;;) { 12377 if ((LA(1) == PRAGMA)) { 12378 pragma(); 12379 if (inputState->guessing==0) { 12380 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12381 } 12382 } 12383 else { 12384 goto _loop408; 12385 } 12386 12387 } 12388 _loop408:; 12389 } // ( ... )* 12390 break; 12391 } 12392 case ACCEPT: 12393 case DELAY: 12394 case TERMINATE: 12395 { 12396 break; 12397 } 12398 default: 12399 { 12400 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12401 } 12402 } 12403 } 12404 if ( inputState->guessing==0 ) { 12405 guard_opt_AST = RefAdaAST(currentAST.root); 12406 #line 1306 "ada.g" 12407 guard_opt_AST = RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(GUARD_OPT,"GUARD_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(guard_opt_AST.get())))); 12408 #line 12409 "AdaParser.cpp" 12409 currentAST.root = guard_opt_AST; 12410 if ( guard_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12411 guard_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12412 currentAST.child = guard_opt_AST->getFirstChild(); 12413 else 12414 currentAST.child = guard_opt_AST; 12415 currentAST.advanceChildToEnd(); 12416 } 12417 guard_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12418 } 12419 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12420 if( inputState->guessing == 0 ) { 12421 reportError(ex); 12422 consume(); 12423 consumeUntil(_tokenSet_111); 12424 } else { 12425 throw; 12426 } 12427 } 12428 returnAST = guard_opt_AST; 12429 } 12430 12431 void AdaParser::select_alternative() { 12432 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12433 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12434 RefAdaAST select_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12435 ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; 12436 RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12437 12438 try { // for error handling 12439 switch ( LA(1)) { 12440 case ACCEPT: 12441 { 12442 accept_alternative(); 12443 if (inputState->guessing==0) { 12444 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12445 } 12446 select_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12447 break; 12448 } 12449 case DELAY: 12450 { 12451 delay_alternative(); 12452 if (inputState->guessing==0) { 12453 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12454 } 12455 select_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12456 break; 12457 } 12458 case TERMINATE: 12459 { 12460 t = LT(1); 12461 if ( inputState->guessing == 0 ) { 12462 t_AST = astFactory->create(t); 12463 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get())); 12464 } 12465 match(TERMINATE); 12466 match(SEMI); 12467 if ( inputState->guessing==0 ) { 12468 #line 1312 "ada.g" 12469 Set(t_AST, TERMINATE_ALTERNATIVE); 12470 #line 12471 "AdaParser.cpp" 12471 } 12472 select_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12473 break; 12474 } 12475 default: 12476 { 12477 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12478 } 12479 } 12480 } 12481 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12482 if( inputState->guessing == 0 ) { 12483 reportError(ex); 12484 consume(); 12485 consumeUntil(_tokenSet_109); 12486 } else { 12487 throw; 12488 } 12489 } 12490 returnAST = select_alternative_AST; 12491 } 12492 12493 void AdaParser::or_select_opt() { 12494 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12495 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12496 RefAdaAST or_select_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12497 12498 try { // for error handling 12499 { // ( ... )* 12500 for (;;) { 12501 if ((LA(1) == OR)) { 12502 match(OR); 12503 guard_opt(); 12504 if (inputState->guessing==0) { 12505 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12506 } 12507 select_alternative(); 12508 if (inputState->guessing==0) { 12509 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12510 } 12511 } 12512 else { 12513 goto _loop417; 12514 } 12515 12516 } 12517 _loop417:; 12518 } // ( ... )* 12519 if ( inputState->guessing==0 ) { 12520 or_select_opt_AST = RefAdaAST(currentAST.root); 12521 #line 1331 "ada.g" 12522 or_select_opt_AST = 12523 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(OR_SELECT_OPT,"OR_SELECT_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(or_select_opt_AST.get())))); 12524 #line 12525 "AdaParser.cpp" 12525 currentAST.root = or_select_opt_AST; 12526 if ( or_select_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12527 or_select_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12528 currentAST.child = or_select_opt_AST->getFirstChild(); 12529 else 12530 currentAST.child = or_select_opt_AST; 12531 currentAST.advanceChildToEnd(); 12532 } 12533 or_select_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12534 } 12535 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12536 if( inputState->guessing == 0 ) { 12537 reportError(ex); 12538 consume(); 12539 consumeUntil(_tokenSet_98); 12540 } else { 12541 throw; 12542 } 12543 } 12544 returnAST = or_select_opt_AST; 12545 } 12546 12547 void AdaParser::accept_alternative() { 12548 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12549 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12550 RefAdaAST accept_alternative_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12551 12552 try { // for error handling 12553 accept_stmt(); 12554 if (inputState->guessing==0) { 12555 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12556 } 12557 stmts_opt(); 12558 if (inputState->guessing==0) { 12559 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12560 } 12561 if ( inputState->guessing==0 ) { 12562 accept_alternative_AST = RefAdaAST(currentAST.root); 12563 #line 1316 "ada.g" 12564 accept_alternative_AST = 12565 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(ACCEPT_ALTERNATIVE,"ACCEPT_ALTERNATIVE").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(accept_alternative_AST.get())))); 12566 #line 12567 "AdaParser.cpp" 12567 currentAST.root = accept_alternative_AST; 12568 if ( accept_alternative_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12569 accept_alternative_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12570 currentAST.child = accept_alternative_AST->getFirstChild(); 12571 else 12572 currentAST.child = accept_alternative_AST; 12573 currentAST.advanceChildToEnd(); 12574 } 12575 accept_alternative_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12576 } 12577 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12578 if( inputState->guessing == 0 ) { 12579 reportError(ex); 12580 consume(); 12581 consumeUntil(_tokenSet_109); 12582 } else { 12583 throw; 12584 } 12585 } 12586 returnAST = accept_alternative_AST; 12587 } 12588 12589 void AdaParser::exception_handler() { 12590 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12591 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12592 RefAdaAST exception_handler_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12593 ANTLR_USE_NAMESPACE(antlr)RefToken w = ANTLR_USE_NAMESPACE(antlr)nullToken; 12594 RefAdaAST w_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12595 12596 try { // for error handling 12597 w = LT(1); 12598 if ( inputState->guessing == 0 ) { 12599 w_AST = astFactory->create(w); 12600 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(w_AST.get())); 12601 } 12602 match(WHEN); 12603 identifier_colon_opt(); 12604 if (inputState->guessing==0) { 12605 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12606 } 12607 except_choice_s(); 12608 if (inputState->guessing==0) { 12609 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12610 } 12611 match(RIGHT_SHAFT); 12612 statements(); 12613 if (inputState->guessing==0) { 12614 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12615 } 12616 if ( inputState->guessing==0 ) { 12617 #line 1347 "ada.g" 12618 Set (w_AST, EXCEPTION_HANDLER); 12619 #line 12620 "AdaParser.cpp" 12620 } 12621 exception_handler_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12622 } 12623 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12624 if( inputState->guessing == 0 ) { 12625 reportError(ex); 12626 consume(); 12627 consumeUntil(_tokenSet_72); 12628 } else { 12629 throw; 12630 } 12631 } 12632 returnAST = exception_handler_AST; 12633 } 12634 12635 void AdaParser::identifier_colon_opt() { 12636 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12637 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12638 RefAdaAST identifier_colon_opt_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12639 12640 try { // for error handling 12641 { 12642 if ((LA(1) == IDENTIFIER) && (LA(2) == COLON)) { 12643 RefAdaAST tmp340_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12644 if ( inputState->guessing == 0 ) { 12645 tmp340_AST = astFactory->create(LT(1)); 12646 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp340_AST.get())); 12647 } 12648 match(IDENTIFIER); 12649 match(COLON); 12650 } 12651 else if ((LA(1) == IDENTIFIER || LA(1) == OTHERS) && (LA(2) == RIGHT_SHAFT || LA(2) == DOT || LA(2) == PIPE)) { 12652 } 12653 else { 12654 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12655 } 12656 12657 } 12658 if ( inputState->guessing==0 ) { 12659 identifier_colon_opt_AST = RefAdaAST(currentAST.root); 12660 #line 1351 "ada.g" 12661 identifier_colon_opt_AST = 12662 RefAdaAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(IDENTIFIER_COLON_OPT,"IDENTIFIER_COLON_OPT").get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(identifier_colon_opt_AST.get())))); 12663 #line 12664 "AdaParser.cpp" 12664 currentAST.root = identifier_colon_opt_AST; 12665 if ( identifier_colon_opt_AST!=static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) && 12666 identifier_colon_opt_AST->getFirstChild() != static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) ) 12667 currentAST.child = identifier_colon_opt_AST->getFirstChild(); 12668 else 12669 currentAST.child = identifier_colon_opt_AST; 12670 currentAST.advanceChildToEnd(); 12671 } 12672 identifier_colon_opt_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12673 } 12674 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12675 if( inputState->guessing == 0 ) { 12676 reportError(ex); 12677 consume(); 12678 consumeUntil(_tokenSet_112); 12679 } else { 12680 throw; 12681 } 12682 } 12683 returnAST = identifier_colon_opt_AST; 12684 } 12685 12686 void AdaParser::except_choice_s() { 12687 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12688 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12689 RefAdaAST except_choice_s_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12690 12691 try { // for error handling 12692 exception_choice(); 12693 if (inputState->guessing==0) { 12694 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12695 } 12696 { // ( ... )* 12697 for (;;) { 12698 if ((LA(1) == PIPE)) { 12699 RefAdaAST tmp342_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12700 if ( inputState->guessing == 0 ) { 12701 tmp342_AST = astFactory->create(LT(1)); 12702 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp342_AST.get())); 12703 } 12704 match(PIPE); 12705 exception_choice(); 12706 if (inputState->guessing==0) { 12707 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12708 } 12709 } 12710 else { 12711 goto _loop430; 12712 } 12713 12714 } 12715 _loop430:; 12716 } // ( ... )* 12717 except_choice_s_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12718 } 12719 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12720 if( inputState->guessing == 0 ) { 12721 reportError(ex); 12722 consume(); 12723 consumeUntil(_tokenSet_76); 12724 } else { 12725 throw; 12726 } 12727 } 12728 returnAST = except_choice_s_AST; 12729 } 12730 12731 void AdaParser::exception_choice() { 12732 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12733 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12734 RefAdaAST exception_choice_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12735 12736 try { // for error handling 12737 switch ( LA(1)) { 12738 case IDENTIFIER: 12739 { 12740 compound_name(); 12741 if (inputState->guessing==0) { 12742 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12743 } 12744 exception_choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12745 break; 12746 } 12747 case OTHERS: 12748 { 12749 RefAdaAST tmp343_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12750 if ( inputState->guessing == 0 ) { 12751 tmp343_AST = astFactory->create(LT(1)); 12752 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp343_AST.get())); 12753 } 12754 match(OTHERS); 12755 exception_choice_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12756 break; 12757 } 12758 default: 12759 { 12760 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12761 } 12762 } 12763 } 12764 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12765 if( inputState->guessing == 0 ) { 12766 reportError(ex); 12767 consume(); 12768 consumeUntil(_tokenSet_68); 12769 } else { 12770 throw; 12771 } 12772 } 12773 returnAST = exception_choice_AST; 12774 } 12775 12776 void AdaParser::operator_call() { 12777 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12778 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12779 RefAdaAST operator_call_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12780 ANTLR_USE_NAMESPACE(antlr)RefToken cs = ANTLR_USE_NAMESPACE(antlr)nullToken; 12781 RefAdaAST cs_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12782 12783 try { // for error handling 12784 cs = LT(1); 12785 if ( inputState->guessing == 0 ) { 12786 cs_AST = astFactory->create(cs); 12787 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cs_AST.get())); 12788 } 12789 match(CHAR_STRING); 12790 operator_call_tail(cs_AST); 12791 if (inputState->guessing==0) { 12792 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12793 } 12794 operator_call_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12795 } 12796 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12797 if( inputState->guessing == 0 ) { 12798 reportError(ex); 12799 consume(); 12800 consumeUntil(_tokenSet_0); 12801 } else { 12802 throw; 12803 } 12804 } 12805 returnAST = operator_call_AST; 12806 } 12807 12808 void AdaParser::operator_call_tail( 12809 RefAdaAST opstr 12810 ) { 12811 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12812 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12813 RefAdaAST operator_call_tail_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12814 12815 try { // for error handling 12816 match(LPAREN); 12817 if (!( is_operator_symbol(opstr->getText().c_str()) )) 12818 throw ANTLR_USE_NAMESPACE(antlr)SemanticException(" is_operator_symbol(opstr->getText().c_str()) "); 12819 value_s(); 12820 if (inputState->guessing==0) { 12821 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12822 } 12823 match(RPAREN); 12824 if ( inputState->guessing==0 ) { 12825 #line 1376 "ada.g" 12826 opstr->setType(OPERATOR_SYMBOL); 12827 #line 12828 "AdaParser.cpp" 12828 } 12829 operator_call_tail_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 12830 } 12831 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 12832 if( inputState->guessing == 0 ) { 12833 reportError(ex); 12834 consume(); 12835 consumeUntil(_tokenSet_113); 12836 } else { 12837 throw; 12838 } 12839 } 12840 returnAST = operator_call_tail_AST; 12841 } 12842 12843 void AdaParser::relation() { 12844 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12845 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 12846 RefAdaAST relation_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12847 ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; 12848 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12849 12850 try { // for error handling 12851 simple_expression(); 12852 if (inputState->guessing==0) { 12853 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12854 } 12855 { 12856 switch ( LA(1)) { 12857 case IN: 12858 { 12859 RefAdaAST tmp346_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12860 if ( inputState->guessing == 0 ) { 12861 tmp346_AST = astFactory->create(LT(1)); 12862 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp346_AST.get())); 12863 } 12864 match(IN); 12865 range_or_mark(); 12866 if (inputState->guessing==0) { 12867 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12868 } 12869 break; 12870 } 12871 case NOT: 12872 { 12873 n = LT(1); 12874 if ( inputState->guessing == 0 ) { 12875 n_AST = astFactory->create(n); 12876 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get())); 12877 } 12878 match(NOT); 12879 match(IN); 12880 range_or_mark(); 12881 if (inputState->guessing==0) { 12882 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12883 } 12884 if ( inputState->guessing==0 ) { 12885 #line 1400 "ada.g" 12886 Set (n_AST, NOT_IN); 12887 #line 12888 "AdaParser.cpp" 12888 } 12889 break; 12890 } 12891 case EQ: 12892 { 12893 RefAdaAST tmp348_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12894 if ( inputState->guessing == 0 ) { 12895 tmp348_AST = astFactory->create(LT(1)); 12896 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp348_AST.get())); 12897 } 12898 match(EQ); 12899 simple_expression(); 12900 if (inputState->guessing==0) { 12901 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12902 } 12903 break; 12904 } 12905 case NE: 12906 { 12907 RefAdaAST tmp349_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12908 if ( inputState->guessing == 0 ) { 12909 tmp349_AST = astFactory->create(LT(1)); 12910 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp349_AST.get())); 12911 } 12912 match(NE); 12913 simple_expression(); 12914 if (inputState->guessing==0) { 12915 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12916 } 12917 break; 12918 } 12919 case LT_: 12920 { 12921 RefAdaAST tmp350_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12922 if ( inputState->guessing == 0 ) { 12923 tmp350_AST = astFactory->create(LT(1)); 12924 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp350_AST.get())); 12925 } 12926 match(LT_); 12927 simple_expression(); 12928 if (inputState->guessing==0) { 12929 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12930 } 12931 break; 12932 } 12933 case LE: 12934 { 12935 RefAdaAST tmp351_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12936 if ( inputState->guessing == 0 ) { 12937 tmp351_AST = astFactory->create(LT(1)); 12938 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp351_AST.get())); 12939 } 12940 match(LE); 12941 simple_expression(); 12942 if (inputState->guessing==0) { 12943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12944 } 12945 break; 12946 } 12947 case GT: 12948 { 12949 RefAdaAST tmp352_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12950 if ( inputState->guessing == 0 ) { 12951 tmp352_AST = astFactory->create(LT(1)); 12952 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp352_AST.get())); 12953 } 12954 match(GT); 12955 simple_expression(); 12956 if (inputState->guessing==0) { 12957 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12958 } 12959 break; 12960 } 12961 case GE: 12962 { 12963 RefAdaAST tmp353_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 12964 if ( inputState->guessing == 0 ) { 12965 tmp353_AST = astFactory->create(LT(1)); 12966 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp353_AST.get())); 12967 } 12968 match(GE); 12969 simple_expression(); 12970 if (inputState->guessing==0) { 12971 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 12972 } 12973 break; 12974 } 12975 case SEMI: 12976 case COMMA: 12977 case RPAREN: 12978 case RIGHT_SHAFT: 12979 case WITH: 12980 case RANGE: 12981 case DIGITS: 12982 case IS: 12983 case PIPE: 12984 case DOT_DOT: 12985 case ASSIGN: 12986 case THEN: 12987 case LOOP: 12988 case OR: 12989 case AND: 12990 case XOR: 12991 { 12992 break; 12993 } 12994 default: 12995 { 12996 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 12997 } 12998 } 12999 } 13000 relation_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13001 } 13002 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13003 if( inputState->guessing == 0 ) { 13004 reportError(ex); 13005 consume(); 13006 consumeUntil(_tokenSet_34); 13007 } else { 13008 throw; 13009 } 13010 } 13011 returnAST = relation_AST; 13012 } 13013 13014 void AdaParser::range_or_mark() { 13015 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13016 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13017 RefAdaAST range_or_mark_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13018 13019 try { // for error handling 13020 bool synPredMatched450 = false; 13021 if (((_tokenSet_5.member(LA(1))) && (_tokenSet_33.member(LA(2))))) { 13022 int _m450 = mark(); 13023 synPredMatched450 = true; 13024 inputState->guessing++; 13025 try { 13026 { 13027 range(); 13028 } 13029 } 13030 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) { 13031 synPredMatched450 = false; 13032 } 13033 rewind(_m450); 13034 inputState->guessing--; 13035 } 13036 if ( synPredMatched450 ) { 13037 range(); 13038 if (inputState->guessing==0) { 13039 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13040 } 13041 range_or_mark_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13042 } 13043 else if ((LA(1) == IDENTIFIER) && (_tokenSet_114.member(LA(2)))) { 13044 subtype_mark(); 13045 if (inputState->guessing==0) { 13046 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13047 } 13048 range_or_mark_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13049 } 13050 else { 13051 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13052 } 13053 13054 } 13055 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13056 if( inputState->guessing == 0 ) { 13057 reportError(ex); 13058 consume(); 13059 consumeUntil(_tokenSet_34); 13060 } else { 13061 throw; 13062 } 13063 } 13064 returnAST = range_or_mark_AST; 13065 } 13066 13067 void AdaParser::signed_term() { 13068 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13069 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13070 RefAdaAST signed_term_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13071 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 13072 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13073 ANTLR_USE_NAMESPACE(antlr)RefToken m = ANTLR_USE_NAMESPACE(antlr)nullToken; 13074 RefAdaAST m_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13075 13076 try { // for error handling 13077 switch ( LA(1)) { 13078 case PLUS: 13079 { 13080 p = LT(1); 13081 if ( inputState->guessing == 0 ) { 13082 p_AST = astFactory->create(p); 13083 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 13084 } 13085 match(PLUS); 13086 term(); 13087 if (inputState->guessing==0) { 13088 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13089 } 13090 if ( inputState->guessing==0 ) { 13091 #line 1422 "ada.g" 13092 Set(p_AST, UNARY_PLUS); 13093 #line 13094 "AdaParser.cpp" 13094 } 13095 signed_term_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13096 break; 13097 } 13098 case MINUS: 13099 { 13100 m = LT(1); 13101 if ( inputState->guessing == 0 ) { 13102 m_AST = astFactory->create(m); 13103 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(m_AST.get())); 13104 } 13105 match(MINUS); 13106 term(); 13107 if (inputState->guessing==0) { 13108 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13109 } 13110 if ( inputState->guessing==0 ) { 13111 #line 1423 "ada.g" 13112 Set(m_AST, UNARY_MINUS); 13113 #line 13114 "AdaParser.cpp" 13114 } 13115 signed_term_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13116 break; 13117 } 13118 case IDENTIFIER: 13119 case LPAREN: 13120 case NEW: 13121 case CHARACTER_LITERAL: 13122 case CHAR_STRING: 13123 case NuLL: 13124 case NOT: 13125 case ABS: 13126 case NUMERIC_LIT: 13127 { 13128 term(); 13129 if (inputState->guessing==0) { 13130 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13131 } 13132 signed_term_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13133 break; 13134 } 13135 default: 13136 { 13137 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13138 } 13139 } 13140 } 13141 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13142 if( inputState->guessing == 0 ) { 13143 reportError(ex); 13144 consume(); 13145 consumeUntil(_tokenSet_115); 13146 } else { 13147 throw; 13148 } 13149 } 13150 returnAST = signed_term_AST; 13151 } 13152 13153 void AdaParser::term() { 13154 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13155 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13156 RefAdaAST term_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13157 13158 try { // for error handling 13159 factor(); 13160 if (inputState->guessing==0) { 13161 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13162 } 13163 { // ( ... )* 13164 for (;;) { 13165 switch ( LA(1)) { 13166 case STAR: 13167 { 13168 RefAdaAST tmp354_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13169 if ( inputState->guessing == 0 ) { 13170 tmp354_AST = astFactory->create(LT(1)); 13171 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp354_AST.get())); 13172 } 13173 match(STAR); 13174 factor(); 13175 if (inputState->guessing==0) { 13176 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13177 } 13178 break; 13179 } 13180 case DIV: 13181 { 13182 RefAdaAST tmp355_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13183 if ( inputState->guessing == 0 ) { 13184 tmp355_AST = astFactory->create(LT(1)); 13185 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp355_AST.get())); 13186 } 13187 match(DIV); 13188 factor(); 13189 if (inputState->guessing==0) { 13190 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13191 } 13192 break; 13193 } 13194 case MOD: 13195 { 13196 RefAdaAST tmp356_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13197 if ( inputState->guessing == 0 ) { 13198 tmp356_AST = astFactory->create(LT(1)); 13199 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp356_AST.get())); 13200 } 13201 match(MOD); 13202 factor(); 13203 if (inputState->guessing==0) { 13204 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13205 } 13206 break; 13207 } 13208 case REM: 13209 { 13210 RefAdaAST tmp357_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13211 if ( inputState->guessing == 0 ) { 13212 tmp357_AST = astFactory->create(LT(1)); 13213 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp357_AST.get())); 13214 } 13215 match(REM); 13216 factor(); 13217 if (inputState->guessing==0) { 13218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13219 } 13220 break; 13221 } 13222 default: 13223 { 13224 goto _loop457; 13225 } 13226 } 13227 } 13228 _loop457:; 13229 } // ( ... )* 13230 term_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13231 } 13232 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13233 if( inputState->guessing == 0 ) { 13234 reportError(ex); 13235 consume(); 13236 consumeUntil(_tokenSet_115); 13237 } else { 13238 throw; 13239 } 13240 } 13241 returnAST = term_AST; 13242 } 13243 13244 void AdaParser::factor() { 13245 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13246 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13247 RefAdaAST factor_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13248 13249 try { // for error handling 13250 { 13251 switch ( LA(1)) { 13252 case NOT: 13253 { 13254 RefAdaAST tmp358_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13255 if ( inputState->guessing == 0 ) { 13256 tmp358_AST = astFactory->create(LT(1)); 13257 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp358_AST.get())); 13258 } 13259 match(NOT); 13260 primary(); 13261 if (inputState->guessing==0) { 13262 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13263 } 13264 break; 13265 } 13266 case ABS: 13267 { 13268 RefAdaAST tmp359_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13269 if ( inputState->guessing == 0 ) { 13270 tmp359_AST = astFactory->create(LT(1)); 13271 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp359_AST.get())); 13272 } 13273 match(ABS); 13274 primary(); 13275 if (inputState->guessing==0) { 13276 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13277 } 13278 break; 13279 } 13280 case IDENTIFIER: 13281 case LPAREN: 13282 case NEW: 13283 case CHARACTER_LITERAL: 13284 case CHAR_STRING: 13285 case NuLL: 13286 case NUMERIC_LIT: 13287 { 13288 primary(); 13289 if (inputState->guessing==0) { 13290 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13291 } 13292 { 13293 switch ( LA(1)) { 13294 case EXPON: 13295 { 13296 RefAdaAST tmp360_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13297 if ( inputState->guessing == 0 ) { 13298 tmp360_AST = astFactory->create(LT(1)); 13299 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp360_AST.get())); 13300 } 13301 match(EXPON); 13302 primary(); 13303 if (inputState->guessing==0) { 13304 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13305 } 13306 break; 13307 } 13308 case SEMI: 13309 case COMMA: 13310 case RPAREN: 13311 case RIGHT_SHAFT: 13312 case WITH: 13313 case RANGE: 13314 case DIGITS: 13315 case IS: 13316 case PIPE: 13317 case DOT_DOT: 13318 case IN: 13319 case ASSIGN: 13320 case MOD: 13321 case THEN: 13322 case LOOP: 13323 case OR: 13324 case AND: 13325 case XOR: 13326 case NOT: 13327 case EQ: 13328 case NE: 13329 case LT_: 13330 case LE: 13331 case GT: 13332 case GE: 13333 case PLUS: 13334 case MINUS: 13335 case CONCAT: 13336 case STAR: 13337 case DIV: 13338 case REM: 13339 { 13340 break; 13341 } 13342 default: 13343 { 13344 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13345 } 13346 } 13347 } 13348 break; 13349 } 13350 default: 13351 { 13352 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13353 } 13354 } 13355 } 13356 factor_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13357 } 13358 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13359 if( inputState->guessing == 0 ) { 13360 reportError(ex); 13361 consume(); 13362 consumeUntil(_tokenSet_116); 13363 } else { 13364 throw; 13365 } 13366 } 13367 returnAST = factor_AST; 13368 } 13369 13370 void AdaParser::primary() { 13371 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13372 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13373 RefAdaAST primary_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13374 ANTLR_USE_NAMESPACE(antlr)RefToken cs = ANTLR_USE_NAMESPACE(antlr)nullToken; 13375 RefAdaAST cs_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13376 13377 try { // for error handling 13378 { 13379 switch ( LA(1)) { 13380 case IDENTIFIER: 13381 { 13382 name_or_qualified(); 13383 if (inputState->guessing==0) { 13384 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13385 } 13386 break; 13387 } 13388 case LPAREN: 13389 { 13390 parenthesized_primary(); 13391 if (inputState->guessing==0) { 13392 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13393 } 13394 break; 13395 } 13396 case NEW: 13397 { 13398 allocator(); 13399 if (inputState->guessing==0) { 13400 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13401 } 13402 break; 13403 } 13404 case NuLL: 13405 { 13406 RefAdaAST tmp361_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13407 if ( inputState->guessing == 0 ) { 13408 tmp361_AST = astFactory->create(LT(1)); 13409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp361_AST.get())); 13410 } 13411 match(NuLL); 13412 break; 13413 } 13414 case NUMERIC_LIT: 13415 { 13416 RefAdaAST tmp362_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13417 if ( inputState->guessing == 0 ) { 13418 tmp362_AST = astFactory->create(LT(1)); 13419 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp362_AST.get())); 13420 } 13421 match(NUMERIC_LIT); 13422 break; 13423 } 13424 case CHARACTER_LITERAL: 13425 { 13426 RefAdaAST tmp363_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13427 if ( inputState->guessing == 0 ) { 13428 tmp363_AST = astFactory->create(LT(1)); 13429 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp363_AST.get())); 13430 } 13431 match(CHARACTER_LITERAL); 13432 break; 13433 } 13434 case CHAR_STRING: 13435 { 13436 cs = LT(1); 13437 if ( inputState->guessing == 0 ) { 13438 cs_AST = astFactory->create(cs); 13439 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(cs_AST.get())); 13440 } 13441 match(CHAR_STRING); 13442 { 13443 switch ( LA(1)) { 13444 case LPAREN: 13445 { 13446 operator_call_tail(cs_AST); 13447 if (inputState->guessing==0) { 13448 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13449 } 13450 break; 13451 } 13452 case SEMI: 13453 case COMMA: 13454 case RPAREN: 13455 case RIGHT_SHAFT: 13456 case WITH: 13457 case RANGE: 13458 case DIGITS: 13459 case IS: 13460 case PIPE: 13461 case DOT_DOT: 13462 case IN: 13463 case ASSIGN: 13464 case MOD: 13465 case THEN: 13466 case LOOP: 13467 case OR: 13468 case AND: 13469 case XOR: 13470 case NOT: 13471 case EQ: 13472 case NE: 13473 case LT_: 13474 case LE: 13475 case GT: 13476 case GE: 13477 case PLUS: 13478 case MINUS: 13479 case CONCAT: 13480 case STAR: 13481 case DIV: 13482 case REM: 13483 case EXPON: 13484 { 13485 break; 13486 } 13487 default: 13488 { 13489 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13490 } 13491 } 13492 } 13493 break; 13494 } 13495 default: 13496 { 13497 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13498 } 13499 } 13500 } 13501 primary_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13502 } 13503 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13504 if( inputState->guessing == 0 ) { 13505 reportError(ex); 13506 consume(); 13507 consumeUntil(_tokenSet_117); 13508 } else { 13509 throw; 13510 } 13511 } 13512 returnAST = primary_AST; 13513 } 13514 13515 void AdaParser::name_or_qualified() { 13516 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13517 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13518 RefAdaAST name_or_qualified_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13519 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 13520 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13521 #line 1454 "ada.g" 13522 RefAdaAST dummy; 13523 #line 13524 "AdaParser.cpp" 13524 13525 try { // for error handling 13526 RefAdaAST tmp364_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13527 if ( inputState->guessing == 0 ) { 13528 tmp364_AST = astFactory->create(LT(1)); 13529 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp364_AST.get())); 13530 } 13531 match(IDENTIFIER); 13532 { // ( ... )* 13533 for (;;) { 13534 switch ( LA(1)) { 13535 case DOT: 13536 { 13537 RefAdaAST tmp365_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13538 if ( inputState->guessing == 0 ) { 13539 tmp365_AST = astFactory->create(LT(1)); 13540 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp365_AST.get())); 13541 } 13542 match(DOT); 13543 { 13544 switch ( LA(1)) { 13545 case ALL: 13546 { 13547 RefAdaAST tmp366_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13548 if ( inputState->guessing == 0 ) { 13549 tmp366_AST = astFactory->create(LT(1)); 13550 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp366_AST.get())); 13551 } 13552 match(ALL); 13553 break; 13554 } 13555 case IDENTIFIER: 13556 { 13557 RefAdaAST tmp367_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13558 if ( inputState->guessing == 0 ) { 13559 tmp367_AST = astFactory->create(LT(1)); 13560 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp367_AST.get())); 13561 } 13562 match(IDENTIFIER); 13563 break; 13564 } 13565 case CHARACTER_LITERAL: 13566 { 13567 RefAdaAST tmp368_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13568 if ( inputState->guessing == 0 ) { 13569 tmp368_AST = astFactory->create(LT(1)); 13570 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp368_AST.get())); 13571 } 13572 match(CHARACTER_LITERAL); 13573 break; 13574 } 13575 case CHAR_STRING: 13576 { 13577 dummy=is_operator(); 13578 if (inputState->guessing==0) { 13579 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13580 } 13581 break; 13582 } 13583 default: 13584 { 13585 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13586 } 13587 } 13588 } 13589 break; 13590 } 13591 case LPAREN: 13592 { 13593 p = LT(1); 13594 if ( inputState->guessing == 0 ) { 13595 p_AST = astFactory->create(p); 13596 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 13597 } 13598 match(LPAREN); 13599 value_s(); 13600 if (inputState->guessing==0) { 13601 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13602 } 13603 match(RPAREN); 13604 if ( inputState->guessing==0 ) { 13605 #line 1462 "ada.g" 13606 Set(p_AST, INDEXED_COMPONENT); 13607 #line 13608 "AdaParser.cpp" 13608 } 13609 break; 13610 } 13611 case TIC: 13612 { 13613 RefAdaAST tmp370_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13614 if ( inputState->guessing == 0 ) { 13615 tmp370_AST = astFactory->create(LT(1)); 13616 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp370_AST.get())); 13617 } 13618 match(TIC); 13619 { 13620 switch ( LA(1)) { 13621 case LPAREN: 13622 { 13623 parenthesized_primary(); 13624 if (inputState->guessing==0) { 13625 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13626 } 13627 break; 13628 } 13629 case IDENTIFIER: 13630 case RANGE: 13631 case DIGITS: 13632 case DELTA: 13633 case ACCESS: 13634 { 13635 attribute_id(); 13636 if (inputState->guessing==0) { 13637 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13638 } 13639 break; 13640 } 13641 default: 13642 { 13643 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13644 } 13645 } 13646 } 13647 break; 13648 } 13649 default: 13650 { 13651 goto _loop468; 13652 } 13653 } 13654 } 13655 _loop468:; 13656 } // ( ... )* 13657 name_or_qualified_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13658 } 13659 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13660 if( inputState->guessing == 0 ) { 13661 reportError(ex); 13662 consume(); 13663 consumeUntil(_tokenSet_117); 13664 } else { 13665 throw; 13666 } 13667 } 13668 returnAST = name_or_qualified_AST; 13669 } 13670 13671 void AdaParser::allocator() { 13672 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13673 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13674 RefAdaAST allocator_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13675 ANTLR_USE_NAMESPACE(antlr)RefToken n = ANTLR_USE_NAMESPACE(antlr)nullToken; 13676 RefAdaAST n_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13677 13678 try { // for error handling 13679 n = LT(1); 13680 if ( inputState->guessing == 0 ) { 13681 n_AST = astFactory->create(n); 13682 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get())); 13683 } 13684 match(NEW); 13685 name_or_qualified(); 13686 if (inputState->guessing==0) { 13687 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13688 } 13689 if ( inputState->guessing==0 ) { 13690 #line 1468 "ada.g" 13691 Set(n_AST, ALLOCATOR); 13692 #line 13693 "AdaParser.cpp" 13693 } 13694 allocator_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13695 } 13696 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13697 if( inputState->guessing == 0 ) { 13698 reportError(ex); 13699 consume(); 13700 consumeUntil(_tokenSet_117); 13701 } else { 13702 throw; 13703 } 13704 } 13705 returnAST = allocator_AST; 13706 } 13707 13708 void AdaParser::subprogram_body() { 13709 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13710 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13711 RefAdaAST subprogram_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13712 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 13713 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13714 ANTLR_USE_NAMESPACE(antlr)RefToken f = ANTLR_USE_NAMESPACE(antlr)nullToken; 13715 RefAdaAST f_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13716 13717 try { // for error handling 13718 switch ( LA(1)) { 13719 case PROCEDURE: 13720 { 13721 p = LT(1); 13722 if ( inputState->guessing == 0 ) { 13723 p_AST = astFactory->create(p); 13724 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 13725 } 13726 match(PROCEDURE); 13727 def_id(false); 13728 if (inputState->guessing==0) { 13729 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13730 } 13731 formal_part_opt(); 13732 if (inputState->guessing==0) { 13733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13734 } 13735 match(IS); 13736 body_part(); 13737 if (inputState->guessing==0) { 13738 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13739 } 13740 match(SEMI); 13741 if ( inputState->guessing==0 ) { 13742 #line 1482 "ada.g" 13743 Set(p_AST, PROCEDURE_BODY); 13744 #line 13745 "AdaParser.cpp" 13745 } 13746 subprogram_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13747 break; 13748 } 13749 case FUNCTION: 13750 { 13751 f = LT(1); 13752 if ( inputState->guessing == 0 ) { 13753 f_AST = astFactory->create(f); 13754 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(f_AST.get())); 13755 } 13756 match(FUNCTION); 13757 function_tail(); 13758 if (inputState->guessing==0) { 13759 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13760 } 13761 match(IS); 13762 body_part(); 13763 if (inputState->guessing==0) { 13764 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13765 } 13766 match(SEMI); 13767 if ( inputState->guessing==0 ) { 13768 #line 1484 "ada.g" 13769 Set(f_AST, FUNCTION_BODY); 13770 #line 13771 "AdaParser.cpp" 13771 } 13772 subprogram_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13773 break; 13774 } 13775 default: 13776 { 13777 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename()); 13778 } 13779 } 13780 } 13781 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13782 if( inputState->guessing == 0 ) { 13783 reportError(ex); 13784 consume(); 13785 consumeUntil(_tokenSet_2); 13786 } else { 13787 throw; 13788 } 13789 } 13790 returnAST = subprogram_body_AST; 13791 } 13792 13793 void AdaParser::package_body() { 13794 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13795 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13796 RefAdaAST package_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13797 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 13798 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13799 13800 try { // for error handling 13801 p = LT(1); 13802 if ( inputState->guessing == 0 ) { 13803 p_AST = astFactory->create(p); 13804 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 13805 } 13806 match(PACKAGE); 13807 body_is(); 13808 if (inputState->guessing==0) { 13809 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13810 } 13811 pkg_body_part(); 13812 if (inputState->guessing==0) { 13813 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13814 } 13815 end_id_opt(); 13816 match(SEMI); 13817 if ( inputState->guessing==0 ) { 13818 #line 1488 "ada.g" 13819 Set(p_AST, PACKAGE_BODY); 13820 #line 13821 "AdaParser.cpp" 13821 } 13822 package_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13823 } 13824 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13825 if( inputState->guessing == 0 ) { 13826 reportError(ex); 13827 consume(); 13828 consumeUntil(_tokenSet_2); 13829 } else { 13830 throw; 13831 } 13832 } 13833 returnAST = package_body_AST; 13834 } 13835 13836 void AdaParser::task_body() { 13837 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13838 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13839 RefAdaAST task_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13840 ANTLR_USE_NAMESPACE(antlr)RefToken t = ANTLR_USE_NAMESPACE(antlr)nullToken; 13841 RefAdaAST t_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13842 13843 try { // for error handling 13844 t = LT(1); 13845 if ( inputState->guessing == 0 ) { 13846 t_AST = astFactory->create(t); 13847 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(t_AST.get())); 13848 } 13849 match(TASK); 13850 body_is(); 13851 if (inputState->guessing==0) { 13852 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13853 } 13854 body_part(); 13855 if (inputState->guessing==0) { 13856 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13857 } 13858 match(SEMI); 13859 if ( inputState->guessing==0 ) { 13860 #line 1492 "ada.g" 13861 Set(t_AST, TASK_BODY); 13862 #line 13863 "AdaParser.cpp" 13863 } 13864 task_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13865 } 13866 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13867 if( inputState->guessing == 0 ) { 13868 reportError(ex); 13869 consume(); 13870 consumeUntil(_tokenSet_2); 13871 } else { 13872 throw; 13873 } 13874 } 13875 returnAST = task_body_AST; 13876 } 13877 13878 void AdaParser::protected_body() { 13879 returnAST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13880 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST; 13881 RefAdaAST protected_body_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13882 ANTLR_USE_NAMESPACE(antlr)RefToken p = ANTLR_USE_NAMESPACE(antlr)nullToken; 13883 RefAdaAST p_AST = static_cast<RefAdaAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()); 13884 13885 try { // for error handling 13886 p = LT(1); 13887 if ( inputState->guessing == 0 ) { 13888 p_AST = astFactory->create(p); 13889 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(p_AST.get())); 13890 } 13891 match(PROTECTED); 13892 body_is(); 13893 if (inputState->guessing==0) { 13894 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13895 } 13896 prot_op_bodies_opt(); 13897 if (inputState->guessing==0) { 13898 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get())); 13899 } 13900 end_id_opt(); 13901 match(SEMI); 13902 if ( inputState->guessing==0 ) { 13903 #line 1496 "ada.g" 13904 Set(p_AST, PROTECTED_BODY); 13905 #line 13906 "AdaParser.cpp" 13906 } 13907 protected_body_AST = /*static_cast<RefAdaAST>*/(currentAST.root); 13908 } 13909 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) { 13910 if( inputState->guessing == 0 ) { 13911 reportError(ex); 13912 consume(); 13913 consumeUntil(_tokenSet_2); 13914 } else { 13915 throw; 13916 } 13917 } 13918 returnAST = protected_body_AST; 13919 } 13920 13921 RefAdaAST AdaParser::getAST() 13922 { 13923 return returnAST; 13924 } 13925 13926 void AdaParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory ) 13927 { 13928 factory.setMaxNodeType(303); 13929 } 13930 const char* AdaParser::tokenNames[] = { 13931 "<0>", 13932 "EOF", 13933 "<2>", 13934 "NULL_TREE_LOOKAHEAD", 13935 "\"pragma\"", 13936 "IDENTIFIER", 13937 "SEMI", 13938 "LPAREN", 13939 "COMMA", 13940 "RPAREN", 13941 "RIGHT_SHAFT", 13942 "\"with\"", 13943 "DOT", 13944 "\"use\"", 13945 "\"type\"", 13946 "TIC", 13947 "\"range\"", 13948 "\"digits\"", 13949 "\"delta\"", 13950 "\"access\"", 13951 "\"private\"", 13952 "\"package\"", 13953 "\"body\"", 13954 "\"is\"", 13955 "\"procedure\"", 13956 "\"function\"", 13957 "\"new\"", 13958 "\"others\"", 13959 "PIPE", 13960 "DOT_DOT", 13961 "\"all\"", 13962 "COLON", 13963 "\"in\"", 13964 "\"out\"", 13965 "\"renames\"", 13966 "CHARACTER_LITERAL", 13967 "CHAR_STRING", 13968 "\"null\"", 13969 "\"record\"", 13970 "\"separate\"", 13971 "\"abstract\"", 13972 "\"return\"", 13973 "\"task\"", 13974 "\"protected\"", 13975 "BOX", 13976 "ASSIGN", 13977 "\"entry\"", 13978 "\"for\"", 13979 "\"end\"", 13980 "\"at\"", 13981 "\"mod\"", 13982 "\"subtype\"", 13983 "\"exception\"", 13984 "\"constant\"", 13985 "\"array\"", 13986 "\"of\"", 13987 "\"aliased\"", 13988 "\"case\"", 13989 "\"when\"", 13990 "\"tagged\"", 13991 "\"limited\"", 13992 "\"generic\"", 13993 "\"begin\"", 13994 "LT_LT", 13995 "GT_GT", 13996 "\"if\"", 13997 "\"then\"", 13998 "\"elsif\"", 13999 "\"else\"", 14000 "\"loop\"", 14001 "\"while\"", 14002 "\"reverse\"", 14003 "\"declare\"", 14004 "\"exit\"", 14005 "\"goto\"", 14006 "\"accept\"", 14007 "\"do\"", 14008 "\"delay\"", 14009 "\"until\"", 14010 "\"select\"", 14011 "\"abort\"", 14012 "\"or\"", 14013 "\"terminate\"", 14014 "\"raise\"", 14015 "\"requeue\"", 14016 "\"and\"", 14017 "\"xor\"", 14018 "\"not\"", 14019 "EQ", 14020 "NE", 14021 "LT_", 14022 "LE", 14023 "GT", 14024 "GE", 14025 "PLUS", 14026 "MINUS", 14027 "CONCAT", 14028 "STAR", 14029 "DIV", 14030 "\"rem\"", 14031 "\"abs\"", 14032 "EXPON", 14033 "NUMERIC_LIT", 14034 "ABORTABLE_PART", 14035 "ABORT_STATEMENT", 14036 "ABSTRACT_SUBPROGRAM_DECLARATION", 14037 "ACCEPT_ALTERNATIVE", 14038 "ACCEPT_STATEMENT", 14039 "ALLOCATOR", 14040 "ASSIGNMENT_STATEMENT", 14041 "ASYNCHRONOUS_SELECT", 14042 "ATTRIBUTE_DEFINITION_CLAUSE", 14043 "AT_CLAUSE", 14044 "BLOCK_STATEMENT", 14045 "CASE_STATEMENT", 14046 "CASE_STATEMENT_ALTERNATIVE", 14047 "CODE_STATEMENT", 14048 "COMPONENT_DECLARATION", 14049 "COMPONENT_LIST", 14050 "CONDITION", 14051 "CONDITIONAL_ENTRY_CALL", 14052 "CONTEXT_CLAUSE", 14053 "DECLARATIVE_ITEM", 14054 "DECLARATIVE_PART", 14055 "DEFINING_IDENTIFIER_LIST", 14056 "DELAY_ALTERNATIVE", 14057 "DELAY_STATEMENT", 14058 "DELTA_CONSTRAINT", 14059 "DIGITS_CONSTRAINT", 14060 "DISCRETE_RANGE", 14061 "DISCRIMINANT_ASSOCIATION", 14062 "DISCRIMINANT_CONSTRAINT", 14063 "DISCRIMINANT_SPECIFICATION", 14064 "ENTRY_BODY", 14065 "ENTRY_CALL_ALTERNATIVE", 14066 "ENTRY_CALL_STATEMENT", 14067 "ENTRY_DECLARATION", 14068 "ENTRY_INDEX_SPECIFICATION", 14069 "ENUMERATION_REPESENTATION_CLAUSE", 14070 "EXCEPTION_DECLARATION", 14071 "EXCEPTION_HANDLER", 14072 "EXCEPTION_RENAMING_DECLARATION", 14073 "EXIT_STATEMENT", 14074 "FORMAL_PACKAGE_DECLARATION", 14075 "FORMAL_TYPE_DECLARATION", 14076 "FULL_TYPE_DECLARATION", 14077 "GENERIC_FORMAL_PART", 14078 "GENERIC_INSTANTIATION", 14079 "GENERIC_PACKAGE_DECLARATION", 14080 "GENERIC_RENAMING_DECLARATION", 14081 "GENERIC_SUBPROGRAM_DECLARATION", 14082 "GOTO_STATEMENT", 14083 "HANDLED_SEQUENCE_OF_STATEMENTS", 14084 "IF_STATEMENT", 14085 "INCOMPLETE_TYPE_DECLARATION", 14086 "INDEXED_COMPONENT", 14087 "INDEX_CONSTRAINT", 14088 "LIBRARY_ITEM", 14089 "LOOP_STATEMENT", 14090 "NAME", 14091 "NULL_STATEMENT", 14092 "NUMBER_DECLARATION", 14093 "OBJECT_DECLARATION", 14094 "OBJECT_RENAMING_DECLARATION", 14095 "OPERATOR_SYMBOL", 14096 "PACKAGE_BODY", 14097 "PACKAGE_BODY_STUB", 14098 "PACKAGE_RENAMING_DECLARATION", 14099 "PACKAGE_SPECIFICATION", 14100 "PARAMETER_SPECIFICATION", 14101 "PREFIX", 14102 "PRIMARY", 14103 "PRIVATE_EXTENSION_DECLARATION", 14104 "PRIVATE_TYPE_DECLARATION", 14105 "PROCEDURE_CALL_STATEMENT", 14106 "PROTECTED_BODY", 14107 "PROTECTED_BODY_STUB", 14108 "PROTECTED_TYPE_DECLARATION", 14109 "RAISE_STATEMENT", 14110 "RANGE_ATTRIBUTE_REFERENCE", 14111 "RECORD_REPRESENTATION_CLAUSE", 14112 "REQUEUE_STATEMENT", 14113 "RETURN_STATEMENT", 14114 "SELECTIVE_ACCEPT", 14115 "SELECT_ALTERNATIVE", 14116 "SELECT_STATEMENT", 14117 "SEQUENCE_OF_STATEMENTS", 14118 "SINGLE_PROTECTED_DECLARATION", 14119 "SINGLE_TASK_DECLARATION", 14120 "STATEMENT", 14121 "SUBPROGRAM_BODY", 14122 "SUBPROGRAM_BODY_STUB", 14123 "SUBPROGRAM_DECLARATION", 14124 "SUBPROGRAM_RENAMING_DECLARATION", 14125 "SUBTYPE_DECLARATION", 14126 "SUBTYPE_INDICATION", 14127 "SUBTYPE_MARK", 14128 "SUBUNIT", 14129 "TASK_BODY", 14130 "TASK_BODY_STUB", 14131 "TASK_TYPE_DECLARATION", 14132 "TERMINATE_ALTERNATIVE", 14133 "TIMED_ENTRY_CALL", 14134 "TRIGGERING_ALTERNATIVE", 14135 "TYPE_DECLARATION", 14136 "USE_CLAUSE", 14137 "USE_TYPE_CLAUSE", 14138 "VARIANT", 14139 "VARIANT_PART", 14140 "WITH_CLAUSE", 14141 "ABSTRACT_FUNCTION_DECLARATION", 14142 "ABSTRACT_PROCEDURE_DECLARATION", 14143 "ACCESS_TO_FUNCTION_DECLARATION", 14144 "ACCESS_TO_OBJECT_DECLARATION", 14145 "ACCESS_TO_PROCEDURE_DECLARATION", 14146 "ACCESS_TYPE_DECLARATION", 14147 "ARRAY_OBJECT_DECLARATION", 14148 "ARRAY_TYPE_DECLARATION", 14149 "AND_THEN", 14150 "BASIC_DECLARATIVE_ITEMS_OPT", 14151 "BLOCK_BODY", 14152 "BLOCK_BODY_OPT", 14153 "CALL_STATEMENT", 14154 "COMPONENT_CLAUSES_OPT", 14155 "COMPONENT_ITEMS", 14156 "COND_CLAUSE", 14157 "DECIMAL_FIXED_POINT_DECLARATION", 14158 "DECLARE_OPT", 14159 "DERIVED_RECORD_EXTENSION", 14160 "DERIVED_TYPE_DECLARATION", 14161 "DISCRETE_SUBTYPE_DEF_OPT", 14162 "DISCRIMINANT_SPECIFICATIONS", 14163 "DISCRIM_PART_OPT", 14164 "ELSE_OPT", 14165 "ELSIFS_OPT", 14166 "ENTRY_INDEX_OPT", 14167 "ENUMERATION_TYPE_DECLARATION", 14168 "EXCEPT_HANDLER_PART_OPT", 14169 "EXTENSION_OPT", 14170 "FLOATING_POINT_DECLARATION", 14171 "FORMAL_DECIMAL_FIXED_POINT_DECLARATION", 14172 "FORMAL_DISCRETE_TYPE_DECLARATION", 14173 "FORMAL_FLOATING_POINT_DECLARATION", 14174 "FORMAL_FUNCTION_DECLARATION", 14175 "FORMAL_MODULAR_TYPE_DECLARATION", 14176 "FORMAL_ORDINARY_DERIVED_TYPE_DECLARATION", 14177 "FORMAL_ORDINARY_FIXED_POINT_DECLARATION", 14178 "FORMAL_PART_OPT", 14179 "FORMAL_PRIVATE_EXTENSION_DECLARATION", 14180 "FORMAL_PRIVATE_TYPE_DECLARATION", 14181 "FORMAL_PROCEDURE_DECLARATION", 14182 "FORMAL_SIGNED_INTEGER_TYPE_DECLARATION", 14183 "FUNCTION_BODY", 14184 "FUNCTION_BODY_STUB", 14185 "FUNCTION_DECLARATION", 14186 "FUNCTION_RENAMING_DECLARATION", 14187 "GENERIC_FUNCTION_DECLARATION", 14188 "GENERIC_FUNCTION_INSTANTIATION", 14189 "GENERIC_FUNCTION_RENAMING", 14190 "GENERIC_PACKAGE_INSTANTIATION", 14191 "GENERIC_PACKAGE_RENAMING", 14192 "GENERIC_PROCEDURE_DECLARATION", 14193 "GENERIC_PROCEDURE_INSTANTIATION", 14194 "GENERIC_PROCEDURE_RENAMING", 14195 "GUARD_OPT", 14196 "IDENTIFIER_COLON_OPT", 14197 "INIT_OPT", 14198 "ITERATION_SCHEME_OPT", 14199 "LABEL_OPT", 14200 "MARK_WITH_CONSTRAINT", 14201 "MODIFIERS", 14202 "MODULAR_TYPE_DECLARATION", 14203 "MOD_CLAUSE_OPT", 14204 "NOT_IN", 14205 "ORDINARY_DERIVED_TYPE_DECLARATION", 14206 "ORDINARY_FIXED_POINT_DECLARATION", 14207 "OR_ELSE", 14208 "OR_SELECT_OPT", 14209 "PARENTHESIZED_PRIMARY", 14210 "PRIVATE_TASK_ITEMS_OPT", 14211 "PROCEDURE_BODY", 14212 "PROCEDURE_BODY_STUB", 14213 "PROCEDURE_DECLARATION", 14214 "PROCEDURE_RENAMING_DECLARATION", 14215 "PROT_MEMBER_DECLARATIONS", 14216 "PROT_OP_BODIES_OPT", 14217 "PROT_OP_DECLARATIONS", 14218 "RANGED_EXPRS", 14219 "RECORD_TYPE_DECLARATION", 14220 "SELECTOR_NAMES_OPT", 14221 "SIGNED_INTEGER_TYPE_DECLARATION", 14222 "TASK_ITEMS_OPT", 14223 "UNARY_MINUS", 14224 "UNARY_PLUS", 14225 "VALUE", 14226 "VALUES", 14227 "VARIANTS", 14228 "COMMENT_INTRO", 14229 "DIGIT", 14230 "EXPONENT", 14231 "EXTENDED_DIGIT", 14232 "BASED_INTEGER", 14233 "WS_", 14234 "COMMENT", 14235 0 14236 }; 14237 14238 const unsigned long AdaParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14239 // EOF 14240 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_0(_tokenSet_0_data_,10); 14241 const unsigned long AdaParser::_tokenSet_1_data_[] = { 53477376UL, 536871040UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14242 // "private" "package" "procedure" "function" "separate" "generic" 14243 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_1(_tokenSet_1_data_,10); 14244 const unsigned long AdaParser::_tokenSet_2_data_[] = { 18UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14245 // EOF "pragma" 14246 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_2(_tokenSet_2_data_,10); 14247 const unsigned long AdaParser::_tokenSet_3_data_[] = { 53504050UL, 3860450976UL, 2076542UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14248 // EOF "pragma" IDENTIFIER "with" "use" "type" "private" "package" "procedure" 14249 // "function" "null" "separate" "return" "task" "protected" "entry" "for" 14250 // "end" "subtype" "exception" "case" "when" "generic" "begin" LT_LT "if" 14251 // "then" "elsif" "else" "loop" "while" "declare" "exit" "goto" "accept" 14252 // "delay" "select" "abort" "or" "terminate" "raise" "requeue" 14253 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_3(_tokenSet_3_data_,10); 14254 const unsigned long AdaParser::_tokenSet_4_data_[] = { 64UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14255 // SEMI 14256 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_4(_tokenSet_4_data_,10); 14257 const unsigned long AdaParser::_tokenSet_5_data_[] = { 67109024UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14258 // IDENTIFIER LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "not" PLUS 14259 // MINUS "abs" NUMERIC_LIT 14260 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_5(_tokenSet_5_data_,10); 14261 const unsigned long AdaParser::_tokenSet_6_data_[] = { 201364384UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14262 // IDENTIFIER LPAREN COMMA RPAREN DOT TIC "new" "others" "in" CHARACTER_LITERAL 14263 // CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 14264 // MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 14265 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_6(_tokenSet_6_data_,10); 14266 const unsigned long AdaParser::_tokenSet_7_data_[] = { 768UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14267 // COMMA RPAREN 14268 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_7(_tokenSet_7_data_,10); 14269 const unsigned long AdaParser::_tokenSet_8_data_[] = { 813895488UL, 8192UL, 36UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14270 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 14271 // ASSIGN "then" "loop" 14272 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_8(_tokenSet_8_data_,10); 14273 const unsigned long AdaParser::_tokenSet_9_data_[] = { 53487632UL, 536871040UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14274 // "pragma" "with" "use" "private" "package" "procedure" "function" "separate" 14275 // "generic" 14276 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_9(_tokenSet_9_data_,10); 14277 const unsigned long AdaParser::_tokenSet_10_data_[] = { 53504050UL, 1611238528UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14278 // EOF "pragma" IDENTIFIER "with" "use" "type" "private" "package" "procedure" 14279 // "function" "separate" "task" "protected" "for" "end" "subtype" "generic" 14280 // "begin" 14281 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_10(_tokenSet_10_data_,10); 14282 const unsigned long AdaParser::_tokenSet_11_data_[] = { 814198720UL, 67248645UL, 6426660UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14283 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" "use" TIC "range" "digits" 14284 // "delta" "is" PIPE DOT_DOT "in" "renames" "return" ASSIGN "at" "when" 14285 // "then" "loop" "do" "or" "and" "xor" 14286 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_11(_tokenSet_11_data_,10); 14287 const unsigned long AdaParser::_tokenSet_12_data_[] = { 814165952UL, 139268UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14288 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" "use" "range" "digits" "delta" 14289 // "is" PIPE DOT_DOT "renames" ASSIGN "at" "then" "loop" "or" "and" "xor" 14290 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_12(_tokenSet_12_data_,10); 14291 const unsigned long AdaParser::_tokenSet_13_data_[] = { 814202816UL, 401413UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14292 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT "use" TIC "range" "digits" 14293 // "delta" "is" PIPE DOT_DOT "in" "renames" ASSIGN "at" "mod" "then" "loop" 14294 // "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV 14295 // "rem" EXPON 14296 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_13(_tokenSet_13_data_,10); 14297 const unsigned long AdaParser::_tokenSet_14_data_[] = { 52428800UL, 536870912UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14298 // "package" "procedure" "function" "generic" 14299 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_14(_tokenSet_14_data_,10); 14300 const unsigned long AdaParser::_tokenSet_15_data_[] = { 8388800UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14301 // SEMI LPAREN "is" "renames" 14302 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_15(_tokenSet_15_data_,10); 14303 const unsigned long AdaParser::_tokenSet_16_data_[] = { 52453426UL, 1611238800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14304 // EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" 14305 // CHAR_STRING "separate" "abstract" "task" "protected" "for" "end" "subtype" 14306 // "generic" "begin" 14307 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_16(_tokenSet_16_data_,10); 14308 const unsigned long AdaParser::_tokenSet_17_data_[] = { 52453426UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14309 // EOF "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" 14310 // "task" "protected" "for" "end" "subtype" "generic" "begin" 14311 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_17(_tokenSet_17_data_,10); 14312 const unsigned long AdaParser::_tokenSet_18_data_[] = { 53502002UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14313 // EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 14314 // "function" "task" "protected" "for" "end" "subtype" "generic" "begin" 14315 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_18(_tokenSet_18_data_,10); 14316 const unsigned long AdaParser::_tokenSet_19_data_[] = { 8392896UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14317 // SEMI LPAREN DOT "is" "in" "renames" "when" "do" 14318 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_19(_tokenSet_19_data_,10); 14319 const unsigned long AdaParser::_tokenSet_20_data_[] = { 8388800UL, 67108869UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14320 // SEMI LPAREN "is" "in" "renames" "when" "do" 14321 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_20(_tokenSet_20_data_,10); 14322 const unsigned long AdaParser::_tokenSet_21_data_[] = { 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14323 // "end" 14324 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_21(_tokenSet_21_data_,10); 14325 const unsigned long AdaParser::_tokenSet_22_data_[] = { 53502002UL, 537496976UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14326 // EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 14327 // "function" CHAR_STRING "separate" "abstract" "task" "protected" "for" 14328 // "end" "subtype" "generic" 14329 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_22(_tokenSet_22_data_,10); 14330 const unsigned long AdaParser::_tokenSet_23_data_[] = { 53502002UL, 537496576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14331 // EOF "pragma" IDENTIFIER "use" "type" "private" "package" "procedure" 14332 // "function" "task" "protected" "for" "end" "subtype" "generic" 14333 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_23(_tokenSet_23_data_,10); 14334 const unsigned long AdaParser::_tokenSet_24_data_[] = { 8388672UL, 67108868UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14335 // SEMI "is" "renames" "when" "do" 14336 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_24(_tokenSet_24_data_,10); 14337 const unsigned long AdaParser::_tokenSet_25_data_[] = { 8392832UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14338 // LPAREN DOT "is" "return" 14339 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_25(_tokenSet_25_data_,10); 14340 const unsigned long AdaParser::_tokenSet_26_data_[] = { 8388736UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14341 // LPAREN "is" "return" 14342 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_26(_tokenSet_26_data_,10); 14343 const unsigned long AdaParser::_tokenSet_27_data_[] = { 8388672UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14344 // SEMI "is" "renames" 14345 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_27(_tokenSet_27_data_,10); 14346 const unsigned long AdaParser::_tokenSet_28_data_[] = { 2560UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14347 // RPAREN "with" 14348 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_28(_tokenSet_28_data_,10); 14349 const unsigned long AdaParser::_tokenSet_29_data_[] = { 2816UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14350 // COMMA RPAREN "with" 14351 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_29(_tokenSet_29_data_,10); 14352 const unsigned long AdaParser::_tokenSet_30_data_[] = { 3840UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14353 // COMMA RPAREN RIGHT_SHAFT "with" 14354 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_30(_tokenSet_30_data_,10); 14355 const unsigned long AdaParser::_tokenSet_31_data_[] = { 268439296UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14356 // COMMA RPAREN RIGHT_SHAFT "with" PIPE 14357 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_31(_tokenSet_31_data_,10); 14358 const unsigned long AdaParser::_tokenSet_32_data_[] = { 813895488UL, 8193UL, 1071775780UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14359 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 14360 // "in" ASSIGN "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE GT GE 14361 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_32(_tokenSet_32_data_,10); 14362 const unsigned long AdaParser::_tokenSet_33_data_[] = { 738234528UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14363 // IDENTIFIER LPAREN DOT TIC "new" "others" DOT_DOT CHARACTER_LITERAL CHAR_STRING 14364 // "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 14365 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_33(_tokenSet_33_data_,10); 14366 const unsigned long AdaParser::_tokenSet_34_data_[] = { 813895488UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14367 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 14368 // ASSIGN "then" "loop" "or" "and" "xor" 14369 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_34(_tokenSet_34_data_,10); 14370 const unsigned long AdaParser::_tokenSet_35_data_[] = { 268439360UL, 8192UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14371 // SEMI COMMA RPAREN RIGHT_SHAFT "with" PIPE ASSIGN "loop" 14372 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_35(_tokenSet_35_data_,10); 14373 const unsigned long AdaParser::_tokenSet_36_data_[] = { 32768UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14374 // TIC 14375 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_36(_tokenSet_36_data_,10); 14376 const unsigned long AdaParser::_tokenSet_37_data_[] = { 576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14377 // SEMI RPAREN 14378 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_37(_tokenSet_37_data_,10); 14379 const unsigned long AdaParser::_tokenSet_38_data_[] = { 524320UL, 16777219UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14380 // IDENTIFIER "access" "in" "out" "aliased" 14381 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_38(_tokenSet_38_data_,10); 14382 const unsigned long AdaParser::_tokenSet_39_data_[] = { 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14383 // IDENTIFIER 14384 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_39(_tokenSet_39_data_,10); 14385 const unsigned long AdaParser::_tokenSet_40_data_[] = { 2147484160UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14386 // RPAREN COLON 14387 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_40(_tokenSet_40_data_,10); 14388 const unsigned long AdaParser::_tokenSet_41_data_[] = { 2368UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14389 // SEMI COMMA "with" ASSIGN 14390 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_41(_tokenSet_41_data_,10); 14391 const unsigned long AdaParser::_tokenSet_42_data_[] = { 8388800UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14392 // SEMI LPAREN "is" "return" 14393 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_42(_tokenSet_42_data_,10); 14394 const unsigned long AdaParser::_tokenSet_43_data_[] = { 813932480UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14395 // SEMI LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" 14396 // "is" PIPE DOT_DOT "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" 14397 // EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" EXPON 14398 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_43(_tokenSet_43_data_,10); 14399 const unsigned long AdaParser::_tokenSet_44_data_[] = { 201326752UL, 56UL, 3229614080UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14400 // IDENTIFIER LPAREN "new" "others" CHARACTER_LITERAL CHAR_STRING "null" 14401 // "not" PLUS MINUS "abs" NUMERIC_LIT 14402 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_44(_tokenSet_44_data_,10); 14403 const unsigned long AdaParser::_tokenSet_45_data_[] = { 1006739360UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14404 // IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "new" 14405 // "others" PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" 14406 // "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV 14407 // "rem" "abs" EXPON NUMERIC_LIT 14408 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_45(_tokenSet_45_data_,10); 14409 const unsigned long AdaParser::_tokenSet_46_data_[] = { 1006737312UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14410 // IDENTIFIER LPAREN COMMA RPAREN RIGHT_SHAFT DOT TIC "range" "new" "others" 14411 // PIPE DOT_DOT "in" CHARACTER_LITERAL CHAR_STRING "null" "mod" "or" "and" 14412 // "xor" "not" EQ NE LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" "abs" 14413 // EXPON NUMERIC_LIT 14414 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_46(_tokenSet_46_data_,10); 14415 const unsigned long AdaParser::_tokenSet_47_data_[] = { 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14416 // RPAREN 14417 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_47(_tokenSet_47_data_,10); 14418 const unsigned long AdaParser::_tokenSet_48_data_[] = { 0UL, 512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14419 // "return" 14420 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_48(_tokenSet_48_data_,10); 14421 const unsigned long AdaParser::_tokenSet_49_data_[] = { 1048576UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14422 // "private" "end" 14423 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_49(_tokenSet_49_data_,10); 14424 const unsigned long AdaParser::_tokenSet_50_data_[] = { 32UL, 23068672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14425 // IDENTIFIER "constant" "array" "aliased" 14426 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_50(_tokenSet_50_data_,10); 14427 const unsigned long AdaParser::_tokenSet_51_data_[] = { 495840UL, 6299648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14428 // IDENTIFIER SEMI LPAREN DOT TIC "range" "digits" "delta" ASSIGN "constant" 14429 // "array" 14430 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_51(_tokenSet_51_data_,10); 14431 const unsigned long AdaParser::_tokenSet_52_data_[] = { 8388672UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14432 // SEMI "is" 14433 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_52(_tokenSet_52_data_,10); 14434 const unsigned long AdaParser::_tokenSet_53_data_[] = { 68157504UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14435 // SEMI "private" "new" "null" "record" "abstract" "tagged" "limited" 14436 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_53(_tokenSet_53_data_,10); 14437 const unsigned long AdaParser::_tokenSet_54_data_[] = { 51380272UL, 114688UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14438 // "pragma" IDENTIFIER "private" "procedure" "function" "entry" "for" "end" 14439 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_54(_tokenSet_54_data_,10); 14440 const unsigned long AdaParser::_tokenSet_55_data_[] = { 192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14441 // SEMI LPAREN 14442 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_55(_tokenSet_55_data_,10); 14443 const unsigned long AdaParser::_tokenSet_56_data_[] = { 496256UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14444 // LPAREN RPAREN DOT TIC "range" "digits" "delta" "loop" 14445 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_56(_tokenSet_56_data_,10); 14446 const unsigned long AdaParser::_tokenSet_57_data_[] = { 512UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14447 // RPAREN "loop" 14448 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_57(_tokenSet_57_data_,10); 14449 const unsigned long AdaParser::_tokenSet_58_data_[] = { 2880UL, 8192UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14450 // SEMI COMMA RPAREN "with" ASSIGN "loop" 14451 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_58(_tokenSet_58_data_,10); 14452 const unsigned long AdaParser::_tokenSet_59_data_[] = { 48UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14453 // "pragma" IDENTIFIER "end" 14454 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_59(_tokenSet_59_data_,10); 14455 const unsigned long AdaParser::_tokenSet_60_data_[] = { 50331664UL, 49152UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14456 // "pragma" "procedure" "function" "entry" "for" 14457 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_60(_tokenSet_60_data_,10); 14458 const unsigned long AdaParser::_tokenSet_61_data_[] = { 50331696UL, 100777984UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14459 // "pragma" IDENTIFIER "procedure" "function" "entry" "for" "end" "case" 14460 // "when" 14461 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_61(_tokenSet_61_data_,10); 14462 const unsigned long AdaParser::_tokenSet_62_data_[] = { 64UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14463 // SEMI ASSIGN 14464 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_62(_tokenSet_62_data_,10); 14465 const unsigned long AdaParser::_tokenSet_63_data_[] = { 1048576UL, 402653536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14466 // "private" "null" "record" "abstract" "tagged" "limited" 14467 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_63(_tokenSet_63_data_,10); 14468 const unsigned long AdaParser::_tokenSet_64_data_[] = { 1048688UL, 436207712UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14469 // "pragma" IDENTIFIER SEMI "private" "null" "record" "case" "tagged" "limited" 14470 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_64(_tokenSet_64_data_,10); 14471 const unsigned long AdaParser::_tokenSet_65_data_[] = { 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14472 // "use" 14473 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_65(_tokenSet_65_data_,10); 14474 const unsigned long AdaParser::_tokenSet_66_data_[] = { 32UL, 4194304UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14475 // IDENTIFIER "array" 14476 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_66(_tokenSet_66_data_,10); 14477 const unsigned long AdaParser::_tokenSet_67_data_[] = { 496512UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14478 // LPAREN COMMA RPAREN DOT TIC "range" "digits" "delta" 14479 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_67(_tokenSet_67_data_,10); 14480 const unsigned long AdaParser::_tokenSet_68_data_[] = { 268436480UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14481 // RIGHT_SHAFT PIPE 14482 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_68(_tokenSet_68_data_,10); 14483 const unsigned long AdaParser::_tokenSet_69_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14484 // "procedure" "function" 14485 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_69(_tokenSet_69_data_,10); 14486 const unsigned long AdaParser::_tokenSet_70_data_[] = { 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14487 // "new" 14488 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_70(_tokenSet_70_data_,10); 14489 const unsigned long AdaParser::_tokenSet_71_data_[] = { 1048576UL, 96UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14490 // "private" "null" "record" 14491 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_71(_tokenSet_71_data_,10); 14492 const unsigned long AdaParser::_tokenSet_72_data_[] = { 0UL, 67174400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14493 // "end" "when" 14494 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_72(_tokenSet_72_data_,10); 14495 const unsigned long AdaParser::_tokenSet_73_data_[] = { 0UL, 100728832UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14496 // "end" "case" "when" 14497 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_73(_tokenSet_73_data_,10); 14498 const unsigned long AdaParser::_tokenSet_74_data_[] = { 0UL, 33554432UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14499 // "case" 14500 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_74(_tokenSet_74_data_,10); 14501 const unsigned long AdaParser::_tokenSet_75_data_[] = { 8388608UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14502 // "is" 14503 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_75(_tokenSet_75_data_,10); 14504 const unsigned long AdaParser::_tokenSet_76_data_[] = { 1024UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14505 // RIGHT_SHAFT 14506 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_76(_tokenSet_76_data_,10); 14507 const unsigned long AdaParser::_tokenSet_77_data_[] = { 738300064UL, 262200UL, 3229614080UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14508 // IDENTIFIER LPAREN DOT TIC "range" "new" "others" DOT_DOT CHARACTER_LITERAL 14509 // CHAR_STRING "null" "mod" "not" PLUS MINUS CONCAT STAR DIV "rem" "abs" 14510 // EXPON NUMERIC_LIT 14511 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_77(_tokenSet_77_data_,10); 14512 const unsigned long AdaParser::_tokenSet_78_data_[] = { 469800096UL, 262201UL, 4293001216UL, 127UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14513 // IDENTIFIER LPAREN RIGHT_SHAFT DOT TIC "new" "others" PIPE "in" CHARACTER_LITERAL 14514 // CHAR_STRING "null" "mod" "or" "and" "xor" "not" EQ NE LT_ LE GT GE PLUS 14515 // MINUS CONCAT STAR DIV "rem" "abs" EXPON NUMERIC_LIT 14516 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_78(_tokenSet_78_data_,10); 14517 const unsigned long AdaParser::_tokenSet_79_data_[] = { 52428800UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14518 // "package" "procedure" "function" 14519 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_79(_tokenSet_79_data_,10); 14520 const unsigned long AdaParser::_tokenSet_80_data_[] = { 52455472UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14521 // "pragma" IDENTIFIER "with" "use" "type" "package" "procedure" "function" 14522 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_80(_tokenSet_80_data_,10); 14523 const unsigned long AdaParser::_tokenSet_81_data_[] = { 1048576UL, 402653440UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14524 // "private" "abstract" "tagged" "limited" 14525 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_81(_tokenSet_81_data_,10); 14526 const unsigned long AdaParser::_tokenSet_82_data_[] = { 1048640UL, 402653184UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14527 // SEMI "private" "tagged" "limited" 14528 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_82(_tokenSet_82_data_,10); 14529 const unsigned long AdaParser::_tokenSet_83_data_[] = { 0UL, 1073807360UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14530 // "end" "begin" 14531 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_83(_tokenSet_83_data_,10); 14532 const unsigned long AdaParser::_tokenSet_84_data_[] = { 52453424UL, 1611238400UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14533 // "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" "task" 14534 // "protected" "for" "end" "subtype" "generic" "begin" 14535 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_84(_tokenSet_84_data_,10); 14536 const unsigned long AdaParser::_tokenSet_85_data_[] = { 52453424UL, 1611254912UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14537 // "pragma" IDENTIFIER "use" "type" "package" "procedure" "function" "separate" 14538 // "task" "protected" "entry" "for" "end" "subtype" "generic" "begin" 14539 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_85(_tokenSet_85_data_,10); 14540 const unsigned long AdaParser::_tokenSet_86_data_[] = { 50331664UL, 81920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14541 // "pragma" "procedure" "function" "entry" "end" 14542 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_86(_tokenSet_86_data_,10); 14543 const unsigned long AdaParser::_tokenSet_87_data_[] = { 0UL, 68222976UL, 24UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14544 // "end" "exception" "when" "elsif" "else" 14545 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_87(_tokenSet_87_data_,10); 14546 const unsigned long AdaParser::_tokenSet_88_data_[] = { 37056UL, 8192UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14547 // SEMI LPAREN DOT TIC ASSIGN 14548 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_88(_tokenSet_88_data_,10); 14549 const unsigned long AdaParser::_tokenSet_89_data_[] = { 48UL, 3323036192UL, 1814398UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14550 // "pragma" IDENTIFIER "null" "return" "for" "end" "exception" "case" "when" 14551 // "begin" LT_LT "if" "then" "elsif" "else" "loop" "while" "declare" "exit" 14552 // "goto" "accept" "delay" "select" "abort" "or" "raise" "requeue" 14553 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_89(_tokenSet_89_data_,10); 14554 const unsigned long AdaParser::_tokenSet_90_data_[] = { 32UL, 1107329568UL, 1683298UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14555 // IDENTIFIER "null" "return" "for" "case" "begin" "if" "loop" "while" 14556 // "declare" "exit" "goto" "accept" "delay" "select" "abort" "raise" "requeue" 14557 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_90(_tokenSet_90_data_,10); 14558 const unsigned long AdaParser::_tokenSet_91_data_[] = { 67145952UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14559 // IDENTIFIER SEMI LPAREN DOT TIC "new" CHARACTER_LITERAL CHAR_STRING "null" 14560 // "until" "not" PLUS MINUS "abs" NUMERIC_LIT 14561 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_91(_tokenSet_91_data_,10); 14562 const unsigned long AdaParser::_tokenSet_92_data_[] = { 0UL, 67108864UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14563 // "when" "accept" "delay" "terminate" 14564 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_92(_tokenSet_92_data_,10); 14565 const unsigned long AdaParser::_tokenSet_93_data_[] = { 67109088UL, 56UL, 3229630464UL, 80UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14566 // IDENTIFIER SEMI LPAREN "new" CHARACTER_LITERAL CHAR_STRING "null" "until" 14567 // "not" PLUS MINUS "abs" NUMERIC_LIT 14568 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_93(_tokenSet_93_data_,10); 14569 const unsigned long AdaParser::_tokenSet_94_data_[] = { 37056UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14570 // SEMI LPAREN DOT TIC 14571 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_94(_tokenSet_94_data_,10); 14572 const unsigned long AdaParser::_tokenSet_95_data_[] = { 96UL, 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14573 // IDENTIFIER SEMI CHAR_STRING 14574 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_95(_tokenSet_95_data_,10); 14575 const unsigned long AdaParser::_tokenSet_96_data_[] = { 0UL, 1073774592UL, 352UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14576 // "for" "begin" "loop" "while" "declare" 14577 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_96(_tokenSet_96_data_,10); 14578 const unsigned long AdaParser::_tokenSet_97_data_[] = { 0UL, 65536UL, 24UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14579 // "end" "elsif" "else" 14580 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_97(_tokenSet_97_data_,10); 14581 const unsigned long AdaParser::_tokenSet_98_data_[] = { 0UL, 65536UL, 16UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14582 // "end" "else" 14583 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_98(_tokenSet_98_data_,10); 14584 const unsigned long AdaParser::_tokenSet_99_data_[] = { 8389696UL, 0UL, 36UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14585 // SEMI RIGHT_SHAFT "is" "then" "loop" 14586 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_99(_tokenSet_99_data_,10); 14587 const unsigned long AdaParser::_tokenSet_100_data_[] = { 0UL, 0UL, 32UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14588 // "loop" 14589 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_100(_tokenSet_100_data_,10); 14590 const unsigned long AdaParser::_tokenSet_101_data_[] = { 0UL, 1073741824UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14591 // "begin" 14592 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_101(_tokenSet_101_data_,10); 14593 const unsigned long AdaParser::_tokenSet_102_data_[] = { 64UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14594 // SEMI "when" 14595 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_102(_tokenSet_102_data_,10); 14596 const unsigned long AdaParser::_tokenSet_103_data_[] = { 0UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14597 // "when" 14598 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_103(_tokenSet_103_data_,10); 14599 const unsigned long AdaParser::_tokenSet_104_data_[] = { 128UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14600 // LPAREN "when" 14601 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_104(_tokenSet_104_data_,10); 14602 const unsigned long AdaParser::_tokenSet_105_data_[] = { 48UL, 3254813216UL, 1814390UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14603 // "pragma" IDENTIFIER "null" "return" "for" "case" "begin" LT_LT "if" 14604 // "then" "else" "loop" "while" "declare" "exit" "goto" "accept" "delay" 14605 // "select" "abort" "or" "raise" "requeue" 14606 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_105(_tokenSet_105_data_,10); 14607 const unsigned long AdaParser::_tokenSet_106_data_[] = { 192UL, 0UL, 4096UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14608 // SEMI LPAREN "do" 14609 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_106(_tokenSet_106_data_,10); 14610 const unsigned long AdaParser::_tokenSet_107_data_[] = { 0UL, 0UL, 4UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14611 // "then" 14612 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_107(_tokenSet_107_data_,10); 14613 const unsigned long AdaParser::_tokenSet_108_data_[] = { 0UL, 0UL, 131088UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14614 // "else" "or" 14615 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_108(_tokenSet_108_data_,10); 14616 const unsigned long AdaParser::_tokenSet_109_data_[] = { 0UL, 65536UL, 131088UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14617 // "end" "else" "or" 14618 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_109(_tokenSet_109_data_,10); 14619 const unsigned long AdaParser::_tokenSet_110_data_[] = { 0UL, 65536UL, 131092UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14620 // "end" "then" "else" "or" 14621 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_110(_tokenSet_110_data_,10); 14622 const unsigned long AdaParser::_tokenSet_111_data_[] = { 0UL, 0UL, 272384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14623 // "accept" "delay" "terminate" 14624 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_111(_tokenSet_111_data_,10); 14625 const unsigned long AdaParser::_tokenSet_112_data_[] = { 134217760UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14626 // IDENTIFIER "others" 14627 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_112(_tokenSet_112_data_,10); 14628 const unsigned long AdaParser::_tokenSet_113_data_[] = { 813895490UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14629 // EOF SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE 14630 // DOT_DOT "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" EQ NE 14631 // LT_ LE GT GE PLUS MINUS CONCAT STAR DIV "rem" EXPON 14632 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_113(_tokenSet_113_data_,10); 14633 const unsigned long AdaParser::_tokenSet_114_data_[] = { 813932352UL, 8192UL, 6422564UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14634 // SEMI COMMA RPAREN RIGHT_SHAFT "with" DOT TIC "range" "digits" "is" PIPE 14635 // DOT_DOT ASSIGN "then" "loop" "or" "and" "xor" 14636 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_114(_tokenSet_114_data_,10); 14637 const unsigned long AdaParser::_tokenSet_115_data_[] = { 813895488UL, 8193UL, 4293001252UL, 1UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14638 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 14639 // "in" ASSIGN "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE GT GE 14640 // PLUS MINUS CONCAT 14641 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_115(_tokenSet_115_data_,10); 14642 const unsigned long AdaParser::_tokenSet_116_data_[] = { 813895488UL, 270337UL, 4293001252UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14643 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 14644 // "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE 14645 // GT GE PLUS MINUS CONCAT STAR DIV "rem" 14646 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_116(_tokenSet_116_data_,10); 14647 const unsigned long AdaParser::_tokenSet_117_data_[] = { 813895488UL, 270337UL, 4293001252UL, 47UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL }; 14648 // SEMI COMMA RPAREN RIGHT_SHAFT "with" "range" "digits" "is" PIPE DOT_DOT 14649 // "in" ASSIGN "mod" "then" "loop" "or" "and" "xor" "not" EQ NE LT_ LE 14650 // GT GE PLUS MINUS CONCAT STAR DIV "rem" EXPON 14651 const ANTLR_USE_NAMESPACE(antlr)BitSet AdaParser::_tokenSet_117(_tokenSet_117_data_,10); 14652 14653
KDE Logo
This file is part of the documentation for KDevelop Version 3.0.4.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Oct 6 17:38:57 2004 by doxygen 1.3.7 written by Dimitri van Heesch, © 1997-2003