00001
00002 #include "PascalParser.hpp"
00003 #include <antlr/NoViableAltException.hpp>
00004 #include <antlr/SemanticException.hpp>
00005 #include <antlr/ASTFactory.hpp>
00006 #line 1 "pascal.g"
00007 #line 8 "PascalParser.cpp"
00008 PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
00009 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
00010 {
00011 }
00012
00013 PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
00014 : ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
00015 {
00016 }
00017
00018 PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
00019 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
00020 {
00021 }
00022
00023 PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
00024 : ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
00025 {
00026 }
00027
00028 PascalParser::PascalParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
00029 : ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
00030 {
00031 }
00032
00033 void PascalParser::compilationUnit() {
00034 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00035 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00036 RefPascalAST compilationUnit_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00037
00038 try {
00039 switch ( LA(1)) {
00040 case PROGRAM:
00041 {
00042 program();
00043 if (inputState->guessing==0) {
00044 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00045 }
00046 compilationUnit_AST = (currentAST.root);
00047 break;
00048 }
00049 case LIBRARY:
00050 {
00051 library();
00052 if (inputState->guessing==0) {
00053 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00054 }
00055 compilationUnit_AST = (currentAST.root);
00056 break;
00057 }
00058 case UNIT:
00059 {
00060 unit();
00061 if (inputState->guessing==0) {
00062 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00063 }
00064 compilationUnit_AST = (currentAST.root);
00065 break;
00066 }
00067 default:
00068 {
00069 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00070 }
00071 }
00072 }
00073 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00074 if( inputState->guessing == 0 ) {
00075 reportError(ex);
00076 consume();
00077 consumeUntil(_tokenSet_0);
00078 } else {
00079 throw;
00080 }
00081 }
00082 returnAST = compilationUnit_AST;
00083 }
00084
00085 void PascalParser::program() {
00086 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00087 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00088 RefPascalAST program_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00089
00090 try {
00091 programHeading();
00092 if (inputState->guessing==0) {
00093 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00094 }
00095 {
00096 switch ( LA(1)) {
00097 case USES:
00098 {
00099 usesClause();
00100 if (inputState->guessing==0) {
00101 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00102 }
00103 break;
00104 }
00105 case BEGIN:
00106 case LABEL:
00107 case CONST:
00108 case RESOURCESTRING:
00109 case TYPE:
00110 case VAR:
00111 case PROCEDURE:
00112 case FUNCTION:
00113 case CONSTRUCTOR:
00114 case DESTRUCTOR:
00115 {
00116 break;
00117 }
00118 default:
00119 {
00120 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00121 }
00122 }
00123 }
00124 block();
00125 if (inputState->guessing==0) {
00126 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00127 }
00128 match(DOT);
00129 program_AST = (currentAST.root);
00130 }
00131 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00132 if( inputState->guessing == 0 ) {
00133 reportError(ex);
00134 consume();
00135 consumeUntil(_tokenSet_0);
00136 } else {
00137 throw;
00138 }
00139 }
00140 returnAST = program_AST;
00141 }
00142
00143 void PascalParser::library() {
00144 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00145 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00146 RefPascalAST library_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00147
00148 try {
00149 RefPascalAST tmp2_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00150 if ( inputState->guessing == 0 ) {
00151 tmp2_AST = astFactory->create(LT(1));
00152 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp2_AST.get()));
00153 }
00154 match(LIBRARY);
00155 identifier();
00156 if (inputState->guessing==0) {
00157 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00158 }
00159 match(SEMI);
00160 {
00161 switch ( LA(1)) {
00162 case USES:
00163 {
00164 usesClause();
00165 if (inputState->guessing==0) {
00166 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00167 }
00168 break;
00169 }
00170 case EXPORTS:
00171 case BEGIN:
00172 case LABEL:
00173 case CONST:
00174 case RESOURCESTRING:
00175 case TYPE:
00176 case VAR:
00177 case PROCEDURE:
00178 case FUNCTION:
00179 case CONSTRUCTOR:
00180 case DESTRUCTOR:
00181 {
00182 break;
00183 }
00184 default:
00185 {
00186 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00187 }
00188 }
00189 }
00190 libraryBlock();
00191 if (inputState->guessing==0) {
00192 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00193 }
00194 exportsClause();
00195 if (inputState->guessing==0) {
00196 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00197 }
00198 match(END);
00199 match(DOT);
00200 library_AST = (currentAST.root);
00201 }
00202 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00203 if( inputState->guessing == 0 ) {
00204 reportError(ex);
00205 consume();
00206 consumeUntil(_tokenSet_0);
00207 } else {
00208 throw;
00209 }
00210 }
00211 returnAST = library_AST;
00212 }
00213
00214 void PascalParser::unit() {
00215 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00216 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00217 RefPascalAST unit_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00218
00219 try {
00220 RefPascalAST tmp6_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00221 if ( inputState->guessing == 0 ) {
00222 tmp6_AST = astFactory->create(LT(1));
00223 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp6_AST.get()));
00224 }
00225 match(UNIT);
00226 identifier();
00227 if (inputState->guessing==0) {
00228 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00229 }
00230 match(SEMI);
00231 interfacePart();
00232 if (inputState->guessing==0) {
00233 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00234 }
00235 implementationPart();
00236 if (inputState->guessing==0) {
00237 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00238 }
00239 {
00240 switch ( LA(1)) {
00241 case INITIALIZATION:
00242 {
00243 {
00244 initializationPart();
00245 if (inputState->guessing==0) {
00246 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00247 }
00248 {
00249 switch ( LA(1)) {
00250 case FINALIZATION:
00251 {
00252 finalizationPart();
00253 if (inputState->guessing==0) {
00254 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00255 }
00256 break;
00257 }
00258 case END:
00259 {
00260 break;
00261 }
00262 default:
00263 {
00264 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00265 }
00266 }
00267 }
00268 }
00269 break;
00270 }
00271 case BEGIN:
00272 {
00273 realizationPart();
00274 if (inputState->guessing==0) {
00275 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00276 }
00277 break;
00278 }
00279 case END:
00280 {
00281 break;
00282 }
00283 default:
00284 {
00285 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00286 }
00287 }
00288 }
00289 match(END);
00290 unit_AST = (currentAST.root);
00291 }
00292 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00293 if( inputState->guessing == 0 ) {
00294 reportError(ex);
00295 consume();
00296 consumeUntil(_tokenSet_0);
00297 } else {
00298 throw;
00299 }
00300 }
00301 returnAST = unit_AST;
00302 }
00303
00304 void PascalParser::programHeading() {
00305 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00306 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00307 RefPascalAST programHeading_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00308
00309 try {
00310 RefPascalAST tmp9_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00311 if ( inputState->guessing == 0 ) {
00312 tmp9_AST = astFactory->create(LT(1));
00313 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp9_AST.get()));
00314 }
00315 match(PROGRAM);
00316 identifier();
00317 if (inputState->guessing==0) {
00318 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00319 }
00320 {
00321 switch ( LA(1)) {
00322 case LPAREN:
00323 {
00324 match(LPAREN);
00325 identifierList();
00326 if (inputState->guessing==0) {
00327 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00328 }
00329 match(RPAREN);
00330 break;
00331 }
00332 case SEMI:
00333 {
00334 break;
00335 }
00336 default:
00337 {
00338 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00339 }
00340 }
00341 }
00342 match(SEMI);
00343 programHeading_AST = (currentAST.root);
00344 }
00345 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00346 if( inputState->guessing == 0 ) {
00347 reportError(ex);
00348 consume();
00349 consumeUntil(_tokenSet_1);
00350 } else {
00351 throw;
00352 }
00353 }
00354 returnAST = programHeading_AST;
00355 }
00356
00357 void PascalParser::usesClause() {
00358 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00359 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00360 RefPascalAST usesClause_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00361
00362 try {
00363 RefPascalAST tmp13_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00364 if ( inputState->guessing == 0 ) {
00365 tmp13_AST = astFactory->create(LT(1));
00366 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp13_AST.get()));
00367 }
00368 match(USES);
00369 identifierList();
00370 if (inputState->guessing==0) {
00371 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00372 }
00373 match(SEMI);
00374 usesClause_AST = (currentAST.root);
00375 }
00376 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00377 if( inputState->guessing == 0 ) {
00378 reportError(ex);
00379 consume();
00380 consumeUntil(_tokenSet_2);
00381 } else {
00382 throw;
00383 }
00384 }
00385 returnAST = usesClause_AST;
00386 }
00387
00388 void PascalParser::block() {
00389 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00390 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00391 RefPascalAST block_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00392
00393 try {
00394 declarationPart();
00395 if (inputState->guessing==0) {
00396 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00397 }
00398 statementPart();
00399 if (inputState->guessing==0) {
00400 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00401 }
00402 block_AST = (currentAST.root);
00403 }
00404 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00405 if( inputState->guessing == 0 ) {
00406 reportError(ex);
00407 consume();
00408 consumeUntil(_tokenSet_3);
00409 } else {
00410 throw;
00411 }
00412 }
00413 returnAST = block_AST;
00414 }
00415
00416 void PascalParser::identifier() {
00417 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00418 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00419 RefPascalAST identifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00420
00421 try {
00422 RefPascalAST tmp15_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00423 if ( inputState->guessing == 0 ) {
00424 tmp15_AST = astFactory->create(LT(1));
00425 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp15_AST.get()));
00426 }
00427 match(IDENT);
00428 identifier_AST = (currentAST.root);
00429 }
00430 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00431 if( inputState->guessing == 0 ) {
00432 reportError(ex);
00433 consume();
00434 consumeUntil(_tokenSet_4);
00435 } else {
00436 throw;
00437 }
00438 }
00439 returnAST = identifier_AST;
00440 }
00441
00442 void PascalParser::libraryBlock() {
00443 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00444 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00445 RefPascalAST libraryBlock_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00446
00447 try {
00448 declarationPart();
00449 if (inputState->guessing==0) {
00450 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00451 }
00452 {
00453 switch ( LA(1)) {
00454 case BEGIN:
00455 {
00456 statementPart();
00457 if (inputState->guessing==0) {
00458 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00459 }
00460 break;
00461 }
00462 case EXPORTS:
00463 {
00464 break;
00465 }
00466 default:
00467 {
00468 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00469 }
00470 }
00471 }
00472 libraryBlock_AST = (currentAST.root);
00473 }
00474 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00475 if( inputState->guessing == 0 ) {
00476 reportError(ex);
00477 consume();
00478 consumeUntil(_tokenSet_5);
00479 } else {
00480 throw;
00481 }
00482 }
00483 returnAST = libraryBlock_AST;
00484 }
00485
00486 void PascalParser::exportsClause() {
00487 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00488 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00489 RefPascalAST exportsClause_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00490
00491 try {
00492 RefPascalAST tmp16_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00493 if ( inputState->guessing == 0 ) {
00494 tmp16_AST = astFactory->create(LT(1));
00495 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp16_AST.get()));
00496 }
00497 match(EXPORTS);
00498 exportsList();
00499 if (inputState->guessing==0) {
00500 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00501 }
00502 exportsClause_AST = (currentAST.root);
00503 }
00504 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00505 if( inputState->guessing == 0 ) {
00506 reportError(ex);
00507 consume();
00508 consumeUntil(_tokenSet_6);
00509 } else {
00510 throw;
00511 }
00512 }
00513 returnAST = exportsClause_AST;
00514 }
00515
00516 void PascalParser::declarationPart() {
00517 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00518 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00519 RefPascalAST declarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00520
00521 try {
00522 {
00523 for (;;) {
00524 switch ( LA(1)) {
00525 case LABEL:
00526 {
00527 labelDeclarationPart();
00528 if (inputState->guessing==0) {
00529 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00530 }
00531 break;
00532 }
00533 case CONST:
00534 {
00535 constantDeclarationPart();
00536 if (inputState->guessing==0) {
00537 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00538 }
00539 break;
00540 }
00541 case RESOURCESTRING:
00542 {
00543 resourcestringDeclarationPart();
00544 if (inputState->guessing==0) {
00545 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00546 }
00547 break;
00548 }
00549 case TYPE:
00550 {
00551 typeDeclarationPart();
00552 if (inputState->guessing==0) {
00553 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00554 }
00555 break;
00556 }
00557 case VAR:
00558 {
00559 variableDeclarationPart();
00560 if (inputState->guessing==0) {
00561 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00562 }
00563 break;
00564 }
00565 case PROCEDURE:
00566 case FUNCTION:
00567 case CONSTRUCTOR:
00568 case DESTRUCTOR:
00569 {
00570 procedureAndFunctionDeclarationPart();
00571 if (inputState->guessing==0) {
00572 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00573 }
00574 break;
00575 }
00576 default:
00577 {
00578 goto _loop41;
00579 }
00580 }
00581 }
00582 _loop41:;
00583 }
00584 declarationPart_AST = (currentAST.root);
00585 }
00586 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00587 if( inputState->guessing == 0 ) {
00588 reportError(ex);
00589 consume();
00590 consumeUntil(_tokenSet_7);
00591 } else {
00592 throw;
00593 }
00594 }
00595 returnAST = declarationPart_AST;
00596 }
00597
00598 void PascalParser::statementPart() {
00599 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00600 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00601 RefPascalAST statementPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00602
00603 try {
00604 compoundStatement();
00605 if (inputState->guessing==0) {
00606 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00607 }
00608 statementPart_AST = (currentAST.root);
00609 }
00610 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00611 if( inputState->guessing == 0 ) {
00612 reportError(ex);
00613 consume();
00614 consumeUntil(_tokenSet_3);
00615 } else {
00616 throw;
00617 }
00618 }
00619 returnAST = statementPart_AST;
00620 }
00621
00622 void PascalParser::exportsList() {
00623 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00624 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00625 RefPascalAST exportsList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00626
00627 try {
00628 exportsEntry();
00629 if (inputState->guessing==0) {
00630 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00631 }
00632 {
00633 for (;;) {
00634 if ((LA(1) == COMMA)) {
00635 match(COMMA);
00636 exportsEntry();
00637 if (inputState->guessing==0) {
00638 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00639 }
00640 }
00641 else {
00642 goto _loop11;
00643 }
00644
00645 }
00646 _loop11:;
00647 }
00648 {
00649 switch ( LA(1)) {
00650 case SEMI:
00651 {
00652 match(SEMI);
00653 break;
00654 }
00655 case END:
00656 {
00657 break;
00658 }
00659 default:
00660 {
00661 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00662 }
00663 }
00664 }
00665 exportsList_AST = (currentAST.root);
00666 }
00667 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00668 if( inputState->guessing == 0 ) {
00669 reportError(ex);
00670 consume();
00671 consumeUntil(_tokenSet_6);
00672 } else {
00673 throw;
00674 }
00675 }
00676 returnAST = exportsList_AST;
00677 }
00678
00679 void PascalParser::exportsEntry() {
00680 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00681 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00682 RefPascalAST exportsEntry_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00683
00684 try {
00685 identifier();
00686 if (inputState->guessing==0) {
00687 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00688 }
00689 {
00690 switch ( LA(1)) {
00691 case LITERAL_index:
00692 {
00693 RefPascalAST tmp19_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00694 if ( inputState->guessing == 0 ) {
00695 tmp19_AST = astFactory->create(LT(1));
00696 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp19_AST.get()));
00697 }
00698 match(LITERAL_index);
00699 integerConstant();
00700 if (inputState->guessing==0) {
00701 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00702 }
00703 break;
00704 }
00705 case SEMI:
00706 case END:
00707 case COMMA:
00708 case LITERAL_name:
00709 {
00710 break;
00711 }
00712 default:
00713 {
00714 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00715 }
00716 }
00717 }
00718 {
00719 switch ( LA(1)) {
00720 case LITERAL_name:
00721 {
00722 RefPascalAST tmp20_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00723 if ( inputState->guessing == 0 ) {
00724 tmp20_AST = astFactory->create(LT(1));
00725 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp20_AST.get()));
00726 }
00727 match(LITERAL_name);
00728 stringConstant();
00729 if (inputState->guessing==0) {
00730 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00731 }
00732 break;
00733 }
00734 case SEMI:
00735 case END:
00736 case COMMA:
00737 {
00738 break;
00739 }
00740 default:
00741 {
00742 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00743 }
00744 }
00745 }
00746 exportsEntry_AST = (currentAST.root);
00747 }
00748 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00749 if( inputState->guessing == 0 ) {
00750 reportError(ex);
00751 consume();
00752 consumeUntil(_tokenSet_8);
00753 } else {
00754 throw;
00755 }
00756 }
00757 returnAST = exportsEntry_AST;
00758 }
00759
00760 void PascalParser::integerConstant() {
00761 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00762 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00763 RefPascalAST integerConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00764 RefPascalAST s_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00765 RefPascalAST n_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00766
00767 try {
00768 switch ( LA(1)) {
00769 case NUM_INT:
00770 {
00771 unsignedInteger();
00772 if (inputState->guessing==0) {
00773 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00774 }
00775 integerConstant_AST = (currentAST.root);
00776 break;
00777 }
00778 case PLUS:
00779 case MINUS:
00780 {
00781 sign();
00782 if (inputState->guessing==0) {
00783 s_AST = returnAST;
00784 }
00785 unsignedInteger();
00786 if (inputState->guessing==0) {
00787 n_AST = returnAST;
00788 }
00789 if ( inputState->guessing==0 ) {
00790 integerConstant_AST = RefPascalAST(currentAST.root);
00791 #line 880 "pascal.g"
00792 integerConstant_AST=RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()))));
00793 #line 794 "PascalParser.cpp"
00794 currentAST.root = integerConstant_AST;
00795 if ( integerConstant_AST!=static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
00796 integerConstant_AST->getFirstChild() != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00797 currentAST.child = integerConstant_AST->getFirstChild();
00798 else
00799 currentAST.child = integerConstant_AST;
00800 currentAST.advanceChildToEnd();
00801 }
00802 break;
00803 }
00804 default:
00805 {
00806 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00807 }
00808 }
00809 }
00810 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00811 if( inputState->guessing == 0 ) {
00812 reportError(ex);
00813 consume();
00814 consumeUntil(_tokenSet_9);
00815 } else {
00816 throw;
00817 }
00818 }
00819 returnAST = integerConstant_AST;
00820 }
00821
00822 void PascalParser::stringConstant() {
00823 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00824 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00825 RefPascalAST stringConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00826
00827 try {
00828 switch ( LA(1)) {
00829 case STRING_LITERAL:
00830 {
00831 string();
00832 if (inputState->guessing==0) {
00833 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00834 }
00835 stringConstant_AST = (currentAST.root);
00836 break;
00837 }
00838 case CHR:
00839 {
00840 constantChr();
00841 if (inputState->guessing==0) {
00842 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00843 }
00844 stringConstant_AST = (currentAST.root);
00845 break;
00846 }
00847 default:
00848 {
00849 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00850 }
00851 }
00852 }
00853 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00854 if( inputState->guessing == 0 ) {
00855 reportError(ex);
00856 consume();
00857 consumeUntil(_tokenSet_10);
00858 } else {
00859 throw;
00860 }
00861 }
00862 returnAST = stringConstant_AST;
00863 }
00864
00865 void PascalParser::identifierList() {
00866 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00867 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00868 RefPascalAST identifierList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00869
00870 try {
00871 identifier();
00872 if (inputState->guessing==0) {
00873 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00874 }
00875 {
00876 for (;;) {
00877 if ((LA(1) == COMMA)) {
00878 match(COMMA);
00879 identifier();
00880 if (inputState->guessing==0) {
00881 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00882 }
00883 }
00884 else {
00885 goto _loop378;
00886 }
00887
00888 }
00889 _loop378:;
00890 }
00891 if ( inputState->guessing==0 ) {
00892 identifierList_AST = RefPascalAST(currentAST.root);
00893 #line 867 "pascal.g"
00894 identifierList_AST = RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(IDLIST).get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(identifierList_AST.get()))));
00895 #line 896 "PascalParser.cpp"
00896 currentAST.root = identifierList_AST;
00897 if ( identifierList_AST!=static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
00898 identifierList_AST->getFirstChild() != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00899 currentAST.child = identifierList_AST->getFirstChild();
00900 else
00901 currentAST.child = identifierList_AST;
00902 currentAST.advanceChildToEnd();
00903 }
00904 identifierList_AST = (currentAST.root);
00905 }
00906 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00907 if( inputState->guessing == 0 ) {
00908 reportError(ex);
00909 consume();
00910 consumeUntil(_tokenSet_11);
00911 } else {
00912 throw;
00913 }
00914 }
00915 returnAST = identifierList_AST;
00916 }
00917
00918 void PascalParser::interfacePart() {
00919 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00920 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
00921 RefPascalAST interfacePart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00922
00923 try {
00924 RefPascalAST tmp22_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
00925 if ( inputState->guessing == 0 ) {
00926 tmp22_AST = astFactory->create(LT(1));
00927 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp22_AST.get()));
00928 }
00929 match(INTERFACE);
00930 {
00931 switch ( LA(1)) {
00932 case USES:
00933 {
00934 usesClause();
00935 if (inputState->guessing==0) {
00936 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00937 }
00938 break;
00939 }
00940 case IMPLEMENTATION:
00941 case CONST:
00942 case TYPE:
00943 case PROCEDURE:
00944 case FUNCTION:
00945 {
00946 break;
00947 }
00948 default:
00949 {
00950 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
00951 }
00952 }
00953 }
00954 {
00955 for (;;) {
00956 switch ( LA(1)) {
00957 case CONST:
00958 {
00959 constantDeclarationPart();
00960 if (inputState->guessing==0) {
00961 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00962 }
00963 break;
00964 }
00965 case TYPE:
00966 {
00967 typeDeclarationPart();
00968 if (inputState->guessing==0) {
00969 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00970 }
00971 break;
00972 }
00973 case PROCEDURE:
00974 case FUNCTION:
00975 {
00976 procedureHeadersPart();
00977 if (inputState->guessing==0) {
00978 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
00979 }
00980 break;
00981 }
00982 default:
00983 {
00984 goto _loop24;
00985 }
00986 }
00987 }
00988 _loop24:;
00989 }
00990 interfacePart_AST = (currentAST.root);
00991 }
00992 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00993 if( inputState->guessing == 0 ) {
00994 reportError(ex);
00995 consume();
00996 consumeUntil(_tokenSet_12);
00997 } else {
00998 throw;
00999 }
01000 }
01001 returnAST = interfacePart_AST;
01002 }
01003
01004 void PascalParser::implementationPart() {
01005 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01006 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01007 RefPascalAST implementationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01008
01009 try {
01010 RefPascalAST tmp23_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01011 if ( inputState->guessing == 0 ) {
01012 tmp23_AST = astFactory->create(LT(1));
01013 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp23_AST.get()));
01014 }
01015 match(IMPLEMENTATION);
01016 {
01017 switch ( LA(1)) {
01018 case USES:
01019 {
01020 usesClause();
01021 if (inputState->guessing==0) {
01022 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01023 }
01024 break;
01025 }
01026 case END:
01027 case BEGIN:
01028 case INITIALIZATION:
01029 case LABEL:
01030 case CONST:
01031 case RESOURCESTRING:
01032 case TYPE:
01033 case VAR:
01034 case PROCEDURE:
01035 case FUNCTION:
01036 case CONSTRUCTOR:
01037 case DESTRUCTOR:
01038 {
01039 break;
01040 }
01041 default:
01042 {
01043 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01044 }
01045 }
01046 }
01047 declarationPart();
01048 if (inputState->guessing==0) {
01049 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01050 }
01051 implementationPart_AST = (currentAST.root);
01052 }
01053 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01054 if( inputState->guessing == 0 ) {
01055 reportError(ex);
01056 consume();
01057 consumeUntil(_tokenSet_13);
01058 } else {
01059 throw;
01060 }
01061 }
01062 returnAST = implementationPart_AST;
01063 }
01064
01065 void PascalParser::initializationPart() {
01066 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01067 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01068 RefPascalAST initializationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01069
01070 try {
01071 RefPascalAST tmp24_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01072 if ( inputState->guessing == 0 ) {
01073 tmp24_AST = astFactory->create(LT(1));
01074 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp24_AST.get()));
01075 }
01076 match(INITIALIZATION);
01077 statement();
01078 if (inputState->guessing==0) {
01079 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01080 }
01081 {
01082 for (;;) {
01083 if ((LA(1) == SEMI)) {
01084 match(SEMI);
01085 statement();
01086 if (inputState->guessing==0) {
01087 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01088 }
01089 }
01090 else {
01091 goto _loop34;
01092 }
01093
01094 }
01095 _loop34:;
01096 }
01097 initializationPart_AST = (currentAST.root);
01098 }
01099 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01100 if( inputState->guessing == 0 ) {
01101 reportError(ex);
01102 consume();
01103 consumeUntil(_tokenSet_14);
01104 } else {
01105 throw;
01106 }
01107 }
01108 returnAST = initializationPart_AST;
01109 }
01110
01111 void PascalParser::finalizationPart() {
01112 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01113 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01114 RefPascalAST finalizationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01115
01116 try {
01117 RefPascalAST tmp26_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01118 if ( inputState->guessing == 0 ) {
01119 tmp26_AST = astFactory->create(LT(1));
01120 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp26_AST.get()));
01121 }
01122 match(FINALIZATION);
01123 statement();
01124 if (inputState->guessing==0) {
01125 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01126 }
01127 {
01128 for (;;) {
01129 if ((LA(1) == SEMI)) {
01130 match(SEMI);
01131 statement();
01132 if (inputState->guessing==0) {
01133 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01134 }
01135 }
01136 else {
01137 goto _loop37;
01138 }
01139
01140 }
01141 _loop37:;
01142 }
01143 finalizationPart_AST = (currentAST.root);
01144 }
01145 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01146 if( inputState->guessing == 0 ) {
01147 reportError(ex);
01148 consume();
01149 consumeUntil(_tokenSet_6);
01150 } else {
01151 throw;
01152 }
01153 }
01154 returnAST = finalizationPart_AST;
01155 }
01156
01157 void PascalParser::realizationPart() {
01158 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01159 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01160 RefPascalAST realizationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01161
01162 try {
01163 RefPascalAST tmp28_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01164 if ( inputState->guessing == 0 ) {
01165 tmp28_AST = astFactory->create(LT(1));
01166 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp28_AST.get()));
01167 }
01168 match(BEGIN);
01169 statement();
01170 if (inputState->guessing==0) {
01171 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01172 }
01173 {
01174 for (;;) {
01175 if ((LA(1) == SEMI)) {
01176 match(SEMI);
01177 statement();
01178 if (inputState->guessing==0) {
01179 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01180 }
01181 }
01182 else {
01183 goto _loop29;
01184 }
01185
01186 }
01187 _loop29:;
01188 }
01189 realizationPart_AST = (currentAST.root);
01190 }
01191 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01192 if( inputState->guessing == 0 ) {
01193 reportError(ex);
01194 consume();
01195 consumeUntil(_tokenSet_6);
01196 } else {
01197 throw;
01198 }
01199 }
01200 returnAST = realizationPart_AST;
01201 }
01202
01203 void PascalParser::constantDeclarationPart() {
01204 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01205 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01206 RefPascalAST constantDeclarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01207
01208 try {
01209 RefPascalAST tmp30_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01210 if ( inputState->guessing == 0 ) {
01211 tmp30_AST = astFactory->create(LT(1));
01212 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp30_AST.get()));
01213 }
01214 match(CONST);
01215 {
01216 int _cnt47=0;
01217 for (;;) {
01218 if ((LA(1) == IDENT) && (LA(2) == EQUAL)) {
01219 constantDeclaration();
01220 if (inputState->guessing==0) {
01221 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01222 }
01223 }
01224 else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
01225 typedConstantDeclaration();
01226 if (inputState->guessing==0) {
01227 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01228 }
01229 }
01230 else {
01231 if ( _cnt47>=1 ) { goto _loop47; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
01232 }
01233
01234 _cnt47++;
01235 }
01236 _loop47:;
01237 }
01238 constantDeclarationPart_AST = (currentAST.root);
01239 }
01240 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01241 if( inputState->guessing == 0 ) {
01242 reportError(ex);
01243 consume();
01244 consumeUntil(_tokenSet_2);
01245 } else {
01246 throw;
01247 }
01248 }
01249 returnAST = constantDeclarationPart_AST;
01250 }
01251
01252 void PascalParser::typeDeclarationPart() {
01253 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01254 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01255 RefPascalAST typeDeclarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01256
01257 try {
01258 RefPascalAST tmp31_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01259 if ( inputState->guessing == 0 ) {
01260 tmp31_AST = astFactory->create(LT(1));
01261 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp31_AST.get()));
01262 }
01263 match(TYPE);
01264 {
01265 int _cnt54=0;
01266 for (;;) {
01267 if ((LA(1) == IDENT)) {
01268 typeDeclaration();
01269 if (inputState->guessing==0) {
01270 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01271 }
01272 }
01273 else {
01274 if ( _cnt54>=1 ) { goto _loop54; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
01275 }
01276
01277 _cnt54++;
01278 }
01279 _loop54:;
01280 }
01281 typeDeclarationPart_AST = (currentAST.root);
01282 }
01283 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01284 if( inputState->guessing == 0 ) {
01285 reportError(ex);
01286 consume();
01287 consumeUntil(_tokenSet_2);
01288 } else {
01289 throw;
01290 }
01291 }
01292 returnAST = typeDeclarationPart_AST;
01293 }
01294
01295 void PascalParser::procedureHeadersPart() {
01296 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01297 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01298 RefPascalAST procedureHeadersPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01299
01300 try {
01301 switch ( LA(1)) {
01302 case PROCEDURE:
01303 {
01304 procedureHeader();
01305 if (inputState->guessing==0) {
01306 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01307 }
01308 procedureHeadersPart_AST = (currentAST.root);
01309 break;
01310 }
01311 case FUNCTION:
01312 {
01313 functionHeader();
01314 if (inputState->guessing==0) {
01315 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01316 }
01317 procedureHeadersPart_AST = (currentAST.root);
01318 break;
01319 }
01320 default:
01321 {
01322 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01323 }
01324 }
01325 }
01326 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01327 if( inputState->guessing == 0 ) {
01328 reportError(ex);
01329 consume();
01330 consumeUntil(_tokenSet_15);
01331 } else {
01332 throw;
01333 }
01334 }
01335 returnAST = procedureHeadersPart_AST;
01336 }
01337
01338 void PascalParser::statement() {
01339 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01340 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01341 RefPascalAST statement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01342
01343 try {
01344 {
01345 switch ( LA(1)) {
01346 case NUM_INT:
01347 {
01348 label();
01349 if (inputState->guessing==0) {
01350 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01351 }
01352 match(COLON);
01353 break;
01354 }
01355 case BEGIN:
01356 case CASE:
01357 case GOTO:
01358 case IF:
01359 case WHILE:
01360 case REPEAT:
01361 case FOR:
01362 case WITH:
01363 case RAISE:
01364 case TRY:
01365 case IDENT:
01366 {
01367 break;
01368 }
01369 default:
01370 {
01371 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01372 }
01373 }
01374 }
01375 {
01376 switch ( LA(1)) {
01377 case GOTO:
01378 case RAISE:
01379 case IDENT:
01380 {
01381 simpleStatement();
01382 if (inputState->guessing==0) {
01383 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01384 }
01385 break;
01386 }
01387 case BEGIN:
01388 case CASE:
01389 case IF:
01390 case WHILE:
01391 case REPEAT:
01392 case FOR:
01393 case WITH:
01394 case TRY:
01395 {
01396 structuredStatement();
01397 if (inputState->guessing==0) {
01398 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01399 }
01400 break;
01401 }
01402 default:
01403 {
01404 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01405 }
01406 }
01407 }
01408 statement_AST = (currentAST.root);
01409 }
01410 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01411 if( inputState->guessing == 0 ) {
01412 reportError(ex);
01413 consume();
01414 consumeUntil(_tokenSet_16);
01415 } else {
01416 throw;
01417 }
01418 }
01419 returnAST = statement_AST;
01420 }
01421
01422 void PascalParser::labelDeclarationPart() {
01423 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01424 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01425 RefPascalAST labelDeclarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01426
01427 try {
01428 RefPascalAST tmp33_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01429 if ( inputState->guessing == 0 ) {
01430 tmp33_AST = astFactory->create(LT(1));
01431 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp33_AST.get()));
01432 }
01433 match(LABEL);
01434 label();
01435 if (inputState->guessing==0) {
01436 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01437 }
01438 {
01439 for (;;) {
01440 if ((LA(1) == COMMA)) {
01441 match(COMMA);
01442 label();
01443 if (inputState->guessing==0) {
01444 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01445 }
01446 }
01447 else {
01448 goto _loop44;
01449 }
01450
01451 }
01452 _loop44:;
01453 }
01454 match(SEMI);
01455 labelDeclarationPart_AST = (currentAST.root);
01456 }
01457 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01458 if( inputState->guessing == 0 ) {
01459 reportError(ex);
01460 consume();
01461 consumeUntil(_tokenSet_17);
01462 } else {
01463 throw;
01464 }
01465 }
01466 returnAST = labelDeclarationPart_AST;
01467 }
01468
01469 void PascalParser::resourcestringDeclarationPart() {
01470 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01471 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01472 RefPascalAST resourcestringDeclarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01473
01474 try {
01475 RefPascalAST tmp36_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01476 if ( inputState->guessing == 0 ) {
01477 tmp36_AST = astFactory->create(LT(1));
01478 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp36_AST.get()));
01479 }
01480 match(RESOURCESTRING);
01481 {
01482 for (;;) {
01483 if ((LA(1) == IDENT)) {
01484 stringConstantDeclaration();
01485 if (inputState->guessing==0) {
01486 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01487 }
01488 }
01489 else {
01490 goto _loop50;
01491 }
01492
01493 }
01494 _loop50:;
01495 }
01496 resourcestringDeclarationPart_AST = (currentAST.root);
01497 }
01498 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01499 if( inputState->guessing == 0 ) {
01500 reportError(ex);
01501 consume();
01502 consumeUntil(_tokenSet_17);
01503 } else {
01504 throw;
01505 }
01506 }
01507 returnAST = resourcestringDeclarationPart_AST;
01508 }
01509
01510 void PascalParser::variableDeclarationPart() {
01511 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01512 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01513 RefPascalAST variableDeclarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01514
01515 try {
01516 RefPascalAST tmp37_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01517 if ( inputState->guessing == 0 ) {
01518 tmp37_AST = astFactory->create(LT(1));
01519 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp37_AST.get()));
01520 }
01521 match(VAR);
01522 variableDeclaration();
01523 if (inputState->guessing==0) {
01524 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01525 }
01526 {
01527 for (;;) {
01528 if ((LA(1) == SEMI) && (LA(2) == IDENT)) {
01529 match(SEMI);
01530 variableDeclaration();
01531 if (inputState->guessing==0) {
01532 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01533 }
01534 }
01535 else {
01536 goto _loop57;
01537 }
01538
01539 }
01540 _loop57:;
01541 }
01542 match(SEMI);
01543 variableDeclarationPart_AST = (currentAST.root);
01544 }
01545 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01546 if( inputState->guessing == 0 ) {
01547 reportError(ex);
01548 consume();
01549 consumeUntil(_tokenSet_17);
01550 } else {
01551 throw;
01552 }
01553 }
01554 returnAST = variableDeclarationPart_AST;
01555 }
01556
01557 void PascalParser::procedureAndFunctionDeclarationPart() {
01558 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01559 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01560 RefPascalAST procedureAndFunctionDeclarationPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01561
01562 try {
01563 procedureAndFunctionDeclaration();
01564 if (inputState->guessing==0) {
01565 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01566 }
01567 procedureAndFunctionDeclarationPart_AST = (currentAST.root);
01568 }
01569 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01570 if( inputState->guessing == 0 ) {
01571 reportError(ex);
01572 consume();
01573 consumeUntil(_tokenSet_17);
01574 } else {
01575 throw;
01576 }
01577 }
01578 returnAST = procedureAndFunctionDeclarationPart_AST;
01579 }
01580
01581 void PascalParser::label() {
01582 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01583 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01584 RefPascalAST label_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01585
01586 try {
01587 unsignedInteger();
01588 if (inputState->guessing==0) {
01589 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01590 }
01591 label_AST = (currentAST.root);
01592 }
01593 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01594 if( inputState->guessing == 0 ) {
01595 reportError(ex);
01596 consume();
01597 consumeUntil(_tokenSet_18);
01598 } else {
01599 throw;
01600 }
01601 }
01602 returnAST = label_AST;
01603 }
01604
01605 void PascalParser::constantDeclaration() {
01606 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01607 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01608 RefPascalAST constantDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01609
01610 try {
01611 identifier();
01612 if (inputState->guessing==0) {
01613 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01614 }
01615 match(EQUAL);
01616 expression();
01617 if (inputState->guessing==0) {
01618 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01619 }
01620 match(SEMI);
01621 constantDeclaration_AST = (currentAST.root);
01622 }
01623 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01624 if( inputState->guessing == 0 ) {
01625 reportError(ex);
01626 consume();
01627 consumeUntil(_tokenSet_19);
01628 } else {
01629 throw;
01630 }
01631 }
01632 returnAST = constantDeclaration_AST;
01633 }
01634
01635 void PascalParser::typedConstantDeclaration() {
01636 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01637 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01638 RefPascalAST typedConstantDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01639
01640 try {
01641 identifier();
01642 if (inputState->guessing==0) {
01643 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01644 }
01645 match(COLON);
01646 type();
01647 if (inputState->guessing==0) {
01648 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01649 }
01650 match(EQUAL);
01651 typedConstant();
01652 if (inputState->guessing==0) {
01653 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01654 }
01655 match(SEMI);
01656 typedConstantDeclaration_AST = (currentAST.root);
01657 }
01658 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01659 if( inputState->guessing == 0 ) {
01660 reportError(ex);
01661 consume();
01662 consumeUntil(_tokenSet_19);
01663 } else {
01664 throw;
01665 }
01666 }
01667 returnAST = typedConstantDeclaration_AST;
01668 }
01669
01670 void PascalParser::stringConstantDeclaration() {
01671 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01672 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01673 RefPascalAST stringConstantDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01674
01675 try {
01676 identifier();
01677 if (inputState->guessing==0) {
01678 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01679 }
01680 match(EQUAL);
01681 string();
01682 if (inputState->guessing==0) {
01683 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01684 }
01685 stringConstantDeclaration_AST = (currentAST.root);
01686 }
01687 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01688 if( inputState->guessing == 0 ) {
01689 reportError(ex);
01690 consume();
01691 consumeUntil(_tokenSet_20);
01692 } else {
01693 throw;
01694 }
01695 }
01696 returnAST = stringConstantDeclaration_AST;
01697 }
01698
01699 void PascalParser::string() {
01700 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01701 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01702 RefPascalAST string_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01703
01704 try {
01705 RefPascalAST tmp46_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01706 if ( inputState->guessing == 0 ) {
01707 tmp46_AST = astFactory->create(LT(1));
01708 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp46_AST.get()));
01709 }
01710 match(STRING_LITERAL);
01711 string_AST = (currentAST.root);
01712 }
01713 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01714 if( inputState->guessing == 0 ) {
01715 reportError(ex);
01716 consume();
01717 consumeUntil(_tokenSet_21);
01718 } else {
01719 throw;
01720 }
01721 }
01722 returnAST = string_AST;
01723 }
01724
01725 void PascalParser::typeDeclaration() {
01726 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01727 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01728 RefPascalAST typeDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01729
01730 try {
01731 identifier();
01732 if (inputState->guessing==0) {
01733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01734 }
01735 match(EQUAL);
01736 type();
01737 if (inputState->guessing==0) {
01738 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01739 }
01740 match(SEMI);
01741 typeDeclaration_AST = (currentAST.root);
01742 }
01743 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01744 if( inputState->guessing == 0 ) {
01745 reportError(ex);
01746 consume();
01747 consumeUntil(_tokenSet_19);
01748 } else {
01749 throw;
01750 }
01751 }
01752 returnAST = typeDeclaration_AST;
01753 }
01754
01755 void PascalParser::variableDeclaration() {
01756 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01757 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01758 RefPascalAST variableDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01759 ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken;
01760 RefPascalAST c_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01761
01762 try {
01763 identifierList();
01764 if (inputState->guessing==0) {
01765 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01766 }
01767 c = LT(1);
01768 if ( inputState->guessing == 0 ) {
01769 c_AST = astFactory->create(c);
01770 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(c_AST.get()));
01771 }
01772 match(COLON);
01773 if ( inputState->guessing==0 ) {
01774 #line 246 "pascal.g"
01775 c_AST->setType(VARDECL);
01776 #line 1777 "PascalParser.cpp"
01777 }
01778 type();
01779 if (inputState->guessing==0) {
01780 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01781 }
01782 variableDeclaration_AST = (currentAST.root);
01783 }
01784 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01785 if( inputState->guessing == 0 ) {
01786 reportError(ex);
01787 consume();
01788 consumeUntil(_tokenSet_22);
01789 } else {
01790 throw;
01791 }
01792 }
01793 returnAST = variableDeclaration_AST;
01794 }
01795
01796 void PascalParser::type() {
01797 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01798 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01799 RefPascalAST type_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01800
01801 try {
01802 switch ( LA(1)) {
01803 case INTEGER:
01804 case SHORTINT:
01805 case SMALLINT:
01806 case LONGINT:
01807 case INT64:
01808 case BYTE:
01809 case WORD:
01810 case CARDINAL:
01811 case QWORD:
01812 case BOOLEAN:
01813 case BYTEBOOL:
01814 case LONGBOOL:
01815 case CHAR:
01816 case REAL:
01817 case SINGLE:
01818 case DOUBLE:
01819 case EXTENDED:
01820 case COMP:
01821 {
01822 simpleType();
01823 if (inputState->guessing==0) {
01824 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01825 }
01826 type_AST = (currentAST.root);
01827 break;
01828 }
01829 case NUM_INT:
01830 case PLUS:
01831 case MINUS:
01832 case STRING_LITERAL:
01833 case CHR:
01834 case NUM_REAL:
01835 case IDENT:
01836 {
01837 subrangeTypeOrTypeIdentifier();
01838 if (inputState->guessing==0) {
01839 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01840 }
01841 type_AST = (currentAST.root);
01842 break;
01843 }
01844 case LPAREN:
01845 {
01846 enumeratedType();
01847 if (inputState->guessing==0) {
01848 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01849 }
01850 type_AST = (currentAST.root);
01851 break;
01852 }
01853 case STRING:
01854 {
01855 stringType();
01856 if (inputState->guessing==0) {
01857 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01858 }
01859 type_AST = (currentAST.root);
01860 break;
01861 }
01862 case ARRAY:
01863 case PACKED:
01864 case RECORD:
01865 case SET:
01866 case FILE:
01867 case OBJECT:
01868 case CLASS:
01869 {
01870 structuredType();
01871 if (inputState->guessing==0) {
01872 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01873 }
01874 type_AST = (currentAST.root);
01875 break;
01876 }
01877 case POINTER:
01878 {
01879 pointerType();
01880 if (inputState->guessing==0) {
01881 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01882 }
01883 type_AST = (currentAST.root);
01884 break;
01885 }
01886 case PROCEDURE:
01887 case FUNCTION:
01888 {
01889 proceduralType();
01890 if (inputState->guessing==0) {
01891 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01892 }
01893 type_AST = (currentAST.root);
01894 break;
01895 }
01896 default:
01897 {
01898 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01899 }
01900 }
01901 }
01902 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01903 if( inputState->guessing == 0 ) {
01904 reportError(ex);
01905 consume();
01906 consumeUntil(_tokenSet_23);
01907 } else {
01908 throw;
01909 }
01910 }
01911 returnAST = type_AST;
01912 }
01913
01914 void PascalParser::procedureAndFunctionDeclaration() {
01915 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01916 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01917 RefPascalAST procedureAndFunctionDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01918
01919 try {
01920 switch ( LA(1)) {
01921 case PROCEDURE:
01922 {
01923 procedureDeclaration();
01924 if (inputState->guessing==0) {
01925 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01926 }
01927 procedureAndFunctionDeclaration_AST = (currentAST.root);
01928 break;
01929 }
01930 case FUNCTION:
01931 {
01932 functionDeclaration();
01933 if (inputState->guessing==0) {
01934 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01935 }
01936 procedureAndFunctionDeclaration_AST = (currentAST.root);
01937 break;
01938 }
01939 case CONSTRUCTOR:
01940 {
01941 constructorDeclaration();
01942 if (inputState->guessing==0) {
01943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01944 }
01945 procedureAndFunctionDeclaration_AST = (currentAST.root);
01946 break;
01947 }
01948 case DESTRUCTOR:
01949 {
01950 destructorDeclaration();
01951 if (inputState->guessing==0) {
01952 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01953 }
01954 procedureAndFunctionDeclaration_AST = (currentAST.root);
01955 break;
01956 }
01957 default:
01958 {
01959 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
01960 }
01961 }
01962 }
01963 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01964 if( inputState->guessing == 0 ) {
01965 reportError(ex);
01966 consume();
01967 consumeUntil(_tokenSet_17);
01968 } else {
01969 throw;
01970 }
01971 }
01972 returnAST = procedureAndFunctionDeclaration_AST;
01973 }
01974
01975 void PascalParser::procedureDeclaration() {
01976 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01977 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
01978 RefPascalAST procedureDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
01979
01980 try {
01981 procedureHeader();
01982 if (inputState->guessing==0) {
01983 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01984 }
01985 subroutineBlock();
01986 if (inputState->guessing==0) {
01987 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
01988 }
01989 match(SEMI);
01990 procedureDeclaration_AST = (currentAST.root);
01991 }
01992 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01993 if( inputState->guessing == 0 ) {
01994 reportError(ex);
01995 consume();
01996 consumeUntil(_tokenSet_17);
01997 } else {
01998 throw;
01999 }
02000 }
02001 returnAST = procedureDeclaration_AST;
02002 }
02003
02004 void PascalParser::functionDeclaration() {
02005 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02006 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02007 RefPascalAST functionDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02008
02009 try {
02010 functionHeader();
02011 if (inputState->guessing==0) {
02012 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02013 }
02014 subroutineBlock();
02015 if (inputState->guessing==0) {
02016 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02017 }
02018 match(SEMI);
02019 functionDeclaration_AST = (currentAST.root);
02020 }
02021 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02022 if( inputState->guessing == 0 ) {
02023 reportError(ex);
02024 consume();
02025 consumeUntil(_tokenSet_17);
02026 } else {
02027 throw;
02028 }
02029 }
02030 returnAST = functionDeclaration_AST;
02031 }
02032
02033 void PascalParser::constructorDeclaration() {
02034 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02035 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02036 RefPascalAST constructorDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02037
02038 try {
02039 constructorHeader();
02040 if (inputState->guessing==0) {
02041 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02042 }
02043 match(SEMI);
02044 subroutineBlock();
02045 if (inputState->guessing==0) {
02046 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02047 }
02048 constructorDeclaration_AST = (currentAST.root);
02049 }
02050 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02051 if( inputState->guessing == 0 ) {
02052 reportError(ex);
02053 consume();
02054 consumeUntil(_tokenSet_17);
02055 } else {
02056 throw;
02057 }
02058 }
02059 returnAST = constructorDeclaration_AST;
02060 }
02061
02062 void PascalParser::destructorDeclaration() {
02063 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02064 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02065 RefPascalAST destructorDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02066
02067 try {
02068 destructorHeader();
02069 if (inputState->guessing==0) {
02070 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02071 }
02072 match(SEMI);
02073 subroutineBlock();
02074 if (inputState->guessing==0) {
02075 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02076 }
02077 destructorDeclaration_AST = (currentAST.root);
02078 }
02079 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02080 if( inputState->guessing == 0 ) {
02081 reportError(ex);
02082 consume();
02083 consumeUntil(_tokenSet_17);
02084 } else {
02085 throw;
02086 }
02087 }
02088 returnAST = destructorDeclaration_AST;
02089 }
02090
02091 void PascalParser::compoundStatement() {
02092 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02093 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02094 RefPascalAST compoundStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02095
02096 try {
02097 if ((LA(1) == BEGIN) && (LA(2) == END)) {
02098 match(BEGIN);
02099 match(END);
02100 compoundStatement_AST = (currentAST.root);
02101 }
02102 else if ((LA(1) == BEGIN) && (LA(2) == SEMI)) {
02103 match(BEGIN);
02104 {
02105 int _cnt312=0;
02106 for (;;) {
02107 if ((LA(1) == SEMI)) {
02108 match(SEMI);
02109 }
02110 else {
02111 if ( _cnt312>=1 ) { goto _loop312; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
02112 }
02113
02114 _cnt312++;
02115 }
02116 _loop312:;
02117 }
02118 match(END);
02119 compoundStatement_AST = (currentAST.root);
02120 }
02121 else if ((LA(1) == BEGIN) && (_tokenSet_24.member(LA(2)))) {
02122 match(BEGIN);
02123 statement();
02124 if (inputState->guessing==0) {
02125 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02126 }
02127 {
02128 for (;;) {
02129 if ((LA(1) == SEMI)) {
02130 match(SEMI);
02131 {
02132 switch ( LA(1)) {
02133 case BEGIN:
02134 case NUM_INT:
02135 case CASE:
02136 case GOTO:
02137 case IF:
02138 case WHILE:
02139 case REPEAT:
02140 case FOR:
02141 case WITH:
02142 case RAISE:
02143 case TRY:
02144 case IDENT:
02145 {
02146 statement();
02147 if (inputState->guessing==0) {
02148 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02149 }
02150 break;
02151 }
02152 case SEMI:
02153 case END:
02154 {
02155 break;
02156 }
02157 default:
02158 {
02159 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02160 }
02161 }
02162 }
02163 }
02164 else {
02165 goto _loop315;
02166 }
02167
02168 }
02169 _loop315:;
02170 }
02171 match(END);
02172 compoundStatement_AST = (currentAST.root);
02173 }
02174 else {
02175 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02176 }
02177
02178 }
02179 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02180 if( inputState->guessing == 0 ) {
02181 reportError(ex);
02182 consume();
02183 consumeUntil(_tokenSet_25);
02184 } else {
02185 throw;
02186 }
02187 }
02188 returnAST = compoundStatement_AST;
02189 }
02190
02191 void PascalParser::procedureHeader() {
02192 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02193 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02194 RefPascalAST procedureHeader_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02195
02196 try {
02197 RefPascalAST tmp61_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02198 if ( inputState->guessing == 0 ) {
02199 tmp61_AST = astFactory->create(LT(1));
02200 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp61_AST.get()));
02201 }
02202 match(PROCEDURE);
02203 {
02204 if ((LA(1) == IDENT) && (LA(2) == SEMI || LA(2) == LPAREN)) {
02205 identifier();
02206 if (inputState->guessing==0) {
02207 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02208 }
02209 }
02210 else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
02211 qualifiedMethodIdentifier();
02212 if (inputState->guessing==0) {
02213 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02214 }
02215 }
02216 else {
02217 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02218 }
02219
02220 }
02221 {
02222 switch ( LA(1)) {
02223 case LPAREN:
02224 {
02225 formalParameterList();
02226 if (inputState->guessing==0) {
02227 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02228 }
02229 break;
02230 }
02231 case SEMI:
02232 {
02233 break;
02234 }
02235 default:
02236 {
02237 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02238 }
02239 }
02240 }
02241 match(SEMI);
02242 {
02243 for (;;) {
02244 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02245 modifiers();
02246 if (inputState->guessing==0) {
02247 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02248 }
02249 match(SEMI);
02250 }
02251 else {
02252 goto _loop68;
02253 }
02254
02255 }
02256 _loop68:;
02257 }
02258 procedureHeader_AST = (currentAST.root);
02259 }
02260 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02261 if( inputState->guessing == 0 ) {
02262 reportError(ex);
02263 consume();
02264 consumeUntil(_tokenSet_26);
02265 } else {
02266 throw;
02267 }
02268 }
02269 returnAST = procedureHeader_AST;
02270 }
02271
02272 void PascalParser::subroutineBlock() {
02273 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02274 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02275 RefPascalAST subroutineBlock_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02276
02277 try {
02278 switch ( LA(1)) {
02279 case BEGIN:
02280 case LABEL:
02281 case CONST:
02282 case RESOURCESTRING:
02283 case TYPE:
02284 case VAR:
02285 case PROCEDURE:
02286 case FUNCTION:
02287 case CONSTRUCTOR:
02288 case DESTRUCTOR:
02289 {
02290 block();
02291 if (inputState->guessing==0) {
02292 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02293 }
02294 subroutineBlock_AST = (currentAST.root);
02295 break;
02296 }
02297 case EXTERNAL:
02298 {
02299 externalDirective();
02300 if (inputState->guessing==0) {
02301 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02302 }
02303 subroutineBlock_AST = (currentAST.root);
02304 break;
02305 }
02306 case FORWARD:
02307 {
02308 match(FORWARD);
02309 subroutineBlock_AST = (currentAST.root);
02310 break;
02311 }
02312 default:
02313 {
02314 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02315 }
02316 }
02317 }
02318 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02319 if( inputState->guessing == 0 ) {
02320 reportError(ex);
02321 consume();
02322 consumeUntil(_tokenSet_27);
02323 } else {
02324 throw;
02325 }
02326 }
02327 returnAST = subroutineBlock_AST;
02328 }
02329
02330 void PascalParser::functionHeader() {
02331 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02332 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02333 RefPascalAST functionHeader_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02334
02335 try {
02336 bool synPredMatched74 = false;
02337 if (((LA(1) == FUNCTION) && (LA(2) == IDENT))) {
02338 int _m74 = mark();
02339 synPredMatched74 = true;
02340 inputState->guessing++;
02341 try {
02342 {
02343 match(FUNCTION);
02344 identifier();
02345 match(COLON);
02346 type();
02347 match(SEMI);
02348 }
02349 }
02350 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
02351 synPredMatched74 = false;
02352 }
02353 rewind(_m74);
02354 inputState->guessing--;
02355 }
02356 if ( synPredMatched74 ) {
02357 RefPascalAST tmp65_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02358 if ( inputState->guessing == 0 ) {
02359 tmp65_AST = astFactory->create(LT(1));
02360 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp65_AST.get()));
02361 }
02362 match(FUNCTION);
02363 identifier();
02364 if (inputState->guessing==0) {
02365 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02366 }
02367 match(COLON);
02368 type();
02369 if (inputState->guessing==0) {
02370 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02371 }
02372 match(SEMI);
02373 {
02374 for (;;) {
02375 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02376 modifiers();
02377 if (inputState->guessing==0) {
02378 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02379 }
02380 match(SEMI);
02381 }
02382 else {
02383 goto _loop76;
02384 }
02385
02386 }
02387 _loop76:;
02388 }
02389 functionHeader_AST = (currentAST.root);
02390 }
02391 else {
02392 bool synPredMatched78 = false;
02393 if (((LA(1) == FUNCTION) && (LA(2) == IDENT))) {
02394 int _m78 = mark();
02395 synPredMatched78 = true;
02396 inputState->guessing++;
02397 try {
02398 {
02399 match(FUNCTION);
02400 identifier();
02401 match(COLON);
02402 match(COLON);
02403 identifier();
02404 match(COLON);
02405 type();
02406 match(SEMI);
02407 }
02408 }
02409 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
02410 synPredMatched78 = false;
02411 }
02412 rewind(_m78);
02413 inputState->guessing--;
02414 }
02415 if ( synPredMatched78 ) {
02416 RefPascalAST tmp69_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02417 if ( inputState->guessing == 0 ) {
02418 tmp69_AST = astFactory->create(LT(1));
02419 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp69_AST.get()));
02420 }
02421 match(FUNCTION);
02422 qualifiedMethodIdentifier();
02423 if (inputState->guessing==0) {
02424 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02425 }
02426 match(COLON);
02427 type();
02428 if (inputState->guessing==0) {
02429 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02430 }
02431 match(SEMI);
02432 {
02433 for (;;) {
02434 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02435 modifiers();
02436 if (inputState->guessing==0) {
02437 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02438 }
02439 match(SEMI);
02440 }
02441 else {
02442 goto _loop80;
02443 }
02444
02445 }
02446 _loop80:;
02447 }
02448 functionHeader_AST = (currentAST.root);
02449 }
02450 else {
02451 bool synPredMatched82 = false;
02452 if (((LA(1) == FUNCTION) && (LA(2) == IDENT))) {
02453 int _m82 = mark();
02454 synPredMatched82 = true;
02455 inputState->guessing++;
02456 try {
02457 {
02458 match(FUNCTION);
02459 identifier();
02460 match(COLON);
02461 match(COLON);
02462 identifier();
02463 match(LPAREN);
02464 }
02465 }
02466 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
02467 synPredMatched82 = false;
02468 }
02469 rewind(_m82);
02470 inputState->guessing--;
02471 }
02472 if ( synPredMatched82 ) {
02473 RefPascalAST tmp73_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02474 if ( inputState->guessing == 0 ) {
02475 tmp73_AST = astFactory->create(LT(1));
02476 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp73_AST.get()));
02477 }
02478 match(FUNCTION);
02479 qualifiedMethodIdentifier();
02480 if (inputState->guessing==0) {
02481 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02482 }
02483 formalParameterList();
02484 if (inputState->guessing==0) {
02485 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02486 }
02487 match(COLON);
02488 type();
02489 if (inputState->guessing==0) {
02490 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02491 }
02492 match(SEMI);
02493 {
02494 for (;;) {
02495 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02496 modifiers();
02497 if (inputState->guessing==0) {
02498 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02499 }
02500 match(SEMI);
02501 }
02502 else {
02503 goto _loop84;
02504 }
02505
02506 }
02507 _loop84:;
02508 }
02509 functionHeader_AST = (currentAST.root);
02510 }
02511 else if ((LA(1) == FUNCTION) && (LA(2) == IDENT)) {
02512 RefPascalAST tmp77_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02513 if ( inputState->guessing == 0 ) {
02514 tmp77_AST = astFactory->create(LT(1));
02515 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp77_AST.get()));
02516 }
02517 match(FUNCTION);
02518 identifier();
02519 if (inputState->guessing==0) {
02520 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02521 }
02522 formalParameterList();
02523 if (inputState->guessing==0) {
02524 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02525 }
02526 match(COLON);
02527 type();
02528 if (inputState->guessing==0) {
02529 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02530 }
02531 match(SEMI);
02532 {
02533 for (;;) {
02534 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02535 modifiers();
02536 if (inputState->guessing==0) {
02537 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02538 }
02539 match(SEMI);
02540 }
02541 else {
02542 goto _loop86;
02543 }
02544
02545 }
02546 _loop86:;
02547 }
02548 functionHeader_AST = (currentAST.root);
02549 }
02550 else {
02551 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02552 }
02553 }}
02554 }
02555 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02556 if( inputState->guessing == 0 ) {
02557 reportError(ex);
02558 consume();
02559 consumeUntil(_tokenSet_26);
02560 } else {
02561 throw;
02562 }
02563 }
02564 returnAST = functionHeader_AST;
02565 }
02566
02567 void PascalParser::qualifiedMethodIdentifier() {
02568 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02569 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02570 RefPascalAST qualifiedMethodIdentifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02571
02572 try {
02573 identifier();
02574 if (inputState->guessing==0) {
02575 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02576 }
02577 match(COLON);
02578 match(COLON);
02579 identifier();
02580 if (inputState->guessing==0) {
02581 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02582 }
02583 qualifiedMethodIdentifier_AST = (currentAST.root);
02584 }
02585 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02586 if( inputState->guessing == 0 ) {
02587 reportError(ex);
02588 consume();
02589 consumeUntil(_tokenSet_28);
02590 } else {
02591 throw;
02592 }
02593 }
02594 returnAST = qualifiedMethodIdentifier_AST;
02595 }
02596
02597 void PascalParser::formalParameterList() {
02598 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02599 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02600 RefPascalAST formalParameterList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02601
02602 try {
02603 match(LPAREN);
02604 parameterDeclaration();
02605 if (inputState->guessing==0) {
02606 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02607 }
02608 {
02609 for (;;) {
02610 if ((LA(1) == SEMI)) {
02611 match(SEMI);
02612 parameterDeclaration();
02613 if (inputState->guessing==0) {
02614 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02615 }
02616 }
02617 else {
02618 goto _loop96;
02619 }
02620
02621 }
02622 _loop96:;
02623 }
02624 match(RPAREN);
02625 formalParameterList_AST = (currentAST.root);
02626 }
02627 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02628 if( inputState->guessing == 0 ) {
02629 reportError(ex);
02630 consume();
02631 consumeUntil(_tokenSet_29);
02632 } else {
02633 throw;
02634 }
02635 }
02636 returnAST = formalParameterList_AST;
02637 }
02638
02639 void PascalParser::modifiers() {
02640 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02641 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02642 RefPascalAST modifiers_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02643
02644 try {
02645 switch ( LA(1)) {
02646 case PUBLIC:
02647 {
02648 match(PUBLIC);
02649 modifiers_AST = (currentAST.root);
02650 break;
02651 }
02652 case ALIAS:
02653 {
02654 {
02655 match(ALIAS);
02656 stringConstant();
02657 if (inputState->guessing==0) {
02658 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02659 }
02660 }
02661 modifiers_AST = (currentAST.root);
02662 break;
02663 }
02664 case INTERRUPT:
02665 {
02666 match(INTERRUPT);
02667 modifiers_AST = (currentAST.root);
02668 break;
02669 }
02670 case REGISTER:
02671 case PASCAL:
02672 case CDECL:
02673 case STDCALL:
02674 case POPSTACK:
02675 case SAVEREGISTERS:
02676 case INLINE:
02677 case SAFECALL:
02678 case NEAR:
02679 case FAR:
02680 {
02681 callModifiers();
02682 if (inputState->guessing==0) {
02683 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02684 }
02685 modifiers_AST = (currentAST.root);
02686 break;
02687 }
02688 case EXPORT:
02689 {
02690 match(EXPORT);
02691 modifiers_AST = (currentAST.root);
02692 break;
02693 }
02694 default:
02695 {
02696 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02697 }
02698 }
02699 }
02700 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02701 if( inputState->guessing == 0 ) {
02702 reportError(ex);
02703 consume();
02704 consumeUntil(_tokenSet_22);
02705 } else {
02706 throw;
02707 }
02708 }
02709 returnAST = modifiers_AST;
02710 }
02711
02712 void PascalParser::externalDirective() {
02713 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02714 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02715 RefPascalAST externalDirective_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02716
02717 try {
02718 RefPascalAST tmp90_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02719 if ( inputState->guessing == 0 ) {
02720 tmp90_AST = astFactory->create(LT(1));
02721 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp90_AST.get()));
02722 }
02723 match(EXTERNAL);
02724 {
02725 switch ( LA(1)) {
02726 case STRING_LITERAL:
02727 case CHR:
02728 {
02729 stringConstant();
02730 if (inputState->guessing==0) {
02731 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02732 }
02733 {
02734 switch ( LA(1)) {
02735 case LITERAL_name:
02736 {
02737 {
02738 RefPascalAST tmp91_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02739 if ( inputState->guessing == 0 ) {
02740 tmp91_AST = astFactory->create(LT(1));
02741 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp91_AST.get()));
02742 }
02743 match(LITERAL_name);
02744 stringConstant();
02745 if (inputState->guessing==0) {
02746 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02747 }
02748 }
02749 break;
02750 }
02751 case LITERAL_index:
02752 {
02753 {
02754 RefPascalAST tmp92_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02755 if ( inputState->guessing == 0 ) {
02756 tmp92_AST = astFactory->create(LT(1));
02757 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp92_AST.get()));
02758 }
02759 match(LITERAL_index);
02760 integerConstant();
02761 if (inputState->guessing==0) {
02762 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02763 }
02764 }
02765 break;
02766 }
02767 case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
02768 case SEMI:
02769 case END:
02770 case EXPORTS:
02771 case BEGIN:
02772 case INITIALIZATION:
02773 case LABEL:
02774 case CONST:
02775 case RESOURCESTRING:
02776 case TYPE:
02777 case VAR:
02778 case PROCEDURE:
02779 case FUNCTION:
02780 case CONSTRUCTOR:
02781 case DESTRUCTOR:
02782 {
02783 break;
02784 }
02785 default:
02786 {
02787 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02788 }
02789 }
02790 }
02791 break;
02792 }
02793 case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
02794 case SEMI:
02795 case END:
02796 case EXPORTS:
02797 case BEGIN:
02798 case INITIALIZATION:
02799 case LABEL:
02800 case CONST:
02801 case RESOURCESTRING:
02802 case TYPE:
02803 case VAR:
02804 case PROCEDURE:
02805 case FUNCTION:
02806 case CONSTRUCTOR:
02807 case DESTRUCTOR:
02808 {
02809 break;
02810 }
02811 default:
02812 {
02813 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02814 }
02815 }
02816 }
02817 externalDirective_AST = (currentAST.root);
02818 }
02819 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02820 if( inputState->guessing == 0 ) {
02821 reportError(ex);
02822 consume();
02823 consumeUntil(_tokenSet_27);
02824 } else {
02825 throw;
02826 }
02827 }
02828 returnAST = externalDirective_AST;
02829 }
02830
02831 void PascalParser::functionHeaderEnding() {
02832 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02833 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02834 RefPascalAST functionHeaderEnding_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02835
02836 try {
02837 switch ( LA(1)) {
02838 case COLON:
02839 {
02840 match(COLON);
02841 type();
02842 if (inputState->guessing==0) {
02843 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02844 }
02845 match(SEMI);
02846 {
02847 for (;;) {
02848 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02849 modifiers();
02850 if (inputState->guessing==0) {
02851 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02852 }
02853 match(SEMI);
02854 }
02855 else {
02856 goto _loop91;
02857 }
02858
02859 }
02860 _loop91:;
02861 }
02862 functionHeaderEnding_AST = (currentAST.root);
02863 break;
02864 }
02865 case LPAREN:
02866 {
02867 formalParameterList();
02868 if (inputState->guessing==0) {
02869 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02870 }
02871 match(COLON);
02872 type();
02873 if (inputState->guessing==0) {
02874 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02875 }
02876 match(SEMI);
02877 {
02878 for (;;) {
02879 if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
02880 modifiers();
02881 if (inputState->guessing==0) {
02882 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02883 }
02884 match(SEMI);
02885 }
02886 else {
02887 goto _loop93;
02888 }
02889
02890 }
02891 _loop93:;
02892 }
02893 functionHeaderEnding_AST = (currentAST.root);
02894 break;
02895 }
02896 default:
02897 {
02898 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02899 }
02900 }
02901 }
02902 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02903 if( inputState->guessing == 0 ) {
02904 reportError(ex);
02905 consume();
02906 consumeUntil(_tokenSet_0);
02907 } else {
02908 throw;
02909 }
02910 }
02911 returnAST = functionHeaderEnding_AST;
02912 }
02913
02914 void PascalParser::parameterDeclaration() {
02915 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02916 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02917 RefPascalAST parameterDeclaration_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02918
02919 try {
02920 switch ( LA(1)) {
02921 case IDENT:
02922 {
02923 valueParameter();
02924 if (inputState->guessing==0) {
02925 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02926 }
02927 parameterDeclaration_AST = (currentAST.root);
02928 break;
02929 }
02930 case VAR:
02931 {
02932 variableParameter();
02933 if (inputState->guessing==0) {
02934 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02935 }
02936 parameterDeclaration_AST = (currentAST.root);
02937 break;
02938 }
02939 case CONST:
02940 {
02941 constantParameter();
02942 if (inputState->guessing==0) {
02943 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02944 }
02945 parameterDeclaration_AST = (currentAST.root);
02946 break;
02947 }
02948 default:
02949 {
02950 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
02951 }
02952 }
02953 }
02954 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02955 if( inputState->guessing == 0 ) {
02956 reportError(ex);
02957 consume();
02958 consumeUntil(_tokenSet_30);
02959 } else {
02960 throw;
02961 }
02962 }
02963 returnAST = parameterDeclaration_AST;
02964 }
02965
02966 void PascalParser::valueParameter() {
02967 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02968 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
02969 RefPascalAST valueParameter_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
02970
02971 try {
02972 bool synPredMatched100 = false;
02973 if (((LA(1) == IDENT) && (LA(2) == COMMA || LA(2) == COLON))) {
02974 int _m100 = mark();
02975 synPredMatched100 = true;
02976 inputState->guessing++;
02977 try {
02978 {
02979 identifierList();
02980 match(COLON);
02981 match(ARRAY);
02982 match(OF);
02983 }
02984 }
02985 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
02986 synPredMatched100 = false;
02987 }
02988 rewind(_m100);
02989 inputState->guessing--;
02990 }
02991 if ( synPredMatched100 ) {
02992 identifierList();
02993 if (inputState->guessing==0) {
02994 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
02995 }
02996 match(COLON);
02997 match(ARRAY);
02998 match(OF);
02999 type();
03000 if (inputState->guessing==0) {
03001 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03002 }
03003 valueParameter_AST = (currentAST.root);
03004 }
03005 else if ((LA(1) == IDENT) && (LA(2) == COMMA || LA(2) == COLON)) {
03006 identifierList();
03007 if (inputState->guessing==0) {
03008 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03009 }
03010 match(COLON);
03011 type();
03012 if (inputState->guessing==0) {
03013 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03014 }
03015 valueParameter_AST = (currentAST.root);
03016 }
03017 else {
03018 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03019 }
03020
03021 }
03022 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03023 if( inputState->guessing == 0 ) {
03024 reportError(ex);
03025 consume();
03026 consumeUntil(_tokenSet_30);
03027 } else {
03028 throw;
03029 }
03030 }
03031 returnAST = valueParameter_AST;
03032 }
03033
03034 void PascalParser::variableParameter() {
03035 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03036 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03037 RefPascalAST variableParameter_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03038
03039 try {
03040 RefPascalAST tmp103_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03041 if ( inputState->guessing == 0 ) {
03042 tmp103_AST = astFactory->create(LT(1));
03043 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp103_AST.get()));
03044 }
03045 match(VAR);
03046 identifierList();
03047 if (inputState->guessing==0) {
03048 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03049 }
03050 {
03051 switch ( LA(1)) {
03052 case COLON:
03053 {
03054 untypedParameterPart();
03055 if (inputState->guessing==0) {
03056 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03057 }
03058 break;
03059 }
03060 case SEMI:
03061 case RPAREN:
03062 case RBRACK:
03063 {
03064 break;
03065 }
03066 default:
03067 {
03068 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03069 }
03070 }
03071 }
03072 variableParameter_AST = (currentAST.root);
03073 }
03074 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03075 if( inputState->guessing == 0 ) {
03076 reportError(ex);
03077 consume();
03078 consumeUntil(_tokenSet_30);
03079 } else {
03080 throw;
03081 }
03082 }
03083 returnAST = variableParameter_AST;
03084 }
03085
03086 void PascalParser::constantParameter() {
03087 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03088 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03089 RefPascalAST constantParameter_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03090
03091 try {
03092 RefPascalAST tmp104_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03093 if ( inputState->guessing == 0 ) {
03094 tmp104_AST = astFactory->create(LT(1));
03095 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp104_AST.get()));
03096 }
03097 match(CONST);
03098 identifierList();
03099 if (inputState->guessing==0) {
03100 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03101 }
03102 {
03103 switch ( LA(1)) {
03104 case COLON:
03105 {
03106 untypedParameterPart();
03107 if (inputState->guessing==0) {
03108 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03109 }
03110 break;
03111 }
03112 case SEMI:
03113 case RPAREN:
03114 case RBRACK:
03115 {
03116 break;
03117 }
03118 default:
03119 {
03120 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03121 }
03122 }
03123 }
03124 constantParameter_AST = (currentAST.root);
03125 }
03126 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03127 if( inputState->guessing == 0 ) {
03128 reportError(ex);
03129 consume();
03130 consumeUntil(_tokenSet_30);
03131 } else {
03132 throw;
03133 }
03134 }
03135 returnAST = constantParameter_AST;
03136 }
03137
03138 void PascalParser::untypedParameterPart() {
03139 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03140 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03141 RefPascalAST untypedParameterPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03142
03143 try {
03144 bool synPredMatched105 = false;
03145 if (((LA(1) == COLON) && (LA(2) == ARRAY))) {
03146 int _m105 = mark();
03147 synPredMatched105 = true;
03148 inputState->guessing++;
03149 try {
03150 {
03151 match(COLON);
03152 match(ARRAY);
03153 match(OF);
03154 type();
03155 }
03156 }
03157 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
03158 synPredMatched105 = false;
03159 }
03160 rewind(_m105);
03161 inputState->guessing--;
03162 }
03163 if ( synPredMatched105 ) {
03164 match(COLON);
03165 match(ARRAY);
03166 match(OF);
03167 type();
03168 if (inputState->guessing==0) {
03169 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03170 }
03171 untypedParameterPart_AST = (currentAST.root);
03172 }
03173 else if ((LA(1) == COLON) && (_tokenSet_31.member(LA(2)))) {
03174 match(COLON);
03175 type();
03176 if (inputState->guessing==0) {
03177 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03178 }
03179 untypedParameterPart_AST = (currentAST.root);
03180 }
03181 else {
03182 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03183 }
03184
03185 }
03186 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03187 if( inputState->guessing == 0 ) {
03188 reportError(ex);
03189 consume();
03190 consumeUntil(_tokenSet_30);
03191 } else {
03192 throw;
03193 }
03194 }
03195 returnAST = untypedParameterPart_AST;
03196 }
03197
03198 void PascalParser::callModifiers() {
03199 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03200 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03201 RefPascalAST callModifiers_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03202
03203 try {
03204 switch ( LA(1)) {
03205 case REGISTER:
03206 {
03207 match(REGISTER);
03208 callModifiers_AST = (currentAST.root);
03209 break;
03210 }
03211 case PASCAL:
03212 {
03213 match(PASCAL);
03214 callModifiers_AST = (currentAST.root);
03215 break;
03216 }
03217 case CDECL:
03218 {
03219 match(CDECL);
03220 callModifiers_AST = (currentAST.root);
03221 break;
03222 }
03223 case STDCALL:
03224 {
03225 match(STDCALL);
03226 callModifiers_AST = (currentAST.root);
03227 break;
03228 }
03229 case POPSTACK:
03230 {
03231 match(POPSTACK);
03232 callModifiers_AST = (currentAST.root);
03233 break;
03234 }
03235 case SAVEREGISTERS:
03236 {
03237 match(SAVEREGISTERS);
03238 callModifiers_AST = (currentAST.root);
03239 break;
03240 }
03241 case INLINE:
03242 {
03243 match(INLINE);
03244 callModifiers_AST = (currentAST.root);
03245 break;
03246 }
03247 case SAFECALL:
03248 {
03249 match(SAFECALL);
03250 callModifiers_AST = (currentAST.root);
03251 break;
03252 }
03253 case NEAR:
03254 {
03255 match(NEAR);
03256 callModifiers_AST = (currentAST.root);
03257 break;
03258 }
03259 case FAR:
03260 {
03261 match(FAR);
03262 callModifiers_AST = (currentAST.root);
03263 break;
03264 }
03265 default:
03266 {
03267 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03268 }
03269 }
03270 }
03271 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03272 if( inputState->guessing == 0 ) {
03273 reportError(ex);
03274 consume();
03275 consumeUntil(_tokenSet_23);
03276 } else {
03277 throw;
03278 }
03279 }
03280 returnAST = callModifiers_AST;
03281 }
03282
03283 void PascalParser::expression() {
03284 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03285 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03286 RefPascalAST expression_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03287
03288 try {
03289 simpleExpression();
03290 if (inputState->guessing==0) {
03291 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03292 }
03293 {
03294 switch ( LA(1)) {
03295 case EQUAL:
03296 case LE:
03297 case GE:
03298 case LTH:
03299 case GT:
03300 case NOT_EQUAL:
03301 case IN:
03302 case IS:
03303 {
03304 expressionSign();
03305 if (inputState->guessing==0) {
03306 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03307 }
03308 simpleExpression();
03309 if (inputState->guessing==0) {
03310 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03311 }
03312 break;
03313 }
03314 case DOT:
03315 case SEMI:
03316 case END:
03317 case COMMA:
03318 case RPAREN:
03319 case FINALIZATION:
03320 case OF:
03321 case DOTDOT:
03322 case RBRACK:
03323 case THEN:
03324 case ELSE:
03325 case DO:
03326 case UNTIL:
03327 case TO:
03328 case DOWNTO:
03329 case RBRACK2:
03330 case EXCEPT:
03331 case FINALLY:
03332 {
03333 break;
03334 }
03335 default:
03336 {
03337 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03338 }
03339 }
03340 }
03341 expression_AST = (currentAST.root);
03342 }
03343 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03344 if( inputState->guessing == 0 ) {
03345 reportError(ex);
03346 consume();
03347 consumeUntil(_tokenSet_32);
03348 } else {
03349 throw;
03350 }
03351 }
03352 returnAST = expression_AST;
03353 }
03354
03355 void PascalParser::typedConstant() {
03356 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03357 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03358 RefPascalAST typedConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03359
03360 try {
03361 bool synPredMatched120 = false;
03362 if (((_tokenSet_33.member(LA(1))) && (_tokenSet_34.member(LA(2))))) {
03363 int _m120 = mark();
03364 synPredMatched120 = true;
03365 inputState->guessing++;
03366 try {
03367 {
03368 constant();
03369 }
03370 }
03371 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
03372 synPredMatched120 = false;
03373 }
03374 rewind(_m120);
03375 inputState->guessing--;
03376 }
03377 if ( synPredMatched120 ) {
03378 constant();
03379 if (inputState->guessing==0) {
03380 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03381 }
03382 typedConstant_AST = (currentAST.root);
03383 }
03384 else {
03385 bool synPredMatched122 = false;
03386 if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
03387 int _m122 = mark();
03388 synPredMatched122 = true;
03389 inputState->guessing++;
03390 try {
03391 {
03392 match(LPAREN);
03393 identifier();
03394 match(COLON);
03395 }
03396 }
03397 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
03398 synPredMatched122 = false;
03399 }
03400 rewind(_m122);
03401 inputState->guessing--;
03402 }
03403 if ( synPredMatched122 ) {
03404 recordConstant();
03405 if (inputState->guessing==0) {
03406 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03407 }
03408 typedConstant_AST = (currentAST.root);
03409 }
03410 else {
03411 bool synPredMatched124 = false;
03412 if (((LA(1) == LPAREN) && (_tokenSet_35.member(LA(2))))) {
03413 int _m124 = mark();
03414 synPredMatched124 = true;
03415 inputState->guessing++;
03416 try {
03417 {
03418 arrayConstant();
03419 }
03420 }
03421 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
03422 synPredMatched124 = false;
03423 }
03424 rewind(_m124);
03425 inputState->guessing--;
03426 }
03427 if ( synPredMatched124 ) {
03428 arrayConstant();
03429 if (inputState->guessing==0) {
03430 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03431 }
03432 typedConstant_AST = (currentAST.root);
03433 }
03434 else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_37.member(LA(2)))) {
03435 proceduralConstant();
03436 if (inputState->guessing==0) {
03437 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03438 }
03439 typedConstant_AST = (currentAST.root);
03440 }
03441 else {
03442 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03443 }
03444 }}
03445 }
03446 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03447 if( inputState->guessing == 0 ) {
03448 reportError(ex);
03449 consume();
03450 consumeUntil(_tokenSet_22);
03451 } else {
03452 throw;
03453 }
03454 }
03455 returnAST = typedConstant_AST;
03456 }
03457
03458 void PascalParser::constant() {
03459 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03460 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03461 RefPascalAST constant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03462 RefPascalAST s_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03463 RefPascalAST n_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03464 RefPascalAST s2_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03465 RefPascalAST id_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03466
03467 try {
03468 switch ( LA(1)) {
03469 case NUM_INT:
03470 case NUM_REAL:
03471 {
03472 unsignedNumber();
03473 if (inputState->guessing==0) {
03474 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03475 }
03476 constant_AST = (currentAST.root);
03477 break;
03478 }
03479 case IDENT:
03480 {
03481 identifier();
03482 if (inputState->guessing==0) {
03483 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03484 }
03485 constant_AST = (currentAST.root);
03486 break;
03487 }
03488 case STRING_LITERAL:
03489 {
03490 string();
03491 if (inputState->guessing==0) {
03492 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03493 }
03494 constant_AST = (currentAST.root);
03495 break;
03496 }
03497 case CHR:
03498 {
03499 constantChr();
03500 if (inputState->guessing==0) {
03501 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03502 }
03503 constant_AST = (currentAST.root);
03504 break;
03505 }
03506 default:
03507 if ((LA(1) == PLUS || LA(1) == MINUS) && (LA(2) == NUM_INT || LA(2) == NUM_REAL)) {
03508 sign();
03509 if (inputState->guessing==0) {
03510 s_AST = returnAST;
03511 }
03512 unsignedNumber();
03513 if (inputState->guessing==0) {
03514 n_AST = returnAST;
03515 }
03516 if ( inputState->guessing==0 ) {
03517 constant_AST = RefPascalAST(currentAST.root);
03518 #line 901 "pascal.g"
03519 constant_AST=RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(n_AST.get()))));
03520 #line 3521 "PascalParser.cpp"
03521 currentAST.root = constant_AST;
03522 if ( constant_AST!=static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03523 constant_AST->getFirstChild() != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03524 currentAST.child = constant_AST->getFirstChild();
03525 else
03526 currentAST.child = constant_AST;
03527 currentAST.advanceChildToEnd();
03528 }
03529 }
03530 else if ((LA(1) == PLUS || LA(1) == MINUS) && (LA(2) == IDENT)) {
03531 sign();
03532 if (inputState->guessing==0) {
03533 s2_AST = returnAST;
03534 }
03535 identifier();
03536 if (inputState->guessing==0) {
03537 id_AST = returnAST;
03538 }
03539 if ( inputState->guessing==0 ) {
03540 constant_AST = RefPascalAST(currentAST.root);
03541 #line 903 "pascal.g"
03542 constant_AST=RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(s2_AST.get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(id_AST.get()))));
03543 #line 3544 "PascalParser.cpp"
03544 currentAST.root = constant_AST;
03545 if ( constant_AST!=static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
03546 constant_AST->getFirstChild() != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03547 currentAST.child = constant_AST->getFirstChild();
03548 else
03549 currentAST.child = constant_AST;
03550 currentAST.advanceChildToEnd();
03551 }
03552 }
03553 else {
03554 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03555 }
03556 }
03557 }
03558 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03559 if( inputState->guessing == 0 ) {
03560 reportError(ex);
03561 consume();
03562 consumeUntil(_tokenSet_38);
03563 } else {
03564 throw;
03565 }
03566 }
03567 returnAST = constant_AST;
03568 }
03569
03570 void PascalParser::recordConstant() {
03571 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03572 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03573 RefPascalAST recordConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03574
03575 try {
03576 match(LPAREN);
03577 {
03578 identifier();
03579 if (inputState->guessing==0) {
03580 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03581 }
03582 match(COLON);
03583 constant();
03584 if (inputState->guessing==0) {
03585 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03586 }
03587 }
03588 {
03589 for (;;) {
03590 if ((LA(1) == SEMI)) {
03591 match(SEMI);
03592 {
03593 identifier();
03594 if (inputState->guessing==0) {
03595 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03596 }
03597 match(COLON);
03598 constant();
03599 if (inputState->guessing==0) {
03600 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03601 }
03602 }
03603 }
03604 else {
03605 goto _loop134;
03606 }
03607
03608 }
03609 _loop134:;
03610 }
03611 match(RPAREN);
03612 recordConstant_AST = (currentAST.root);
03613 }
03614 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03615 if( inputState->guessing == 0 ) {
03616 reportError(ex);
03617 consume();
03618 consumeUntil(_tokenSet_22);
03619 } else {
03620 throw;
03621 }
03622 }
03623 returnAST = recordConstant_AST;
03624 }
03625
03626 void PascalParser::arrayConstant() {
03627 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03628 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03629 RefPascalAST arrayConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03630
03631 try {
03632 match(LPAREN);
03633 {
03634 switch ( LA(1)) {
03635 case NUM_INT:
03636 case PLUS:
03637 case MINUS:
03638 case STRING_LITERAL:
03639 case CHR:
03640 case NUM_REAL:
03641 case IDENT:
03642 {
03643 constant();
03644 if (inputState->guessing==0) {
03645 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03646 }
03647 break;
03648 }
03649 case LPAREN:
03650 {
03651 arrayConstant();
03652 if (inputState->guessing==0) {
03653 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03654 }
03655 break;
03656 }
03657 default:
03658 {
03659 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03660 }
03661 }
03662 }
03663 {
03664 for (;;) {
03665 if ((LA(1) == COMMA)) {
03666 match(COMMA);
03667 {
03668 switch ( LA(1)) {
03669 case NUM_INT:
03670 case PLUS:
03671 case MINUS:
03672 case STRING_LITERAL:
03673 case CHR:
03674 case NUM_REAL:
03675 case IDENT:
03676 {
03677 constant();
03678 if (inputState->guessing==0) {
03679 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03680 }
03681 break;
03682 }
03683 case LPAREN:
03684 {
03685 arrayConstant();
03686 if (inputState->guessing==0) {
03687 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03688 }
03689 break;
03690 }
03691 default:
03692 {
03693 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03694 }
03695 }
03696 }
03697 }
03698 else {
03699 goto _loop129;
03700 }
03701
03702 }
03703 _loop129:;
03704 }
03705 match(RPAREN);
03706 arrayConstant_AST = (currentAST.root);
03707 }
03708 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03709 if( inputState->guessing == 0 ) {
03710 reportError(ex);
03711 consume();
03712 consumeUntil(_tokenSet_39);
03713 } else {
03714 throw;
03715 }
03716 }
03717 returnAST = arrayConstant_AST;
03718 }
03719
03720 void PascalParser::proceduralConstant() {
03721 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03722 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03723 RefPascalAST proceduralConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03724
03725 try {
03726 expression();
03727 if (inputState->guessing==0) {
03728 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03729 }
03730 proceduralConstant_AST = (currentAST.root);
03731 }
03732 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03733 if( inputState->guessing == 0 ) {
03734 reportError(ex);
03735 consume();
03736 consumeUntil(_tokenSet_22);
03737 } else {
03738 throw;
03739 }
03740 }
03741 returnAST = proceduralConstant_AST;
03742 }
03743
03744 void PascalParser::addressConstant() {
03745 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03746 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03747 RefPascalAST addressConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03748
03749 try {
03750 RefPascalAST tmp127_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03751 if ( inputState->guessing == 0 ) {
03752 tmp127_AST = astFactory->create(LT(1));
03753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp127_AST.get()));
03754 }
03755 match(NUM_INT);
03756 addressConstant_AST = (currentAST.root);
03757 }
03758 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03759 if( inputState->guessing == 0 ) {
03760 reportError(ex);
03761 consume();
03762 consumeUntil(_tokenSet_16);
03763 } else {
03764 throw;
03765 }
03766 }
03767 returnAST = addressConstant_AST;
03768 }
03769
03770 void PascalParser::simpleType() {
03771 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03772 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03773 RefPascalAST simpleType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03774
03775 try {
03776 switch ( LA(1)) {
03777 case INTEGER:
03778 case SHORTINT:
03779 case SMALLINT:
03780 case LONGINT:
03781 case INT64:
03782 case BYTE:
03783 case WORD:
03784 case CARDINAL:
03785 case QWORD:
03786 case BOOLEAN:
03787 case BYTEBOOL:
03788 case LONGBOOL:
03789 case CHAR:
03790 {
03791 ordinalType();
03792 if (inputState->guessing==0) {
03793 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03794 }
03795 simpleType_AST = (currentAST.root);
03796 break;
03797 }
03798 case REAL:
03799 case SINGLE:
03800 case DOUBLE:
03801 case EXTENDED:
03802 case COMP:
03803 {
03804 realType();
03805 if (inputState->guessing==0) {
03806 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03807 }
03808 simpleType_AST = (currentAST.root);
03809 break;
03810 }
03811 default:
03812 {
03813 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03814 }
03815 }
03816 }
03817 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03818 if( inputState->guessing == 0 ) {
03819 reportError(ex);
03820 consume();
03821 consumeUntil(_tokenSet_23);
03822 } else {
03823 throw;
03824 }
03825 }
03826 returnAST = simpleType_AST;
03827 }
03828
03829 void PascalParser::subrangeTypeOrTypeIdentifier() {
03830 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03831 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03832 RefPascalAST subrangeTypeOrTypeIdentifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03833
03834 try {
03835 constant();
03836 if (inputState->guessing==0) {
03837 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03838 }
03839 {
03840 switch ( LA(1)) {
03841 case DOTDOT:
03842 {
03843 match(DOTDOT);
03844 constant();
03845 if (inputState->guessing==0) {
03846 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03847 }
03848 break;
03849 }
03850 case SEMI:
03851 case RPAREN:
03852 case EQUAL:
03853 case RBRACK:
03854 {
03855 break;
03856 }
03857 default:
03858 {
03859 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03860 }
03861 }
03862 }
03863 subrangeTypeOrTypeIdentifier_AST = (currentAST.root);
03864 }
03865 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03866 if( inputState->guessing == 0 ) {
03867 reportError(ex);
03868 consume();
03869 consumeUntil(_tokenSet_23);
03870 } else {
03871 throw;
03872 }
03873 }
03874 returnAST = subrangeTypeOrTypeIdentifier_AST;
03875 }
03876
03877 void PascalParser::enumeratedType() {
03878 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03879 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03880 RefPascalAST enumeratedType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03881
03882 try {
03883 bool synPredMatched147 = false;
03884 if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
03885 int _m147 = mark();
03886 synPredMatched147 = true;
03887 inputState->guessing++;
03888 try {
03889 {
03890 match(LPAREN);
03891 identifier();
03892 match(ASSIGN);
03893 }
03894 }
03895 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
03896 synPredMatched147 = false;
03897 }
03898 rewind(_m147);
03899 inputState->guessing--;
03900 }
03901 if ( synPredMatched147 ) {
03902 match(LPAREN);
03903 assignedEnumList();
03904 if (inputState->guessing==0) {
03905 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03906 }
03907 match(RPAREN);
03908 enumeratedType_AST = (currentAST.root);
03909 }
03910 else if ((LA(1) == LPAREN) && (LA(2) == IDENT)) {
03911 match(LPAREN);
03912 identifierList();
03913 if (inputState->guessing==0) {
03914 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03915 }
03916 match(RPAREN);
03917 enumeratedType_AST = (currentAST.root);
03918 }
03919 else {
03920 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03921 }
03922
03923 }
03924 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03925 if( inputState->guessing == 0 ) {
03926 reportError(ex);
03927 consume();
03928 consumeUntil(_tokenSet_40);
03929 } else {
03930 throw;
03931 }
03932 }
03933 returnAST = enumeratedType_AST;
03934 }
03935
03936 void PascalParser::stringType() {
03937 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03938 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03939 RefPascalAST stringType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03940
03941 try {
03942 RefPascalAST tmp133_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03943 if ( inputState->guessing == 0 ) {
03944 tmp133_AST = astFactory->create(LT(1));
03945 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp133_AST.get()));
03946 }
03947 match(STRING);
03948 {
03949 switch ( LA(1)) {
03950 case LBRACK:
03951 {
03952 match(LBRACK);
03953 unsignedInteger();
03954 if (inputState->guessing==0) {
03955 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
03956 }
03957 match(RBRACK);
03958 break;
03959 }
03960 case SEMI:
03961 case RPAREN:
03962 case EQUAL:
03963 case RBRACK:
03964 {
03965 break;
03966 }
03967 default:
03968 {
03969 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
03970 }
03971 }
03972 }
03973 stringType_AST = (currentAST.root);
03974 }
03975 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03976 if( inputState->guessing == 0 ) {
03977 reportError(ex);
03978 consume();
03979 consumeUntil(_tokenSet_23);
03980 } else {
03981 throw;
03982 }
03983 }
03984 returnAST = stringType_AST;
03985 }
03986
03987 void PascalParser::structuredType() {
03988 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03989 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
03990 RefPascalAST structuredType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
03991
03992 try {
03993 {
03994 switch ( LA(1)) {
03995 case PACKED:
03996 {
03997 match(PACKED);
03998 break;
03999 }
04000 case ARRAY:
04001 case RECORD:
04002 case SET:
04003 case FILE:
04004 case OBJECT:
04005 case CLASS:
04006 {
04007 break;
04008 }
04009 default:
04010 {
04011 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04012 }
04013 }
04014 }
04015 {
04016 switch ( LA(1)) {
04017 case ARRAY:
04018 {
04019 arrayType();
04020 if (inputState->guessing==0) {
04021 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04022 }
04023 break;
04024 }
04025 case RECORD:
04026 {
04027 recordType();
04028 if (inputState->guessing==0) {
04029 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04030 }
04031 break;
04032 }
04033 case OBJECT:
04034 {
04035 objectType();
04036 if (inputState->guessing==0) {
04037 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04038 }
04039 break;
04040 }
04041 case CLASS:
04042 {
04043 classType();
04044 if (inputState->guessing==0) {
04045 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04046 }
04047 break;
04048 }
04049 case SET:
04050 {
04051 setType();
04052 if (inputState->guessing==0) {
04053 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04054 }
04055 break;
04056 }
04057 case FILE:
04058 {
04059 fileType();
04060 if (inputState->guessing==0) {
04061 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04062 }
04063 break;
04064 }
04065 default:
04066 {
04067 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04068 }
04069 }
04070 }
04071 structuredType_AST = (currentAST.root);
04072 }
04073 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04074 if( inputState->guessing == 0 ) {
04075 reportError(ex);
04076 consume();
04077 consumeUntil(_tokenSet_23);
04078 } else {
04079 throw;
04080 }
04081 }
04082 returnAST = structuredType_AST;
04083 }
04084
04085 void PascalParser::pointerType() {
04086 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04087 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04088 RefPascalAST pointerType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04089
04090 try {
04091 RefPascalAST tmp137_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04092 if ( inputState->guessing == 0 ) {
04093 tmp137_AST = astFactory->create(LT(1));
04094 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp137_AST.get()));
04095 }
04096 match(POINTER);
04097 typeIdentifier();
04098 if (inputState->guessing==0) {
04099 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04100 }
04101 pointerType_AST = (currentAST.root);
04102 }
04103 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04104 if( inputState->guessing == 0 ) {
04105 reportError(ex);
04106 consume();
04107 consumeUntil(_tokenSet_23);
04108 } else {
04109 throw;
04110 }
04111 }
04112 returnAST = pointerType_AST;
04113 }
04114
04115 void PascalParser::proceduralType() {
04116 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04117 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04118 RefPascalAST proceduralType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04119
04120 try {
04121 bool synPredMatched185 = false;
04122 if (((LA(1) == PROCEDURE || LA(1) == FUNCTION) && (LA(2) == IDENT))) {
04123 int _m185 = mark();
04124 synPredMatched185 = true;
04125 inputState->guessing++;
04126 try {
04127 {
04128 proceduralTypePart1();
04129 match(SEMI);
04130 }
04131 }
04132 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
04133 synPredMatched185 = false;
04134 }
04135 rewind(_m185);
04136 inputState->guessing--;
04137 }
04138 if ( synPredMatched185 ) {
04139 proceduralTypePart1();
04140 if (inputState->guessing==0) {
04141 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04142 }
04143 match(SEMI);
04144 callModifiers();
04145 if (inputState->guessing==0) {
04146 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04147 }
04148 proceduralType_AST = (currentAST.root);
04149 }
04150 else if ((LA(1) == PROCEDURE || LA(1) == FUNCTION) && (LA(2) == IDENT)) {
04151 proceduralTypePart1();
04152 if (inputState->guessing==0) {
04153 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04154 }
04155 proceduralType_AST = (currentAST.root);
04156 }
04157 else {
04158 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04159 }
04160
04161 }
04162 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04163 if( inputState->guessing == 0 ) {
04164 reportError(ex);
04165 consume();
04166 consumeUntil(_tokenSet_23);
04167 } else {
04168 throw;
04169 }
04170 }
04171 returnAST = proceduralType_AST;
04172 }
04173
04174 void PascalParser::ordinalType() {
04175 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04176 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04177 RefPascalAST ordinalType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04178
04179 try {
04180 switch ( LA(1)) {
04181 case INTEGER:
04182 {
04183 match(INTEGER);
04184 ordinalType_AST = (currentAST.root);
04185 break;
04186 }
04187 case SHORTINT:
04188 {
04189 match(SHORTINT);
04190 ordinalType_AST = (currentAST.root);
04191 break;
04192 }
04193 case SMALLINT:
04194 {
04195 match(SMALLINT);
04196 ordinalType_AST = (currentAST.root);
04197 break;
04198 }
04199 case LONGINT:
04200 {
04201 match(LONGINT);
04202 ordinalType_AST = (currentAST.root);
04203 break;
04204 }
04205 case INT64:
04206 {
04207 match(INT64);
04208 ordinalType_AST = (currentAST.root);
04209 break;
04210 }
04211 case BYTE:
04212 {
04213 match(BYTE);
04214 ordinalType_AST = (currentAST.root);
04215 break;
04216 }
04217 case WORD:
04218 {
04219 match(WORD);
04220 ordinalType_AST = (currentAST.root);
04221 break;
04222 }
04223 case CARDINAL:
04224 {
04225 match(CARDINAL);
04226 ordinalType_AST = (currentAST.root);
04227 break;
04228 }
04229 case QWORD:
04230 {
04231 match(QWORD);
04232 ordinalType_AST = (currentAST.root);
04233 break;
04234 }
04235 case BOOLEAN:
04236 {
04237 match(BOOLEAN);
04238 ordinalType_AST = (currentAST.root);
04239 break;
04240 }
04241 case BYTEBOOL:
04242 {
04243 match(BYTEBOOL);
04244 ordinalType_AST = (currentAST.root);
04245 break;
04246 }
04247 case LONGBOOL:
04248 {
04249 match(LONGBOOL);
04250 ordinalType_AST = (currentAST.root);
04251 break;
04252 }
04253 case CHAR:
04254 {
04255 match(CHAR);
04256 ordinalType_AST = (currentAST.root);
04257 break;
04258 }
04259 default:
04260 {
04261 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04262 }
04263 }
04264 }
04265 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04266 if( inputState->guessing == 0 ) {
04267 reportError(ex);
04268 consume();
04269 consumeUntil(_tokenSet_40);
04270 } else {
04271 throw;
04272 }
04273 }
04274 returnAST = ordinalType_AST;
04275 }
04276
04277 void PascalParser::realType() {
04278 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04279 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04280 RefPascalAST realType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04281
04282 try {
04283 switch ( LA(1)) {
04284 case REAL:
04285 {
04286 match(REAL);
04287 realType_AST = (currentAST.root);
04288 break;
04289 }
04290 case SINGLE:
04291 {
04292 match(SINGLE);
04293 realType_AST = (currentAST.root);
04294 break;
04295 }
04296 case DOUBLE:
04297 {
04298 match(DOUBLE);
04299 realType_AST = (currentAST.root);
04300 break;
04301 }
04302 case EXTENDED:
04303 {
04304 match(EXTENDED);
04305 realType_AST = (currentAST.root);
04306 break;
04307 }
04308 case COMP:
04309 {
04310 match(COMP);
04311 realType_AST = (currentAST.root);
04312 break;
04313 }
04314 default:
04315 {
04316 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04317 }
04318 }
04319 }
04320 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04321 if( inputState->guessing == 0 ) {
04322 reportError(ex);
04323 consume();
04324 consumeUntil(_tokenSet_23);
04325 } else {
04326 throw;
04327 }
04328 }
04329 returnAST = realType_AST;
04330 }
04331
04332 void PascalParser::typeIdentifier() {
04333 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04334 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04335 RefPascalAST typeIdentifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04336
04337 try {
04338 identifier();
04339 if (inputState->guessing==0) {
04340 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04341 }
04342 typeIdentifier_AST = (currentAST.root);
04343 }
04344 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04345 if( inputState->guessing == 0 ) {
04346 reportError(ex);
04347 consume();
04348 consumeUntil(_tokenSet_41);
04349 } else {
04350 throw;
04351 }
04352 }
04353 returnAST = typeIdentifier_AST;
04354 }
04355
04356 void PascalParser::subrangeType() {
04357 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04358 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04359 RefPascalAST subrangeType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04360
04361 try {
04362 constant();
04363 if (inputState->guessing==0) {
04364 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04365 }
04366 match(DOTDOT);
04367 constant();
04368 if (inputState->guessing==0) {
04369 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04370 }
04371 subrangeType_AST = (currentAST.root);
04372 }
04373 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04374 if( inputState->guessing == 0 ) {
04375 reportError(ex);
04376 consume();
04377 consumeUntil(_tokenSet_0);
04378 } else {
04379 throw;
04380 }
04381 }
04382 returnAST = subrangeType_AST;
04383 }
04384
04385 void PascalParser::assignedEnumList() {
04386 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04387 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04388 RefPascalAST assignedEnumList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04389
04390 try {
04391 {
04392 identifier();
04393 if (inputState->guessing==0) {
04394 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04395 }
04396 match(ASSIGN);
04397 expression();
04398 if (inputState->guessing==0) {
04399 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04400 }
04401 }
04402 {
04403 for (;;) {
04404 if ((LA(1) == COMMA)) {
04405 match(COMMA);
04406 {
04407 identifier();
04408 if (inputState->guessing==0) {
04409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04410 }
04411 match(ASSIGN);
04412 expression();
04413 if (inputState->guessing==0) {
04414 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04415 }
04416 }
04417 }
04418 else {
04419 goto _loop152;
04420 }
04421
04422 }
04423 _loop152:;
04424 }
04425 assignedEnumList_AST = (currentAST.root);
04426 }
04427 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04428 if( inputState->guessing == 0 ) {
04429 reportError(ex);
04430 consume();
04431 consumeUntil(_tokenSet_42);
04432 } else {
04433 throw;
04434 }
04435 }
04436 returnAST = assignedEnumList_AST;
04437 }
04438
04439 void PascalParser::unsignedInteger() {
04440 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04441 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04442 RefPascalAST unsignedInteger_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04443
04444 try {
04445 RefPascalAST tmp161_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04446 if ( inputState->guessing == 0 ) {
04447 tmp161_AST = astFactory->create(LT(1));
04448 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp161_AST.get()));
04449 }
04450 match(NUM_INT);
04451 unsignedInteger_AST = (currentAST.root);
04452 }
04453 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04454 if( inputState->guessing == 0 ) {
04455 reportError(ex);
04456 consume();
04457 consumeUntil(_tokenSet_43);
04458 } else {
04459 throw;
04460 }
04461 }
04462 returnAST = unsignedInteger_AST;
04463 }
04464
04465 void PascalParser::arrayType() {
04466 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04467 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04468 RefPascalAST arrayType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04469
04470 try {
04471 RefPascalAST tmp162_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04472 if ( inputState->guessing == 0 ) {
04473 tmp162_AST = astFactory->create(LT(1));
04474 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp162_AST.get()));
04475 }
04476 match(ARRAY);
04477 match(LBRACK);
04478 arrayIndexType();
04479 if (inputState->guessing==0) {
04480 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04481 }
04482 {
04483 for (;;) {
04484 if ((LA(1) == COMMA)) {
04485 match(COMMA);
04486 arrayIndexType();
04487 if (inputState->guessing==0) {
04488 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04489 }
04490 }
04491 else {
04492 goto _loop161;
04493 }
04494
04495 }
04496 _loop161:;
04497 }
04498 match(RBRACK);
04499 match(OF);
04500 type();
04501 if (inputState->guessing==0) {
04502 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04503 }
04504 arrayType_AST = (currentAST.root);
04505 }
04506 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04507 if( inputState->guessing == 0 ) {
04508 reportError(ex);
04509 consume();
04510 consumeUntil(_tokenSet_23);
04511 } else {
04512 throw;
04513 }
04514 }
04515 returnAST = arrayType_AST;
04516 }
04517
04518 void PascalParser::recordType() {
04519 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04520 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04521 RefPascalAST recordType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04522
04523 try {
04524 RefPascalAST tmp167_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04525 if ( inputState->guessing == 0 ) {
04526 tmp167_AST = astFactory->create(LT(1));
04527 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp167_AST.get()));
04528 }
04529 match(RECORD);
04530 {
04531 for (;;) {
04532 if ((LA(1) == CASE || LA(1) == IDENT)) {
04533 fieldList();
04534 if (inputState->guessing==0) {
04535 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04536 }
04537 }
04538 else {
04539 goto _loop168;
04540 }
04541
04542 }
04543 _loop168:;
04544 }
04545 match(END);
04546 recordType_AST = (currentAST.root);
04547 }
04548 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04549 if( inputState->guessing == 0 ) {
04550 reportError(ex);
04551 consume();
04552 consumeUntil(_tokenSet_23);
04553 } else {
04554 throw;
04555 }
04556 }
04557 returnAST = recordType_AST;
04558 }
04559
04560 void PascalParser::objectType() {
04561 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04562 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04563 RefPascalAST objectType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04564
04565 try {
04566 RefPascalAST tmp169_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04567 if ( inputState->guessing == 0 ) {
04568 tmp169_AST = astFactory->create(LT(1));
04569 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp169_AST.get()));
04570 }
04571 match(OBJECT);
04572 {
04573 switch ( LA(1)) {
04574 case LPAREN:
04575 {
04576 heritage();
04577 if (inputState->guessing==0) {
04578 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04579 }
04580 break;
04581 }
04582 case END:
04583 case PROCEDURE:
04584 case FUNCTION:
04585 case PUBLIC:
04586 case PRIVATE:
04587 case PROTECTED:
04588 case CONSTRUCTOR:
04589 case DESTRUCTOR:
04590 case IDENT:
04591 {
04592 break;
04593 }
04594 default:
04595 {
04596 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04597 }
04598 }
04599 }
04600 {
04601 switch ( LA(1)) {
04602 case END:
04603 case PROCEDURE:
04604 case FUNCTION:
04605 case CONSTRUCTOR:
04606 case DESTRUCTOR:
04607 case IDENT:
04608 {
04609 componentList();
04610 if (inputState->guessing==0) {
04611 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04612 }
04613 break;
04614 }
04615 case PUBLIC:
04616 case PRIVATE:
04617 case PROTECTED:
04618 {
04619 objectVisibilitySpecifier();
04620 if (inputState->guessing==0) {
04621 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04622 }
04623 break;
04624 }
04625 default:
04626 {
04627 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04628 }
04629 }
04630 }
04631 match(END);
04632 objectType_AST = (currentAST.root);
04633 }
04634 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04635 if( inputState->guessing == 0 ) {
04636 reportError(ex);
04637 consume();
04638 consumeUntil(_tokenSet_23);
04639 } else {
04640 throw;
04641 }
04642 }
04643 returnAST = objectType_AST;
04644 }
04645
04646 void PascalParser::classType() {
04647 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04648 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04649 RefPascalAST classType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04650
04651 try {
04652 RefPascalAST tmp171_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04653 if ( inputState->guessing == 0 ) {
04654 tmp171_AST = astFactory->create(LT(1));
04655 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp171_AST.get()));
04656 }
04657 match(CLASS);
04658 {
04659 switch ( LA(1)) {
04660 case LPAREN:
04661 {
04662 heritage();
04663 if (inputState->guessing==0) {
04664 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04665 }
04666 break;
04667 }
04668 case END:
04669 case PROCEDURE:
04670 case FUNCTION:
04671 case PUBLIC:
04672 case PRIVATE:
04673 case PROTECTED:
04674 case CONSTRUCTOR:
04675 case DESTRUCTOR:
04676 case CLASS:
04677 case PUBLISHED:
04678 case PROPERTY:
04679 case IDENT:
04680 {
04681 break;
04682 }
04683 default:
04684 {
04685 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04686 }
04687 }
04688 }
04689 {
04690 switch ( LA(1)) {
04691 case END:
04692 case PROCEDURE:
04693 case FUNCTION:
04694 case CONSTRUCTOR:
04695 case DESTRUCTOR:
04696 case CLASS:
04697 case PROPERTY:
04698 case IDENT:
04699 {
04700 classComponentList();
04701 if (inputState->guessing==0) {
04702 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04703 }
04704 break;
04705 }
04706 case PUBLIC:
04707 case PRIVATE:
04708 case PROTECTED:
04709 case PUBLISHED:
04710 {
04711 classVisibilitySpecifier();
04712 if (inputState->guessing==0) {
04713 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04714 }
04715 break;
04716 }
04717 default:
04718 {
04719 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04720 }
04721 }
04722 }
04723 match(END);
04724 classType_AST = (currentAST.root);
04725 }
04726 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04727 if( inputState->guessing == 0 ) {
04728 reportError(ex);
04729 consume();
04730 consumeUntil(_tokenSet_23);
04731 } else {
04732 throw;
04733 }
04734 }
04735 returnAST = classType_AST;
04736 }
04737
04738 void PascalParser::setType() {
04739 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04740 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04741 RefPascalAST setType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04742
04743 try {
04744 RefPascalAST tmp173_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04745 if ( inputState->guessing == 0 ) {
04746 tmp173_AST = astFactory->create(LT(1));
04747 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp173_AST.get()));
04748 }
04749 match(SET);
04750 match(OF);
04751 ordinalType();
04752 if (inputState->guessing==0) {
04753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04754 }
04755 setType_AST = (currentAST.root);
04756 }
04757 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04758 if( inputState->guessing == 0 ) {
04759 reportError(ex);
04760 consume();
04761 consumeUntil(_tokenSet_23);
04762 } else {
04763 throw;
04764 }
04765 }
04766 returnAST = setType_AST;
04767 }
04768
04769 void PascalParser::fileType() {
04770 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04771 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04772 RefPascalAST fileType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04773
04774 try {
04775 RefPascalAST tmp175_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04776 if ( inputState->guessing == 0 ) {
04777 tmp175_AST = astFactory->create(LT(1));
04778 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp175_AST.get()));
04779 }
04780 match(FILE);
04781 match(OF);
04782 type();
04783 if (inputState->guessing==0) {
04784 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04785 }
04786 fileType_AST = (currentAST.root);
04787 }
04788 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04789 if( inputState->guessing == 0 ) {
04790 reportError(ex);
04791 consume();
04792 consumeUntil(_tokenSet_23);
04793 } else {
04794 throw;
04795 }
04796 }
04797 returnAST = fileType_AST;
04798 }
04799
04800 void PascalParser::arrayIndexType() {
04801 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04802 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04803 RefPascalAST arrayIndexType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04804
04805 try {
04806 if (((LA(1) >= INTEGER && LA(1) <= CHAR))) {
04807 ordinalType();
04808 if (inputState->guessing==0) {
04809 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04810 }
04811 arrayIndexType_AST = (currentAST.root);
04812 }
04813 else {
04814 bool synPredMatched164 = false;
04815 if (((_tokenSet_36.member(LA(1))) && (_tokenSet_44.member(LA(2))))) {
04816 int _m164 = mark();
04817 synPredMatched164 = true;
04818 inputState->guessing++;
04819 try {
04820 {
04821 expression();
04822 match(DOTDOT);
04823 }
04824 }
04825 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
04826 synPredMatched164 = false;
04827 }
04828 rewind(_m164);
04829 inputState->guessing--;
04830 }
04831 if ( synPredMatched164 ) {
04832 arraySubrangeType();
04833 if (inputState->guessing==0) {
04834 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04835 }
04836 arrayIndexType_AST = (currentAST.root);
04837 }
04838 else if ((LA(1) == LPAREN) && (LA(2) == IDENT)) {
04839 enumeratedType();
04840 if (inputState->guessing==0) {
04841 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04842 }
04843 arrayIndexType_AST = (currentAST.root);
04844 }
04845 else {
04846 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04847 }
04848 }
04849 }
04850 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04851 if( inputState->guessing == 0 ) {
04852 reportError(ex);
04853 consume();
04854 consumeUntil(_tokenSet_45);
04855 } else {
04856 throw;
04857 }
04858 }
04859 returnAST = arrayIndexType_AST;
04860 }
04861
04862 void PascalParser::arraySubrangeType() {
04863 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04864 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04865 RefPascalAST arraySubrangeType_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04866
04867 try {
04868 expression();
04869 if (inputState->guessing==0) {
04870 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04871 }
04872 match(DOTDOT);
04873 expression();
04874 if (inputState->guessing==0) {
04875 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04876 }
04877 arraySubrangeType_AST = (currentAST.root);
04878 }
04879 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04880 if( inputState->guessing == 0 ) {
04881 reportError(ex);
04882 consume();
04883 consumeUntil(_tokenSet_45);
04884 } else {
04885 throw;
04886 }
04887 }
04888 returnAST = arraySubrangeType_AST;
04889 }
04890
04891 void PascalParser::fieldList() {
04892 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04893 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04894 RefPascalAST fieldList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04895
04896 try {
04897 switch ( LA(1)) {
04898 case IDENT:
04899 {
04900 fixedField();
04901 if (inputState->guessing==0) {
04902 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04903 }
04904 fieldList_AST = (currentAST.root);
04905 break;
04906 }
04907 case CASE:
04908 {
04909 variantPart();
04910 if (inputState->guessing==0) {
04911 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04912 }
04913 fieldList_AST = (currentAST.root);
04914 break;
04915 }
04916 default:
04917 {
04918 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04919 }
04920 }
04921 }
04922 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04923 if( inputState->guessing == 0 ) {
04924 reportError(ex);
04925 consume();
04926 consumeUntil(_tokenSet_46);
04927 } else {
04928 throw;
04929 }
04930 }
04931 returnAST = fieldList_AST;
04932 }
04933
04934 void PascalParser::fixedField() {
04935 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04936 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04937 RefPascalAST fixedField_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04938
04939 try {
04940 identifierList();
04941 if (inputState->guessing==0) {
04942 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04943 }
04944 match(COLON);
04945 type();
04946 if (inputState->guessing==0) {
04947 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04948 }
04949 match(SEMI);
04950 fixedField_AST = (currentAST.root);
04951 }
04952 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
04953 if( inputState->guessing == 0 ) {
04954 reportError(ex);
04955 consume();
04956 consumeUntil(_tokenSet_46);
04957 } else {
04958 throw;
04959 }
04960 }
04961 returnAST = fixedField_AST;
04962 }
04963
04964 void PascalParser::variantPart() {
04965 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04966 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
04967 RefPascalAST variantPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04968
04969 try {
04970 RefPascalAST tmp180_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
04971 if ( inputState->guessing == 0 ) {
04972 tmp180_AST = astFactory->create(LT(1));
04973 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp180_AST.get()));
04974 }
04975 match(CASE);
04976 {
04977 if ((LA(1) == IDENT) && (LA(2) == COLON)) {
04978 identifier();
04979 if (inputState->guessing==0) {
04980 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04981 }
04982 match(COLON);
04983 }
04984 else if ((LA(1) == IDENT) && (LA(2) == OF)) {
04985 }
04986 else {
04987 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
04988 }
04989
04990 }
04991 identifier();
04992 if (inputState->guessing==0) {
04993 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04994 }
04995 match(OF);
04996 variant();
04997 if (inputState->guessing==0) {
04998 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
04999 }
05000 {
05001 for (;;) {
05002 if ((LA(1) == SEMI)) {
05003 match(SEMI);
05004 variant();
05005 if (inputState->guessing==0) {
05006 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05007 }
05008 }
05009 else {
05010 goto _loop174;
05011 }
05012
05013 }
05014 _loop174:;
05015 }
05016 variantPart_AST = (currentAST.root);
05017 }
05018 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05019 if( inputState->guessing == 0 ) {
05020 reportError(ex);
05021 consume();
05022 consumeUntil(_tokenSet_46);
05023 } else {
05024 throw;
05025 }
05026 }
05027 returnAST = variantPart_AST;
05028 }
05029
05030 void PascalParser::variant() {
05031 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05032 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05033 RefPascalAST variant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05034
05035 try {
05036 {
05037 int _cnt177=0;
05038 for (;;) {
05039 if ((_tokenSet_33.member(LA(1)))) {
05040 constant();
05041 if (inputState->guessing==0) {
05042 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05043 }
05044 match(COMMA);
05045 }
05046 else {
05047 if ( _cnt177>=1 ) { goto _loop177; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
05048 }
05049
05050 _cnt177++;
05051 }
05052 _loop177:;
05053 }
05054 match(COLON);
05055 match(LPAREN);
05056 {
05057 for (;;) {
05058 if ((LA(1) == CASE || LA(1) == IDENT)) {
05059 fieldList();
05060 if (inputState->guessing==0) {
05061 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05062 }
05063 }
05064 else {
05065 goto _loop179;
05066 }
05067
05068 }
05069 _loop179:;
05070 }
05071 match(RPAREN);
05072 variant_AST = (currentAST.root);
05073 }
05074 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05075 if( inputState->guessing == 0 ) {
05076 reportError(ex);
05077 consume();
05078 consumeUntil(_tokenSet_47);
05079 } else {
05080 throw;
05081 }
05082 }
05083 returnAST = variant_AST;
05084 }
05085
05086 void PascalParser::proceduralTypePart1() {
05087 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05088 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05089 RefPascalAST proceduralTypePart1_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05090
05091 try {
05092 {
05093 switch ( LA(1)) {
05094 case FUNCTION:
05095 {
05096 functionHeader();
05097 if (inputState->guessing==0) {
05098 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05099 }
05100 break;
05101 }
05102 case PROCEDURE:
05103 {
05104 procedureHeader();
05105 if (inputState->guessing==0) {
05106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05107 }
05108 break;
05109 }
05110 default:
05111 {
05112 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05113 }
05114 }
05115 }
05116 {
05117 switch ( LA(1)) {
05118 case OF:
05119 {
05120 match(OF);
05121 match(OBJECT);
05122 break;
05123 }
05124 case SEMI:
05125 case RPAREN:
05126 case EQUAL:
05127 case RBRACK:
05128 {
05129 break;
05130 }
05131 default:
05132 {
05133 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05134 }
05135 }
05136 }
05137 proceduralTypePart1_AST = (currentAST.root);
05138 }
05139 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05140 if( inputState->guessing == 0 ) {
05141 reportError(ex);
05142 consume();
05143 consumeUntil(_tokenSet_23);
05144 } else {
05145 throw;
05146 }
05147 }
05148 returnAST = proceduralTypePart1_AST;
05149 }
05150
05151 void PascalParser::heritage() {
05152 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05153 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05154 RefPascalAST heritage_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05155
05156 try {
05157 match(LPAREN);
05158 identifier();
05159 if (inputState->guessing==0) {
05160 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05161 }
05162 match(RPAREN);
05163 heritage_AST = (currentAST.root);
05164 }
05165 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05166 if( inputState->guessing == 0 ) {
05167 reportError(ex);
05168 consume();
05169 consumeUntil(_tokenSet_48);
05170 } else {
05171 throw;
05172 }
05173 }
05174 returnAST = heritage_AST;
05175 }
05176
05177 void PascalParser::componentList() {
05178 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05179 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05180 RefPascalAST componentList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05181
05182 try {
05183 {
05184 switch ( LA(1)) {
05185 case IDENT:
05186 {
05187 {
05188 int _cnt196=0;
05189 for (;;) {
05190 if ((LA(1) == IDENT)) {
05191 fieldDefinition();
05192 if (inputState->guessing==0) {
05193 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05194 }
05195 }
05196 else {
05197 if ( _cnt196>=1 ) { goto _loop196; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
05198 }
05199
05200 _cnt196++;
05201 }
05202 _loop196:;
05203 }
05204 break;
05205 }
05206 case END:
05207 case PROCEDURE:
05208 case FUNCTION:
05209 case CONSTRUCTOR:
05210 case DESTRUCTOR:
05211 {
05212 break;
05213 }
05214 default:
05215 {
05216 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05217 }
05218 }
05219 }
05220 {
05221 switch ( LA(1)) {
05222 case PROCEDURE:
05223 case FUNCTION:
05224 case CONSTRUCTOR:
05225 case DESTRUCTOR:
05226 {
05227 {
05228 int _cnt199=0;
05229 for (;;) {
05230 if ((_tokenSet_49.member(LA(1)))) {
05231 methodDefinition();
05232 if (inputState->guessing==0) {
05233 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05234 }
05235 }
05236 else {
05237 if ( _cnt199>=1 ) { goto _loop199; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
05238 }
05239
05240 _cnt199++;
05241 }
05242 _loop199:;
05243 }
05244 break;
05245 }
05246 case END:
05247 {
05248 break;
05249 }
05250 default:
05251 {
05252 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05253 }
05254 }
05255 }
05256 componentList_AST = (currentAST.root);
05257 }
05258 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05259 if( inputState->guessing == 0 ) {
05260 reportError(ex);
05261 consume();
05262 consumeUntil(_tokenSet_6);
05263 } else {
05264 throw;
05265 }
05266 }
05267 returnAST = componentList_AST;
05268 }
05269
05270 void PascalParser::objectVisibilitySpecifier() {
05271 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05272 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05273 RefPascalAST objectVisibilitySpecifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05274
05275 try {
05276 switch ( LA(1)) {
05277 case PRIVATE:
05278 {
05279 match(PRIVATE);
05280 objectVisibilitySpecifier_AST = (currentAST.root);
05281 break;
05282 }
05283 case PROTECTED:
05284 {
05285 match(PROTECTED);
05286 objectVisibilitySpecifier_AST = (currentAST.root);
05287 break;
05288 }
05289 case PUBLIC:
05290 {
05291 match(PUBLIC);
05292 objectVisibilitySpecifier_AST = (currentAST.root);
05293 break;
05294 }
05295 default:
05296 {
05297 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05298 }
05299 }
05300 }
05301 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05302 if( inputState->guessing == 0 ) {
05303 reportError(ex);
05304 consume();
05305 consumeUntil(_tokenSet_6);
05306 } else {
05307 throw;
05308 }
05309 }
05310 returnAST = objectVisibilitySpecifier_AST;
05311 }
05312
05313 void PascalParser::fieldDefinition() {
05314 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05315 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05316 RefPascalAST fieldDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05317
05318 try {
05319 identifierList();
05320 if (inputState->guessing==0) {
05321 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05322 }
05323 match(COLON);
05324 type();
05325 if (inputState->guessing==0) {
05326 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05327 }
05328 match(SEMI);
05329 fieldDefinition_AST = (currentAST.root);
05330 }
05331 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05332 if( inputState->guessing == 0 ) {
05333 reportError(ex);
05334 consume();
05335 consumeUntil(_tokenSet_50);
05336 } else {
05337 throw;
05338 }
05339 }
05340 returnAST = fieldDefinition_AST;
05341 }
05342
05343 void PascalParser::methodDefinition() {
05344 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05345 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05346 RefPascalAST methodDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05347
05348 try {
05349 {
05350 switch ( LA(1)) {
05351 case FUNCTION:
05352 {
05353 functionHeader();
05354 if (inputState->guessing==0) {
05355 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05356 }
05357 break;
05358 }
05359 case PROCEDURE:
05360 {
05361 procedureHeader();
05362 if (inputState->guessing==0) {
05363 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05364 }
05365 break;
05366 }
05367 case CONSTRUCTOR:
05368 {
05369 constructorHeader();
05370 if (inputState->guessing==0) {
05371 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05372 }
05373 break;
05374 }
05375 case DESTRUCTOR:
05376 {
05377 destructorHeader();
05378 if (inputState->guessing==0) {
05379 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05380 }
05381 break;
05382 }
05383 default:
05384 {
05385 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05386 }
05387 }
05388 }
05389 match(SEMI);
05390 methodDirectives();
05391 if (inputState->guessing==0) {
05392 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05393 }
05394 methodDefinition_AST = (currentAST.root);
05395 }
05396 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05397 if( inputState->guessing == 0 ) {
05398 reportError(ex);
05399 consume();
05400 consumeUntil(_tokenSet_51);
05401 } else {
05402 throw;
05403 }
05404 }
05405 returnAST = methodDefinition_AST;
05406 }
05407
05408 void PascalParser::constructorHeader() {
05409 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05410 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05411 RefPascalAST constructorHeader_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05412
05413 try {
05414 RefPascalAST tmp198_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05415 if ( inputState->guessing == 0 ) {
05416 tmp198_AST = astFactory->create(LT(1));
05417 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp198_AST.get()));
05418 }
05419 match(CONSTRUCTOR);
05420 {
05421 if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
05422 identifier();
05423 if (inputState->guessing==0) {
05424 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05425 }
05426 }
05427 else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
05428 qualifiedMethodIdentifier();
05429 if (inputState->guessing==0) {
05430 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05431 }
05432 }
05433 else {
05434 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05435 }
05436
05437 }
05438 formalParameterList();
05439 if (inputState->guessing==0) {
05440 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05441 }
05442 constructorHeader_AST = (currentAST.root);
05443 }
05444 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05445 if( inputState->guessing == 0 ) {
05446 reportError(ex);
05447 consume();
05448 consumeUntil(_tokenSet_22);
05449 } else {
05450 throw;
05451 }
05452 }
05453 returnAST = constructorHeader_AST;
05454 }
05455
05456 void PascalParser::destructorHeader() {
05457 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05458 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05459 RefPascalAST destructorHeader_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05460
05461 try {
05462 RefPascalAST tmp199_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05463 if ( inputState->guessing == 0 ) {
05464 tmp199_AST = astFactory->create(LT(1));
05465 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp199_AST.get()));
05466 }
05467 match(DESTRUCTOR);
05468 {
05469 if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
05470 identifier();
05471 if (inputState->guessing==0) {
05472 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05473 }
05474 }
05475 else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
05476 qualifiedMethodIdentifier();
05477 if (inputState->guessing==0) {
05478 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05479 }
05480 }
05481 else {
05482 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05483 }
05484
05485 }
05486 formalParameterList();
05487 if (inputState->guessing==0) {
05488 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05489 }
05490 destructorHeader_AST = (currentAST.root);
05491 }
05492 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05493 if( inputState->guessing == 0 ) {
05494 reportError(ex);
05495 consume();
05496 consumeUntil(_tokenSet_22);
05497 } else {
05498 throw;
05499 }
05500 }
05501 returnAST = destructorHeader_AST;
05502 }
05503
05504 void PascalParser::methodDirectives() {
05505 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05506 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05507 RefPascalAST methodDirectives_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05508
05509 try {
05510 {
05511 switch ( LA(1)) {
05512 case VIRTUAL:
05513 {
05514 match(VIRTUAL);
05515 match(SEMI);
05516 {
05517 switch ( LA(1)) {
05518 case ABSTRACT:
05519 {
05520 match(ABSTRACT);
05521 match(SEMI);
05522 break;
05523 }
05524 case END:
05525 case PROCEDURE:
05526 case FUNCTION:
05527 case REGISTER:
05528 case PASCAL:
05529 case CDECL:
05530 case STDCALL:
05531 case POPSTACK:
05532 case SAVEREGISTERS:
05533 case INLINE:
05534 case SAFECALL:
05535 case NEAR:
05536 case FAR:
05537 case CONSTRUCTOR:
05538 case DESTRUCTOR:
05539 {
05540 break;
05541 }
05542 default:
05543 {
05544 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05545 }
05546 }
05547 }
05548 break;
05549 }
05550 case END:
05551 case PROCEDURE:
05552 case FUNCTION:
05553 case REGISTER:
05554 case PASCAL:
05555 case CDECL:
05556 case STDCALL:
05557 case POPSTACK:
05558 case SAVEREGISTERS:
05559 case INLINE:
05560 case SAFECALL:
05561 case NEAR:
05562 case FAR:
05563 case CONSTRUCTOR:
05564 case DESTRUCTOR:
05565 {
05566 break;
05567 }
05568 default:
05569 {
05570 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05571 }
05572 }
05573 }
05574 {
05575 switch ( LA(1)) {
05576 case REGISTER:
05577 case PASCAL:
05578 case CDECL:
05579 case STDCALL:
05580 case POPSTACK:
05581 case SAVEREGISTERS:
05582 case INLINE:
05583 case SAFECALL:
05584 case NEAR:
05585 case FAR:
05586 {
05587 callModifiers();
05588 if (inputState->guessing==0) {
05589 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05590 }
05591 match(SEMI);
05592 break;
05593 }
05594 case END:
05595 case PROCEDURE:
05596 case FUNCTION:
05597 case CONSTRUCTOR:
05598 case DESTRUCTOR:
05599 {
05600 break;
05601 }
05602 default:
05603 {
05604 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05605 }
05606 }
05607 }
05608 methodDirectives_AST = (currentAST.root);
05609 }
05610 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05611 if( inputState->guessing == 0 ) {
05612 reportError(ex);
05613 consume();
05614 consumeUntil(_tokenSet_51);
05615 } else {
05616 throw;
05617 }
05618 }
05619 returnAST = methodDirectives_AST;
05620 }
05621
05622 void PascalParser::classComponentList() {
05623 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05624 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05625 RefPascalAST classComponentList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05626
05627 try {
05628 {
05629 switch ( LA(1)) {
05630 case IDENT:
05631 {
05632 {
05633 int _cnt220=0;
05634 for (;;) {
05635 if ((LA(1) == IDENT)) {
05636 fieldDefinition();
05637 if (inputState->guessing==0) {
05638 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05639 }
05640 }
05641 else {
05642 if ( _cnt220>=1 ) { goto _loop220; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
05643 }
05644
05645 _cnt220++;
05646 }
05647 _loop220:;
05648 }
05649 break;
05650 }
05651 case END:
05652 case PROCEDURE:
05653 case FUNCTION:
05654 case CONSTRUCTOR:
05655 case DESTRUCTOR:
05656 case CLASS:
05657 case PROPERTY:
05658 {
05659 break;
05660 }
05661 default:
05662 {
05663 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05664 }
05665 }
05666 }
05667 {
05668 switch ( LA(1)) {
05669 case PROCEDURE:
05670 case FUNCTION:
05671 case CONSTRUCTOR:
05672 case DESTRUCTOR:
05673 case CLASS:
05674 case PROPERTY:
05675 {
05676 {
05677 int _cnt224=0;
05678 for (;;) {
05679 if ((_tokenSet_52.member(LA(1)))) {
05680 {
05681 switch ( LA(1)) {
05682 case PROCEDURE:
05683 case FUNCTION:
05684 case CONSTRUCTOR:
05685 case DESTRUCTOR:
05686 case CLASS:
05687 {
05688 classMethodDefinition();
05689 if (inputState->guessing==0) {
05690 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05691 }
05692 break;
05693 }
05694 case PROPERTY:
05695 {
05696 propertyDefinition();
05697 if (inputState->guessing==0) {
05698 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05699 }
05700 break;
05701 }
05702 default:
05703 {
05704 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05705 }
05706 }
05707 }
05708 }
05709 else {
05710 if ( _cnt224>=1 ) { goto _loop224; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
05711 }
05712
05713 _cnt224++;
05714 }
05715 _loop224:;
05716 }
05717 break;
05718 }
05719 case END:
05720 {
05721 break;
05722 }
05723 default:
05724 {
05725 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05726 }
05727 }
05728 }
05729 classComponentList_AST = (currentAST.root);
05730 }
05731 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05732 if( inputState->guessing == 0 ) {
05733 reportError(ex);
05734 consume();
05735 consumeUntil(_tokenSet_6);
05736 } else {
05737 throw;
05738 }
05739 }
05740 returnAST = classComponentList_AST;
05741 }
05742
05743 void PascalParser::classVisibilitySpecifier() {
05744 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05745 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05746 RefPascalAST classVisibilitySpecifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05747
05748 try {
05749 switch ( LA(1)) {
05750 case PRIVATE:
05751 {
05752 match(PRIVATE);
05753 classVisibilitySpecifier_AST = (currentAST.root);
05754 break;
05755 }
05756 case PROTECTED:
05757 {
05758 match(PROTECTED);
05759 classVisibilitySpecifier_AST = (currentAST.root);
05760 break;
05761 }
05762 case PUBLIC:
05763 {
05764 match(PUBLIC);
05765 classVisibilitySpecifier_AST = (currentAST.root);
05766 break;
05767 }
05768 case PUBLISHED:
05769 {
05770 match(PUBLISHED);
05771 classVisibilitySpecifier_AST = (currentAST.root);
05772 break;
05773 }
05774 default:
05775 {
05776 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05777 }
05778 }
05779 }
05780 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05781 if( inputState->guessing == 0 ) {
05782 reportError(ex);
05783 consume();
05784 consumeUntil(_tokenSet_6);
05785 } else {
05786 throw;
05787 }
05788 }
05789 returnAST = classVisibilitySpecifier_AST;
05790 }
05791
05792 void PascalParser::classMethodDefinition() {
05793 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05794 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05795 RefPascalAST classMethodDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05796
05797 try {
05798 {
05799 switch ( LA(1)) {
05800 case PROCEDURE:
05801 case FUNCTION:
05802 case CLASS:
05803 {
05804 {
05805 {
05806 switch ( LA(1)) {
05807 case CLASS:
05808 {
05809 match(CLASS);
05810 break;
05811 }
05812 case PROCEDURE:
05813 case FUNCTION:
05814 {
05815 break;
05816 }
05817 default:
05818 {
05819 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05820 }
05821 }
05822 }
05823 {
05824 switch ( LA(1)) {
05825 case FUNCTION:
05826 {
05827 functionHeader();
05828 if (inputState->guessing==0) {
05829 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05830 }
05831 break;
05832 }
05833 case PROCEDURE:
05834 {
05835 procedureHeader();
05836 if (inputState->guessing==0) {
05837 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05838 }
05839 break;
05840 }
05841 default:
05842 {
05843 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05844 }
05845 }
05846 }
05847 }
05848 break;
05849 }
05850 case CONSTRUCTOR:
05851 {
05852 constructorHeader();
05853 if (inputState->guessing==0) {
05854 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05855 }
05856 break;
05857 }
05858 case DESTRUCTOR:
05859 {
05860 destructorHeader();
05861 if (inputState->guessing==0) {
05862 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05863 }
05864 break;
05865 }
05866 default:
05867 {
05868 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05869 }
05870 }
05871 }
05872 match(SEMI);
05873 classMethodDirectives();
05874 if (inputState->guessing==0) {
05875 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05876 }
05877 classMethodDefinition_AST = (currentAST.root);
05878 }
05879 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05880 if( inputState->guessing == 0 ) {
05881 reportError(ex);
05882 consume();
05883 consumeUntil(_tokenSet_53);
05884 } else {
05885 throw;
05886 }
05887 }
05888 returnAST = classMethodDefinition_AST;
05889 }
05890
05891 void PascalParser::propertyDefinition() {
05892 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05893 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05894 RefPascalAST propertyDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05895
05896 try {
05897 RefPascalAST tmp211_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05898 if ( inputState->guessing == 0 ) {
05899 tmp211_AST = astFactory->create(LT(1));
05900 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp211_AST.get()));
05901 }
05902 match(PROPERTY);
05903 identifier();
05904 if (inputState->guessing==0) {
05905 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05906 }
05907 {
05908 switch ( LA(1)) {
05909 case COLON:
05910 case LBRACK:
05911 {
05912 propertyInterface();
05913 if (inputState->guessing==0) {
05914 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05915 }
05916 break;
05917 }
05918 case END:
05919 case PROCEDURE:
05920 case FUNCTION:
05921 case CONSTRUCTOR:
05922 case DESTRUCTOR:
05923 case CLASS:
05924 case PROPERTY:
05925 case LITERAL_read:
05926 case LITERAL_write:
05927 case DEFAULT:
05928 case LITERAL_nodefault:
05929 {
05930 break;
05931 }
05932 default:
05933 {
05934 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05935 }
05936 }
05937 }
05938 propertySpecifiers();
05939 if (inputState->guessing==0) {
05940 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05941 }
05942 propertyDefinition_AST = (currentAST.root);
05943 }
05944 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
05945 if( inputState->guessing == 0 ) {
05946 reportError(ex);
05947 consume();
05948 consumeUntil(_tokenSet_53);
05949 } else {
05950 throw;
05951 }
05952 }
05953 returnAST = propertyDefinition_AST;
05954 }
05955
05956 void PascalParser::classMethodDirectives() {
05957 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05958 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
05959 RefPascalAST classMethodDirectives_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
05960
05961 try {
05962 {
05963 switch ( LA(1)) {
05964 case VIRTUAL:
05965 case OVERRIDE:
05966 case MESSAGE:
05967 {
05968 directiveVariants();
05969 if (inputState->guessing==0) {
05970 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
05971 }
05972 match(SEMI);
05973 break;
05974 }
05975 case END:
05976 case PROCEDURE:
05977 case FUNCTION:
05978 case REGISTER:
05979 case PASCAL:
05980 case CDECL:
05981 case STDCALL:
05982 case POPSTACK:
05983 case SAVEREGISTERS:
05984 case INLINE:
05985 case SAFECALL:
05986 case NEAR:
05987 case FAR:
05988 case CONSTRUCTOR:
05989 case DESTRUCTOR:
05990 case CLASS:
05991 case PROPERTY:
05992 {
05993 break;
05994 }
05995 default:
05996 {
05997 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
05998 }
05999 }
06000 }
06001 {
06002 switch ( LA(1)) {
06003 case REGISTER:
06004 case PASCAL:
06005 case CDECL:
06006 case STDCALL:
06007 case POPSTACK:
06008 case SAVEREGISTERS:
06009 case INLINE:
06010 case SAFECALL:
06011 case NEAR:
06012 case FAR:
06013 {
06014 callModifiers();
06015 if (inputState->guessing==0) {
06016 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06017 }
06018 match(SEMI);
06019 break;
06020 }
06021 case END:
06022 case PROCEDURE:
06023 case FUNCTION:
06024 case CONSTRUCTOR:
06025 case DESTRUCTOR:
06026 case CLASS:
06027 case PROPERTY:
06028 {
06029 break;
06030 }
06031 default:
06032 {
06033 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06034 }
06035 }
06036 }
06037 classMethodDirectives_AST = (currentAST.root);
06038 }
06039 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06040 if( inputState->guessing == 0 ) {
06041 reportError(ex);
06042 consume();
06043 consumeUntil(_tokenSet_53);
06044 } else {
06045 throw;
06046 }
06047 }
06048 returnAST = classMethodDirectives_AST;
06049 }
06050
06051 void PascalParser::directiveVariants() {
06052 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06053 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06054 RefPascalAST directiveVariants_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06055
06056 try {
06057 switch ( LA(1)) {
06058 case VIRTUAL:
06059 {
06060 {
06061 match(VIRTUAL);
06062 {
06063 switch ( LA(1)) {
06064 case ABSTRACT:
06065 {
06066 match(ABSTRACT);
06067 match(SEMI);
06068 break;
06069 }
06070 case SEMI:
06071 {
06072 break;
06073 }
06074 default:
06075 {
06076 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06077 }
06078 }
06079 }
06080 }
06081 directiveVariants_AST = (currentAST.root);
06082 break;
06083 }
06084 case OVERRIDE:
06085 {
06086 match(OVERRIDE);
06087 directiveVariants_AST = (currentAST.root);
06088 break;
06089 }
06090 case MESSAGE:
06091 {
06092 {
06093 match(MESSAGE);
06094 {
06095 switch ( LA(1)) {
06096 case NUM_INT:
06097 case PLUS:
06098 case MINUS:
06099 {
06100 integerConstant();
06101 if (inputState->guessing==0) {
06102 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06103 }
06104 break;
06105 }
06106 case STRING_LITERAL:
06107 case CHR:
06108 {
06109 stringConstant();
06110 if (inputState->guessing==0) {
06111 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06112 }
06113 break;
06114 }
06115 default:
06116 {
06117 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06118 }
06119 }
06120 }
06121 }
06122 directiveVariants_AST = (currentAST.root);
06123 break;
06124 }
06125 default:
06126 {
06127 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06128 }
06129 }
06130 }
06131 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06132 if( inputState->guessing == 0 ) {
06133 reportError(ex);
06134 consume();
06135 consumeUntil(_tokenSet_22);
06136 } else {
06137 throw;
06138 }
06139 }
06140 returnAST = directiveVariants_AST;
06141 }
06142
06143 void PascalParser::propertyInterface() {
06144 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06145 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06146 RefPascalAST propertyInterface_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06147
06148 try {
06149 {
06150 switch ( LA(1)) {
06151 case LBRACK:
06152 {
06153 propertyParameterList();
06154 if (inputState->guessing==0) {
06155 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06156 }
06157 break;
06158 }
06159 case COLON:
06160 {
06161 break;
06162 }
06163 default:
06164 {
06165 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06166 }
06167 }
06168 }
06169 match(COLON);
06170 typeIdentifier();
06171 if (inputState->guessing==0) {
06172 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06173 }
06174 {
06175 switch ( LA(1)) {
06176 case LITERAL_index:
06177 {
06178 RefPascalAST tmp220_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06179 if ( inputState->guessing == 0 ) {
06180 tmp220_AST = astFactory->create(LT(1));
06181 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp220_AST.get()));
06182 }
06183 match(LITERAL_index);
06184 integerConstant();
06185 if (inputState->guessing==0) {
06186 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06187 }
06188 break;
06189 }
06190 case END:
06191 case PROCEDURE:
06192 case FUNCTION:
06193 case CONSTRUCTOR:
06194 case DESTRUCTOR:
06195 case CLASS:
06196 case PROPERTY:
06197 case LITERAL_read:
06198 case LITERAL_write:
06199 case DEFAULT:
06200 case LITERAL_nodefault:
06201 {
06202 break;
06203 }
06204 default:
06205 {
06206 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06207 }
06208 }
06209 }
06210 propertyInterface_AST = (currentAST.root);
06211 }
06212 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06213 if( inputState->guessing == 0 ) {
06214 reportError(ex);
06215 consume();
06216 consumeUntil(_tokenSet_54);
06217 } else {
06218 throw;
06219 }
06220 }
06221 returnAST = propertyInterface_AST;
06222 }
06223
06224 void PascalParser::propertySpecifiers() {
06225 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06226 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06227 RefPascalAST propertySpecifiers_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06228
06229 try {
06230 {
06231 switch ( LA(1)) {
06232 case LITERAL_read:
06233 {
06234 readSpecifier();
06235 if (inputState->guessing==0) {
06236 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06237 }
06238 break;
06239 }
06240 case END:
06241 case PROCEDURE:
06242 case FUNCTION:
06243 case CONSTRUCTOR:
06244 case DESTRUCTOR:
06245 case CLASS:
06246 case PROPERTY:
06247 case LITERAL_write:
06248 case DEFAULT:
06249 case LITERAL_nodefault:
06250 {
06251 break;
06252 }
06253 default:
06254 {
06255 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06256 }
06257 }
06258 }
06259 {
06260 switch ( LA(1)) {
06261 case LITERAL_write:
06262 {
06263 writeSpecifier();
06264 if (inputState->guessing==0) {
06265 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06266 }
06267 break;
06268 }
06269 case END:
06270 case PROCEDURE:
06271 case FUNCTION:
06272 case CONSTRUCTOR:
06273 case DESTRUCTOR:
06274 case CLASS:
06275 case PROPERTY:
06276 case DEFAULT:
06277 case LITERAL_nodefault:
06278 {
06279 break;
06280 }
06281 default:
06282 {
06283 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06284 }
06285 }
06286 }
06287 {
06288 switch ( LA(1)) {
06289 case DEFAULT:
06290 case LITERAL_nodefault:
06291 {
06292 defaultSpecifier();
06293 if (inputState->guessing==0) {
06294 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06295 }
06296 break;
06297 }
06298 case END:
06299 case PROCEDURE:
06300 case FUNCTION:
06301 case CONSTRUCTOR:
06302 case DESTRUCTOR:
06303 case CLASS:
06304 case PROPERTY:
06305 {
06306 break;
06307 }
06308 default:
06309 {
06310 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06311 }
06312 }
06313 }
06314 propertySpecifiers_AST = (currentAST.root);
06315 }
06316 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06317 if( inputState->guessing == 0 ) {
06318 reportError(ex);
06319 consume();
06320 consumeUntil(_tokenSet_53);
06321 } else {
06322 throw;
06323 }
06324 }
06325 returnAST = propertySpecifiers_AST;
06326 }
06327
06328 void PascalParser::propertyParameterList() {
06329 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06330 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06331 RefPascalAST propertyParameterList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06332
06333 try {
06334 match(LBRACK);
06335 parameterDeclaration();
06336 if (inputState->guessing==0) {
06337 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06338 }
06339 {
06340 for (;;) {
06341 if ((LA(1) == SEMI)) {
06342 match(SEMI);
06343 parameterDeclaration();
06344 if (inputState->guessing==0) {
06345 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06346 }
06347 }
06348 else {
06349 goto _loop246;
06350 }
06351
06352 }
06353 _loop246:;
06354 }
06355 match(RBRACK);
06356 propertyParameterList_AST = (currentAST.root);
06357 }
06358 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06359 if( inputState->guessing == 0 ) {
06360 reportError(ex);
06361 consume();
06362 consumeUntil(_tokenSet_55);
06363 } else {
06364 throw;
06365 }
06366 }
06367 returnAST = propertyParameterList_AST;
06368 }
06369
06370 void PascalParser::readSpecifier() {
06371 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06372 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06373 RefPascalAST readSpecifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06374
06375 try {
06376 RefPascalAST tmp224_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06377 if ( inputState->guessing == 0 ) {
06378 tmp224_AST = astFactory->create(LT(1));
06379 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp224_AST.get()));
06380 }
06381 match(LITERAL_read);
06382 fieldOrMethod();
06383 if (inputState->guessing==0) {
06384 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06385 }
06386 readSpecifier_AST = (currentAST.root);
06387 }
06388 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06389 if( inputState->guessing == 0 ) {
06390 reportError(ex);
06391 consume();
06392 consumeUntil(_tokenSet_56);
06393 } else {
06394 throw;
06395 }
06396 }
06397 returnAST = readSpecifier_AST;
06398 }
06399
06400 void PascalParser::writeSpecifier() {
06401 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06402 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06403 RefPascalAST writeSpecifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06404
06405 try {
06406 RefPascalAST tmp225_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06407 if ( inputState->guessing == 0 ) {
06408 tmp225_AST = astFactory->create(LT(1));
06409 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp225_AST.get()));
06410 }
06411 match(LITERAL_write);
06412 fieldOrMethod();
06413 if (inputState->guessing==0) {
06414 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06415 }
06416 writeSpecifier_AST = (currentAST.root);
06417 }
06418 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06419 if( inputState->guessing == 0 ) {
06420 reportError(ex);
06421 consume();
06422 consumeUntil(_tokenSet_57);
06423 } else {
06424 throw;
06425 }
06426 }
06427 returnAST = writeSpecifier_AST;
06428 }
06429
06430 void PascalParser::defaultSpecifier() {
06431 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06432 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06433 RefPascalAST defaultSpecifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06434
06435 try {
06436 switch ( LA(1)) {
06437 case DEFAULT:
06438 {
06439 {
06440 RefPascalAST tmp226_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06441 if ( inputState->guessing == 0 ) {
06442 tmp226_AST = astFactory->create(LT(1));
06443 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp226_AST.get()));
06444 }
06445 match(DEFAULT);
06446 {
06447 switch ( LA(1)) {
06448 case NUM_INT:
06449 case PLUS:
06450 case MINUS:
06451 case STRING_LITERAL:
06452 case CHR:
06453 case NUM_REAL:
06454 case IDENT:
06455 {
06456 constant();
06457 if (inputState->guessing==0) {
06458 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06459 }
06460 break;
06461 }
06462 case END:
06463 case PROCEDURE:
06464 case FUNCTION:
06465 case CONSTRUCTOR:
06466 case DESTRUCTOR:
06467 case CLASS:
06468 case PROPERTY:
06469 {
06470 break;
06471 }
06472 default:
06473 {
06474 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06475 }
06476 }
06477 }
06478 }
06479 defaultSpecifier_AST = (currentAST.root);
06480 break;
06481 }
06482 case LITERAL_nodefault:
06483 {
06484 RefPascalAST tmp227_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06485 if ( inputState->guessing == 0 ) {
06486 tmp227_AST = astFactory->create(LT(1));
06487 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp227_AST.get()));
06488 }
06489 match(LITERAL_nodefault);
06490 defaultSpecifier_AST = (currentAST.root);
06491 break;
06492 }
06493 default:
06494 {
06495 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06496 }
06497 }
06498 }
06499 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06500 if( inputState->guessing == 0 ) {
06501 reportError(ex);
06502 consume();
06503 consumeUntil(_tokenSet_53);
06504 } else {
06505 throw;
06506 }
06507 }
06508 returnAST = defaultSpecifier_AST;
06509 }
06510
06511 void PascalParser::fieldOrMethod() {
06512 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06513 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06514 RefPascalAST fieldOrMethod_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06515
06516 try {
06517 identifier();
06518 if (inputState->guessing==0) {
06519 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06520 }
06521 fieldOrMethod_AST = (currentAST.root);
06522 }
06523 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06524 if( inputState->guessing == 0 ) {
06525 reportError(ex);
06526 consume();
06527 consumeUntil(_tokenSet_56);
06528 } else {
06529 throw;
06530 }
06531 }
06532 returnAST = fieldOrMethod_AST;
06533 }
06534
06535 void PascalParser::simpleExpression() {
06536 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06537 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06538 RefPascalAST simpleExpression_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06539
06540 try {
06541 term();
06542 if (inputState->guessing==0) {
06543 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06544 }
06545 {
06546 for (;;) {
06547 if (((LA(1) >= PLUS && LA(1) <= XOR))) {
06548 {
06549 switch ( LA(1)) {
06550 case PLUS:
06551 {
06552 match(PLUS);
06553 break;
06554 }
06555 case MINUS:
06556 {
06557 match(MINUS);
06558 break;
06559 }
06560 case OR:
06561 {
06562 match(OR);
06563 break;
06564 }
06565 case XOR:
06566 {
06567 match(XOR);
06568 break;
06569 }
06570 default:
06571 {
06572 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06573 }
06574 }
06575 }
06576 term();
06577 if (inputState->guessing==0) {
06578 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06579 }
06580 }
06581 else {
06582 goto _loop263;
06583 }
06584
06585 }
06586 _loop263:;
06587 }
06588 simpleExpression_AST = (currentAST.root);
06589 }
06590 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06591 if( inputState->guessing == 0 ) {
06592 reportError(ex);
06593 consume();
06594 consumeUntil(_tokenSet_58);
06595 } else {
06596 throw;
06597 }
06598 }
06599 returnAST = simpleExpression_AST;
06600 }
06601
06602 void PascalParser::expressionSign() {
06603 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06604 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06605 RefPascalAST expressionSign_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06606
06607 try {
06608 switch ( LA(1)) {
06609 case LE:
06610 {
06611 match(LE);
06612 expressionSign_AST = (currentAST.root);
06613 break;
06614 }
06615 case GE:
06616 {
06617 match(GE);
06618 expressionSign_AST = (currentAST.root);
06619 break;
06620 }
06621 case LTH:
06622 {
06623 match(LTH);
06624 expressionSign_AST = (currentAST.root);
06625 break;
06626 }
06627 case GT:
06628 {
06629 match(GT);
06630 expressionSign_AST = (currentAST.root);
06631 break;
06632 }
06633 case NOT_EQUAL:
06634 {
06635 match(NOT_EQUAL);
06636 expressionSign_AST = (currentAST.root);
06637 break;
06638 }
06639 case IN:
06640 {
06641 match(IN);
06642 expressionSign_AST = (currentAST.root);
06643 break;
06644 }
06645 case IS:
06646 {
06647 match(IS);
06648 expressionSign_AST = (currentAST.root);
06649 break;
06650 }
06651 case EQUAL:
06652 {
06653 match(EQUAL);
06654 expressionSign_AST = (currentAST.root);
06655 break;
06656 }
06657 default:
06658 {
06659 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06660 }
06661 }
06662 }
06663 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06664 if( inputState->guessing == 0 ) {
06665 reportError(ex);
06666 consume();
06667 consumeUntil(_tokenSet_36);
06668 } else {
06669 throw;
06670 }
06671 }
06672 returnAST = expressionSign_AST;
06673 }
06674
06675 void PascalParser::term() {
06676 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06677 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06678 RefPascalAST term_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06679
06680 try {
06681 factor();
06682 if (inputState->guessing==0) {
06683 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06684 }
06685 {
06686 for (;;) {
06687 if (((LA(1) >= STAR && LA(1) <= SHR))) {
06688 {
06689 switch ( LA(1)) {
06690 case STAR:
06691 {
06692 match(STAR);
06693 break;
06694 }
06695 case SLASH:
06696 {
06697 match(SLASH);
06698 break;
06699 }
06700 case DIV:
06701 {
06702 match(DIV);
06703 break;
06704 }
06705 case MOD:
06706 {
06707 match(MOD);
06708 break;
06709 }
06710 case AND:
06711 {
06712 match(AND);
06713 break;
06714 }
06715 case SHL:
06716 {
06717 match(SHL);
06718 break;
06719 }
06720 case SHR:
06721 {
06722 match(SHR);
06723 break;
06724 }
06725 default:
06726 {
06727 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06728 }
06729 }
06730 }
06731 factor();
06732 if (inputState->guessing==0) {
06733 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06734 }
06735 }
06736 else {
06737 goto _loop267;
06738 }
06739
06740 }
06741 _loop267:;
06742 }
06743 term_AST = (currentAST.root);
06744 }
06745 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06746 if( inputState->guessing == 0 ) {
06747 reportError(ex);
06748 consume();
06749 consumeUntil(_tokenSet_59);
06750 } else {
06751 throw;
06752 }
06753 }
06754 returnAST = term_AST;
06755 }
06756
06757 void PascalParser::factor() {
06758 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06759 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06760 RefPascalAST factor_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06761
06762 try {
06763 switch ( LA(1)) {
06764 case LPAREN:
06765 {
06766 {
06767 match(LPAREN);
06768 expression();
06769 if (inputState->guessing==0) {
06770 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06771 }
06772 match(RPAREN);
06773 }
06774 factor_AST = (currentAST.root);
06775 break;
06776 }
06777 case NUM_INT:
06778 case STRING_LITERAL:
06779 case CHR:
06780 case NIL:
06781 case NUM_REAL:
06782 {
06783 unsignedConstant();
06784 if (inputState->guessing==0) {
06785 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06786 }
06787 factor_AST = (currentAST.root);
06788 break;
06789 }
06790 case NOT:
06791 {
06792 {
06793 match(NOT);
06794 factor();
06795 if (inputState->guessing==0) {
06796 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06797 }
06798 }
06799 factor_AST = (currentAST.root);
06800 break;
06801 }
06802 case PLUS:
06803 case MINUS:
06804 {
06805 {
06806 {
06807 switch ( LA(1)) {
06808 case PLUS:
06809 {
06810 match(PLUS);
06811 break;
06812 }
06813 case MINUS:
06814 {
06815 match(MINUS);
06816 break;
06817 }
06818 default:
06819 {
06820 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06821 }
06822 }
06823 }
06824 factor();
06825 if (inputState->guessing==0) {
06826 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06827 }
06828 }
06829 factor_AST = (currentAST.root);
06830 break;
06831 }
06832 case LBRACK:
06833 {
06834 setConstructor();
06835 if (inputState->guessing==0) {
06836 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06837 }
06838 factor_AST = (currentAST.root);
06839 break;
06840 }
06841 case AT:
06842 {
06843 addressFactor();
06844 if (inputState->guessing==0) {
06845 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06846 }
06847 factor_AST = (currentAST.root);
06848 break;
06849 }
06850 case TRUE:
06851 {
06852 RefPascalAST tmp252_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06853 if ( inputState->guessing == 0 ) {
06854 tmp252_AST = astFactory->create(LT(1));
06855 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp252_AST.get()));
06856 }
06857 match(TRUE);
06858 factor_AST = (currentAST.root);
06859 break;
06860 }
06861 case FALSE:
06862 {
06863 RefPascalAST tmp253_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06864 if ( inputState->guessing == 0 ) {
06865 tmp253_AST = astFactory->create(LT(1));
06866 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp253_AST.get()));
06867 }
06868 match(FALSE);
06869 factor_AST = (currentAST.root);
06870 break;
06871 }
06872 default:
06873 if ((LA(1) == IDENT) && (_tokenSet_60.member(LA(2)))) {
06874 identifierOrValueTypecastOrFunctionCall();
06875 if (inputState->guessing==0) {
06876 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06877 }
06878 factor_AST = (currentAST.root);
06879 }
06880 else if ((LA(1) == IDENT) && (LA(2) == LBRACK)) {
06881 identifier();
06882 if (inputState->guessing==0) {
06883 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06884 }
06885 match(LBRACK);
06886 expression();
06887 if (inputState->guessing==0) {
06888 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06889 }
06890 {
06891 for (;;) {
06892 if ((LA(1) == COMMA)) {
06893 match(COMMA);
06894 expression();
06895 if (inputState->guessing==0) {
06896 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06897 }
06898 }
06899 else {
06900 goto _loop274;
06901 }
06902
06903 }
06904 _loop274:;
06905 }
06906 match(RBRACK);
06907 factor_AST = (currentAST.root);
06908 }
06909 else {
06910 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
06911 }
06912 }
06913 }
06914 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
06915 if( inputState->guessing == 0 ) {
06916 reportError(ex);
06917 consume();
06918 consumeUntil(_tokenSet_61);
06919 } else {
06920 throw;
06921 }
06922 }
06923 returnAST = factor_AST;
06924 }
06925
06926 void PascalParser::identifierOrValueTypecastOrFunctionCall() {
06927 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06928 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
06929 RefPascalAST identifierOrValueTypecastOrFunctionCall_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
06930
06931 try {
06932 bool synPredMatched277 = false;
06933 if (((LA(1) == IDENT) && (LA(2) == LPAREN))) {
06934 int _m277 = mark();
06935 synPredMatched277 = true;
06936 inputState->guessing++;
06937 try {
06938 {
06939 identifier();
06940 match(LPAREN);
06941 expression();
06942 match(COMMA);
06943 }
06944 }
06945 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
06946 synPredMatched277 = false;
06947 }
06948 rewind(_m277);
06949 inputState->guessing--;
06950 }
06951 if ( synPredMatched277 ) {
06952 identifier();
06953 if (inputState->guessing==0) {
06954 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06955 }
06956 match(LPAREN);
06957 expressions();
06958 if (inputState->guessing==0) {
06959 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06960 }
06961 match(RPAREN);
06962 identifierOrValueTypecastOrFunctionCall_AST = (currentAST.root);
06963 }
06964 else {
06965 bool synPredMatched279 = false;
06966 if (((LA(1) == IDENT) && (LA(2) == LPAREN))) {
06967 int _m279 = mark();
06968 synPredMatched279 = true;
06969 inputState->guessing++;
06970 try {
06971 {
06972 identifier();
06973 match(LPAREN);
06974 expression();
06975 match(RPAREN);
06976 }
06977 }
06978 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
06979 synPredMatched279 = false;
06980 }
06981 rewind(_m279);
06982 inputState->guessing--;
06983 }
06984 if ( synPredMatched279 ) {
06985 identifier();
06986 if (inputState->guessing==0) {
06987 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06988 }
06989 match(LPAREN);
06990 expression();
06991 if (inputState->guessing==0) {
06992 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
06993 }
06994 match(RPAREN);
06995 identifierOrValueTypecastOrFunctionCall_AST = (currentAST.root);
06996 }
06997 else if ((LA(1) == IDENT) && (_tokenSet_61.member(LA(2)))) {
06998 identifier();
06999 if (inputState->guessing==0) {
07000 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07001 }
07002 identifierOrValueTypecastOrFunctionCall_AST = (currentAST.root);
07003 }
07004 else {
07005 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07006 }
07007 }
07008 }
07009 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07010 if( inputState->guessing == 0 ) {
07011 reportError(ex);
07012 consume();
07013 consumeUntil(_tokenSet_61);
07014 } else {
07015 throw;
07016 }
07017 }
07018 returnAST = identifierOrValueTypecastOrFunctionCall_AST;
07019 }
07020
07021 void PascalParser::unsignedConstant() {
07022 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07023 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07024 RefPascalAST unsignedConstant_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07025
07026 try {
07027 switch ( LA(1)) {
07028 case NUM_INT:
07029 case NUM_REAL:
07030 {
07031 unsignedNumber();
07032 if (inputState->guessing==0) {
07033 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07034 }
07035 unsignedConstant_AST = (currentAST.root);
07036 break;
07037 }
07038 case CHR:
07039 {
07040 constantChr();
07041 if (inputState->guessing==0) {
07042 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07043 }
07044 unsignedConstant_AST = (currentAST.root);
07045 break;
07046 }
07047 case STRING_LITERAL:
07048 {
07049 string();
07050 if (inputState->guessing==0) {
07051 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07052 }
07053 unsignedConstant_AST = (currentAST.root);
07054 break;
07055 }
07056 case NIL:
07057 {
07058 match(NIL);
07059 unsignedConstant_AST = (currentAST.root);
07060 break;
07061 }
07062 default:
07063 {
07064 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07065 }
07066 }
07067 }
07068 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07069 if( inputState->guessing == 0 ) {
07070 reportError(ex);
07071 consume();
07072 consumeUntil(_tokenSet_61);
07073 } else {
07074 throw;
07075 }
07076 }
07077 returnAST = unsignedConstant_AST;
07078 }
07079
07080 void PascalParser::setConstructor() {
07081 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07082 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07083 RefPascalAST setConstructor_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07084
07085 try {
07086 match(LBRACK);
07087 {
07088 switch ( LA(1)) {
07089 case LPAREN:
07090 case NUM_INT:
07091 case LBRACK:
07092 case PLUS:
07093 case MINUS:
07094 case NOT:
07095 case TRUE:
07096 case FALSE:
07097 case AT:
07098 case STRING_LITERAL:
07099 case CHR:
07100 case NIL:
07101 case NUM_REAL:
07102 case IDENT:
07103 {
07104 setGroup();
07105 if (inputState->guessing==0) {
07106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07107 }
07108 {
07109 for (;;) {
07110 if ((LA(1) == COMMA)) {
07111 match(COMMA);
07112 setGroup();
07113 if (inputState->guessing==0) {
07114 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07115 }
07116 }
07117 else {
07118 goto _loop290;
07119 }
07120
07121 }
07122 _loop290:;
07123 }
07124 break;
07125 }
07126 case RBRACK:
07127 {
07128 break;
07129 }
07130 default:
07131 {
07132 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07133 }
07134 }
07135 }
07136 match(RBRACK);
07137 setConstructor_AST = (currentAST.root);
07138 }
07139 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07140 if( inputState->guessing == 0 ) {
07141 reportError(ex);
07142 consume();
07143 consumeUntil(_tokenSet_61);
07144 } else {
07145 throw;
07146 }
07147 }
07148 returnAST = setConstructor_AST;
07149 }
07150
07151 void PascalParser::addressFactor() {
07152 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07153 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07154 RefPascalAST addressFactor_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07155
07156 try {
07157 match(AT);
07158 identifier();
07159 if (inputState->guessing==0) {
07160 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07161 }
07162 addressFactor_AST = (currentAST.root);
07163 }
07164 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07165 if( inputState->guessing == 0 ) {
07166 reportError(ex);
07167 consume();
07168 consumeUntil(_tokenSet_61);
07169 } else {
07170 throw;
07171 }
07172 }
07173 returnAST = addressFactor_AST;
07174 }
07175
07176 void PascalParser::expressions() {
07177 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07178 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07179 RefPascalAST expressions_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07180
07181 try {
07182 expression();
07183 if (inputState->guessing==0) {
07184 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07185 }
07186 {
07187 for (;;) {
07188 if ((LA(1) == COMMA)) {
07189 match(COMMA);
07190 expression();
07191 if (inputState->guessing==0) {
07192 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07193 }
07194 }
07195 else {
07196 goto _loop286;
07197 }
07198
07199 }
07200 _loop286:;
07201 }
07202 expressions_AST = (currentAST.root);
07203 }
07204 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07205 if( inputState->guessing == 0 ) {
07206 reportError(ex);
07207 consume();
07208 consumeUntil(_tokenSet_42);
07209 } else {
07210 throw;
07211 }
07212 }
07213 returnAST = expressions_AST;
07214 }
07215
07216 void PascalParser::functionCall() {
07217 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07218 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07219 RefPascalAST functionCall_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07220
07221 try {
07222 identifier();
07223 if (inputState->guessing==0) {
07224 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07225 }
07226 {
07227 switch ( LA(1)) {
07228 case LPAREN:
07229 {
07230 actualParameterList();
07231 if (inputState->guessing==0) {
07232 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07233 }
07234 break;
07235 }
07236 case SEMI:
07237 case END:
07238 case FINALIZATION:
07239 case AT:
07240 case ELSE:
07241 case UNTIL:
07242 case EXCEPT:
07243 case FINALLY:
07244 {
07245 break;
07246 }
07247 default:
07248 {
07249 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07250 }
07251 }
07252 }
07253 functionCall_AST = (currentAST.root);
07254 }
07255 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07256 if( inputState->guessing == 0 ) {
07257 reportError(ex);
07258 consume();
07259 consumeUntil(_tokenSet_62);
07260 } else {
07261 throw;
07262 }
07263 }
07264 returnAST = functionCall_AST;
07265 }
07266
07267 void PascalParser::actualParameterList() {
07268 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07269 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07270 RefPascalAST actualParameterList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07271
07272 try {
07273 match(LPAREN);
07274 {
07275 switch ( LA(1)) {
07276 case LPAREN:
07277 case NUM_INT:
07278 case LBRACK:
07279 case PLUS:
07280 case MINUS:
07281 case NOT:
07282 case TRUE:
07283 case FALSE:
07284 case AT:
07285 case STRING_LITERAL:
07286 case CHR:
07287 case NIL:
07288 case NUM_REAL:
07289 case IDENT:
07290 {
07291 expressions();
07292 if (inputState->guessing==0) {
07293 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07294 }
07295 break;
07296 }
07297 case RPAREN:
07298 {
07299 break;
07300 }
07301 default:
07302 {
07303 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07304 }
07305 }
07306 }
07307 match(RPAREN);
07308 actualParameterList_AST = (currentAST.root);
07309 }
07310 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07311 if( inputState->guessing == 0 ) {
07312 reportError(ex);
07313 consume();
07314 consumeUntil(_tokenSet_62);
07315 } else {
07316 throw;
07317 }
07318 }
07319 returnAST = actualParameterList_AST;
07320 }
07321
07322 void PascalParser::setGroup() {
07323 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07324 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07325 RefPascalAST setGroup_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07326
07327 try {
07328 expression();
07329 if (inputState->guessing==0) {
07330 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07331 }
07332 {
07333 switch ( LA(1)) {
07334 case DOT:
07335 {
07336 match(DOT);
07337 match(DOT);
07338 expression();
07339 if (inputState->guessing==0) {
07340 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07341 }
07342 break;
07343 }
07344 case COMMA:
07345 case RBRACK:
07346 {
07347 break;
07348 }
07349 default:
07350 {
07351 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07352 }
07353 }
07354 }
07355 setGroup_AST = (currentAST.root);
07356 }
07357 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07358 if( inputState->guessing == 0 ) {
07359 reportError(ex);
07360 consume();
07361 consumeUntil(_tokenSet_45);
07362 } else {
07363 throw;
07364 }
07365 }
07366 returnAST = setGroup_AST;
07367 }
07368
07369 void PascalParser::valueTypecast() {
07370 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07371 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07372 RefPascalAST valueTypecast_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07373
07374 try {
07375 typeIdentifier();
07376 if (inputState->guessing==0) {
07377 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07378 }
07379 match(LPAREN);
07380 expression();
07381 if (inputState->guessing==0) {
07382 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07383 }
07384 match(RPAREN);
07385 valueTypecast_AST = (currentAST.root);
07386 }
07387 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07388 if( inputState->guessing == 0 ) {
07389 reportError(ex);
07390 consume();
07391 consumeUntil(_tokenSet_0);
07392 } else {
07393 throw;
07394 }
07395 }
07396 returnAST = valueTypecast_AST;
07397 }
07398
07399 void PascalParser::simpleStatement() {
07400 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07401 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07402 RefPascalAST simpleStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07403
07404 try {
07405 switch ( LA(1)) {
07406 case GOTO:
07407 {
07408 gotoStatement();
07409 if (inputState->guessing==0) {
07410 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07411 }
07412 simpleStatement_AST = (currentAST.root);
07413 break;
07414 }
07415 case RAISE:
07416 {
07417 raiseStatement();
07418 if (inputState->guessing==0) {
07419 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07420 }
07421 simpleStatement_AST = (currentAST.root);
07422 break;
07423 }
07424 default:
07425 if ((LA(1) == IDENT) && (_tokenSet_63.member(LA(2)))) {
07426 assignmentStatement();
07427 if (inputState->guessing==0) {
07428 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07429 }
07430 simpleStatement_AST = (currentAST.root);
07431 }
07432 else if ((LA(1) == IDENT) && (_tokenSet_64.member(LA(2)))) {
07433 procedureStatement();
07434 if (inputState->guessing==0) {
07435 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07436 }
07437 simpleStatement_AST = (currentAST.root);
07438 }
07439 else {
07440 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07441 }
07442 }
07443 }
07444 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07445 if( inputState->guessing == 0 ) {
07446 reportError(ex);
07447 consume();
07448 consumeUntil(_tokenSet_16);
07449 } else {
07450 throw;
07451 }
07452 }
07453 returnAST = simpleStatement_AST;
07454 }
07455
07456 void PascalParser::structuredStatement() {
07457 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07458 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07459 RefPascalAST structuredStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07460
07461 try {
07462 switch ( LA(1)) {
07463 case BEGIN:
07464 {
07465 compoundStatement();
07466 if (inputState->guessing==0) {
07467 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07468 }
07469 structuredStatement_AST = (currentAST.root);
07470 break;
07471 }
07472 case WHILE:
07473 case REPEAT:
07474 case FOR:
07475 {
07476 repetitiveStatement();
07477 if (inputState->guessing==0) {
07478 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07479 }
07480 structuredStatement_AST = (currentAST.root);
07481 break;
07482 }
07483 case CASE:
07484 case IF:
07485 {
07486 conditionalStatement();
07487 if (inputState->guessing==0) {
07488 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07489 }
07490 structuredStatement_AST = (currentAST.root);
07491 break;
07492 }
07493 case TRY:
07494 {
07495 exceptionStatement();
07496 if (inputState->guessing==0) {
07497 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07498 }
07499 structuredStatement_AST = (currentAST.root);
07500 break;
07501 }
07502 case WITH:
07503 {
07504 withStatement();
07505 if (inputState->guessing==0) {
07506 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07507 }
07508 structuredStatement_AST = (currentAST.root);
07509 break;
07510 }
07511 default:
07512 {
07513 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07514 }
07515 }
07516 }
07517 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07518 if( inputState->guessing == 0 ) {
07519 reportError(ex);
07520 consume();
07521 consumeUntil(_tokenSet_16);
07522 } else {
07523 throw;
07524 }
07525 }
07526 returnAST = structuredStatement_AST;
07527 }
07528
07529 void PascalParser::assignmentStatement() {
07530 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07531 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07532 RefPascalAST assignmentStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07533
07534 try {
07535 identifierOrArrayIdentifier();
07536 if (inputState->guessing==0) {
07537 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07538 }
07539 assignmentOperator();
07540 if (inputState->guessing==0) {
07541 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07542 }
07543 expression();
07544 if (inputState->guessing==0) {
07545 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07546 }
07547 assignmentStatement_AST = (currentAST.root);
07548 }
07549 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07550 if( inputState->guessing == 0 ) {
07551 reportError(ex);
07552 consume();
07553 consumeUntil(_tokenSet_16);
07554 } else {
07555 throw;
07556 }
07557 }
07558 returnAST = assignmentStatement_AST;
07559 }
07560
07561 void PascalParser::procedureStatement() {
07562 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07563 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07564 RefPascalAST procedureStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07565
07566 try {
07567 identifier();
07568 if (inputState->guessing==0) {
07569 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07570 }
07571 {
07572 switch ( LA(1)) {
07573 case LPAREN:
07574 {
07575 actualParameterList();
07576 if (inputState->guessing==0) {
07577 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07578 }
07579 break;
07580 }
07581 case SEMI:
07582 case END:
07583 case FINALIZATION:
07584 case ELSE:
07585 case UNTIL:
07586 case EXCEPT:
07587 case FINALLY:
07588 {
07589 break;
07590 }
07591 default:
07592 {
07593 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07594 }
07595 }
07596 }
07597 procedureStatement_AST = (currentAST.root);
07598 }
07599 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07600 if( inputState->guessing == 0 ) {
07601 reportError(ex);
07602 consume();
07603 consumeUntil(_tokenSet_16);
07604 } else {
07605 throw;
07606 }
07607 }
07608 returnAST = procedureStatement_AST;
07609 }
07610
07611 void PascalParser::gotoStatement() {
07612 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07613 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07614 RefPascalAST gotoStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07615
07616 try {
07617 match(GOTO);
07618 label();
07619 if (inputState->guessing==0) {
07620 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07621 }
07622 gotoStatement_AST = (currentAST.root);
07623 }
07624 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07625 if( inputState->guessing == 0 ) {
07626 reportError(ex);
07627 consume();
07628 consumeUntil(_tokenSet_16);
07629 } else {
07630 throw;
07631 }
07632 }
07633 returnAST = gotoStatement_AST;
07634 }
07635
07636 void PascalParser::raiseStatement() {
07637 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07638 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07639 RefPascalAST raiseStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07640
07641 try {
07642 RefPascalAST tmp274_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07643 if ( inputState->guessing == 0 ) {
07644 tmp274_AST = astFactory->create(LT(1));
07645 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp274_AST.get()));
07646 }
07647 match(RAISE);
07648 {
07649 switch ( LA(1)) {
07650 case IDENT:
07651 {
07652 functionCall();
07653 if (inputState->guessing==0) {
07654 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07655 }
07656 {
07657 switch ( LA(1)) {
07658 case AT:
07659 {
07660 match(AT);
07661 addressConstant();
07662 if (inputState->guessing==0) {
07663 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07664 }
07665 break;
07666 }
07667 case SEMI:
07668 case END:
07669 case FINALIZATION:
07670 case ELSE:
07671 case UNTIL:
07672 case EXCEPT:
07673 case FINALLY:
07674 {
07675 break;
07676 }
07677 default:
07678 {
07679 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07680 }
07681 }
07682 }
07683 break;
07684 }
07685 case SEMI:
07686 case END:
07687 case FINALIZATION:
07688 case ELSE:
07689 case UNTIL:
07690 case EXCEPT:
07691 case FINALLY:
07692 {
07693 break;
07694 }
07695 default:
07696 {
07697 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07698 }
07699 }
07700 }
07701 raiseStatement_AST = (currentAST.root);
07702 }
07703 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07704 if( inputState->guessing == 0 ) {
07705 reportError(ex);
07706 consume();
07707 consumeUntil(_tokenSet_16);
07708 } else {
07709 throw;
07710 }
07711 }
07712 returnAST = raiseStatement_AST;
07713 }
07714
07715 void PascalParser::identifierOrArrayIdentifier() {
07716 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07717 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07718 RefPascalAST identifierOrArrayIdentifier_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07719
07720 try {
07721 if ((LA(1) == IDENT) && (_tokenSet_65.member(LA(2)))) {
07722 identifier();
07723 if (inputState->guessing==0) {
07724 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07725 }
07726 identifierOrArrayIdentifier_AST = (currentAST.root);
07727 }
07728 else if ((LA(1) == IDENT) && (LA(2) == LBRACK)) {
07729 identifier();
07730 if (inputState->guessing==0) {
07731 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07732 }
07733 match(LBRACK);
07734 expression();
07735 if (inputState->guessing==0) {
07736 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07737 }
07738 {
07739 for (;;) {
07740 if ((LA(1) == COMMA)) {
07741 match(COMMA);
07742 expression();
07743 if (inputState->guessing==0) {
07744 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07745 }
07746 }
07747 else {
07748 goto _loop302;
07749 }
07750
07751 }
07752 _loop302:;
07753 }
07754 match(RBRACK);
07755 identifierOrArrayIdentifier_AST = (currentAST.root);
07756 }
07757 else {
07758 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07759 }
07760
07761 }
07762 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07763 if( inputState->guessing == 0 ) {
07764 reportError(ex);
07765 consume();
07766 consumeUntil(_tokenSet_65);
07767 } else {
07768 throw;
07769 }
07770 }
07771 returnAST = identifierOrArrayIdentifier_AST;
07772 }
07773
07774 void PascalParser::assignmentOperator() {
07775 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07776 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07777 RefPascalAST assignmentOperator_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07778
07779 try {
07780 switch ( LA(1)) {
07781 case ASSIGN:
07782 {
07783 match(ASSIGN);
07784 assignmentOperator_AST = (currentAST.root);
07785 break;
07786 }
07787 case PLUSEQ:
07788 {
07789 RefPascalAST tmp280_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07790 if ( inputState->guessing == 0 ) {
07791 tmp280_AST = astFactory->create(LT(1));
07792 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp280_AST.get()));
07793 }
07794 match(PLUSEQ);
07795 assignmentOperator_AST = (currentAST.root);
07796 break;
07797 }
07798 case MINUSEQ:
07799 {
07800 RefPascalAST tmp281_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07801 if ( inputState->guessing == 0 ) {
07802 tmp281_AST = astFactory->create(LT(1));
07803 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp281_AST.get()));
07804 }
07805 match(MINUSEQ);
07806 assignmentOperator_AST = (currentAST.root);
07807 break;
07808 }
07809 case STAREQ:
07810 {
07811 RefPascalAST tmp282_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07812 if ( inputState->guessing == 0 ) {
07813 tmp282_AST = astFactory->create(LT(1));
07814 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp282_AST.get()));
07815 }
07816 match(STAREQ);
07817 assignmentOperator_AST = (currentAST.root);
07818 break;
07819 }
07820 case SLASHQE:
07821 {
07822 RefPascalAST tmp283_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07823 if ( inputState->guessing == 0 ) {
07824 tmp283_AST = astFactory->create(LT(1));
07825 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp283_AST.get()));
07826 }
07827 match(SLASHQE);
07828 assignmentOperator_AST = (currentAST.root);
07829 break;
07830 }
07831 default:
07832 {
07833 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07834 }
07835 }
07836 }
07837 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07838 if( inputState->guessing == 0 ) {
07839 reportError(ex);
07840 consume();
07841 consumeUntil(_tokenSet_36);
07842 } else {
07843 throw;
07844 }
07845 }
07846 returnAST = assignmentOperator_AST;
07847 }
07848
07849 void PascalParser::repetitiveStatement() {
07850 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07851 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07852 RefPascalAST repetitiveStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07853
07854 try {
07855 switch ( LA(1)) {
07856 case FOR:
07857 {
07858 forStatement();
07859 if (inputState->guessing==0) {
07860 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07861 }
07862 repetitiveStatement_AST = (currentAST.root);
07863 break;
07864 }
07865 case REPEAT:
07866 {
07867 repeatStatement();
07868 if (inputState->guessing==0) {
07869 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07870 }
07871 repetitiveStatement_AST = (currentAST.root);
07872 break;
07873 }
07874 case WHILE:
07875 {
07876 whileStatement();
07877 if (inputState->guessing==0) {
07878 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07879 }
07880 repetitiveStatement_AST = (currentAST.root);
07881 break;
07882 }
07883 default:
07884 {
07885 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07886 }
07887 }
07888 }
07889 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07890 if( inputState->guessing == 0 ) {
07891 reportError(ex);
07892 consume();
07893 consumeUntil(_tokenSet_16);
07894 } else {
07895 throw;
07896 }
07897 }
07898 returnAST = repetitiveStatement_AST;
07899 }
07900
07901 void PascalParser::conditionalStatement() {
07902 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07903 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07904 RefPascalAST conditionalStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07905
07906 try {
07907 switch ( LA(1)) {
07908 case IF:
07909 {
07910 ifStatement();
07911 if (inputState->guessing==0) {
07912 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07913 }
07914 conditionalStatement_AST = (currentAST.root);
07915 break;
07916 }
07917 case CASE:
07918 {
07919 caseStatement();
07920 if (inputState->guessing==0) {
07921 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07922 }
07923 conditionalStatement_AST = (currentAST.root);
07924 break;
07925 }
07926 default:
07927 {
07928 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
07929 }
07930 }
07931 }
07932 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07933 if( inputState->guessing == 0 ) {
07934 reportError(ex);
07935 consume();
07936 consumeUntil(_tokenSet_16);
07937 } else {
07938 throw;
07939 }
07940 }
07941 returnAST = conditionalStatement_AST;
07942 }
07943
07944 void PascalParser::exceptionStatement() {
07945 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07946 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07947 RefPascalAST exceptionStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07948
07949 try {
07950 tryStatement();
07951 if (inputState->guessing==0) {
07952 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07953 }
07954 exceptionStatement_AST = (currentAST.root);
07955 }
07956 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07957 if( inputState->guessing == 0 ) {
07958 reportError(ex);
07959 consume();
07960 consumeUntil(_tokenSet_16);
07961 } else {
07962 throw;
07963 }
07964 }
07965 returnAST = exceptionStatement_AST;
07966 }
07967
07968 void PascalParser::withStatement() {
07969 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07970 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
07971 RefPascalAST withStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07972
07973 try {
07974 RefPascalAST tmp284_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
07975 if ( inputState->guessing == 0 ) {
07976 tmp284_AST = astFactory->create(LT(1));
07977 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp284_AST.get()));
07978 }
07979 match(WITH);
07980 recordVariableList();
07981 if (inputState->guessing==0) {
07982 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07983 }
07984 match(DO);
07985 statement();
07986 if (inputState->guessing==0) {
07987 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
07988 }
07989 withStatement_AST = (currentAST.root);
07990 }
07991 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
07992 if( inputState->guessing == 0 ) {
07993 reportError(ex);
07994 consume();
07995 consumeUntil(_tokenSet_16);
07996 } else {
07997 throw;
07998 }
07999 }
08000 returnAST = withStatement_AST;
08001 }
08002
08003 void PascalParser::ifStatement() {
08004 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08005 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08006 RefPascalAST ifStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08007
08008 try {
08009 RefPascalAST tmp286_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08010 if ( inputState->guessing == 0 ) {
08011 tmp286_AST = astFactory->create(LT(1));
08012 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp286_AST.get()));
08013 }
08014 match(IF);
08015 expression();
08016 if (inputState->guessing==0) {
08017 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08018 }
08019 match(THEN);
08020 statement();
08021 if (inputState->guessing==0) {
08022 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08023 }
08024 {
08025 if ((LA(1) == ELSE) && (_tokenSet_24.member(LA(2)))) {
08026 match(ELSE);
08027 statement();
08028 if (inputState->guessing==0) {
08029 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08030 }
08031 }
08032 else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_66.member(LA(2)))) {
08033 }
08034 else {
08035 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08036 }
08037
08038 }
08039 ifStatement_AST = (currentAST.root);
08040 }
08041 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08042 if( inputState->guessing == 0 ) {
08043 reportError(ex);
08044 consume();
08045 consumeUntil(_tokenSet_16);
08046 } else {
08047 throw;
08048 }
08049 }
08050 returnAST = ifStatement_AST;
08051 }
08052
08053 void PascalParser::caseStatement() {
08054 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08055 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08056 RefPascalAST caseStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08057
08058 try {
08059 RefPascalAST tmp289_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08060 if ( inputState->guessing == 0 ) {
08061 tmp289_AST = astFactory->create(LT(1));
08062 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp289_AST.get()));
08063 }
08064 match(CASE);
08065 expression();
08066 if (inputState->guessing==0) {
08067 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08068 }
08069 match(OF);
08070 caseListElement();
08071 if (inputState->guessing==0) {
08072 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08073 }
08074 {
08075 for (;;) {
08076 if ((LA(1) == SEMI) && (_tokenSet_33.member(LA(2)))) {
08077 match(SEMI);
08078 caseListElement();
08079 if (inputState->guessing==0) {
08080 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08081 }
08082 }
08083 else {
08084 goto _loop320;
08085 }
08086
08087 }
08088 _loop320:;
08089 }
08090 {
08091 switch ( LA(1)) {
08092 case SEMI:
08093 {
08094 match(SEMI);
08095 match(ELSE);
08096 statement();
08097 if (inputState->guessing==0) {
08098 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08099 }
08100 {
08101 for (;;) {
08102 if ((LA(1) == SEMI)) {
08103 match(SEMI);
08104 statement();
08105 if (inputState->guessing==0) {
08106 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08107 }
08108 }
08109 else {
08110 goto _loop323;
08111 }
08112
08113 }
08114 _loop323:;
08115 }
08116 break;
08117 }
08118 case END:
08119 {
08120 break;
08121 }
08122 default:
08123 {
08124 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08125 }
08126 }
08127 }
08128 match(END);
08129 caseStatement_AST = (currentAST.root);
08130 }
08131 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08132 if( inputState->guessing == 0 ) {
08133 reportError(ex);
08134 consume();
08135 consumeUntil(_tokenSet_16);
08136 } else {
08137 throw;
08138 }
08139 }
08140 returnAST = caseStatement_AST;
08141 }
08142
08143 void PascalParser::forStatement() {
08144 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08145 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08146 RefPascalAST forStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08147
08148 try {
08149 RefPascalAST tmp296_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08150 if ( inputState->guessing == 0 ) {
08151 tmp296_AST = astFactory->create(LT(1));
08152 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp296_AST.get()));
08153 }
08154 match(FOR);
08155 identifier();
08156 if (inputState->guessing==0) {
08157 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08158 }
08159 match(ASSIGN);
08160 forList();
08161 if (inputState->guessing==0) {
08162 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08163 }
08164 match(DO);
08165 statement();
08166 if (inputState->guessing==0) {
08167 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08168 }
08169 forStatement_AST = (currentAST.root);
08170 }
08171 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08172 if( inputState->guessing == 0 ) {
08173 reportError(ex);
08174 consume();
08175 consumeUntil(_tokenSet_16);
08176 } else {
08177 throw;
08178 }
08179 }
08180 returnAST = forStatement_AST;
08181 }
08182
08183 void PascalParser::repeatStatement() {
08184 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08185 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08186 RefPascalAST repeatStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08187
08188 try {
08189 RefPascalAST tmp299_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08190 if ( inputState->guessing == 0 ) {
08191 tmp299_AST = astFactory->create(LT(1));
08192 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp299_AST.get()));
08193 }
08194 match(REPEAT);
08195 statement();
08196 if (inputState->guessing==0) {
08197 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08198 }
08199 {
08200 for (;;) {
08201 if ((LA(1) == SEMI)) {
08202 match(SEMI);
08203 {
08204 switch ( LA(1)) {
08205 case BEGIN:
08206 case NUM_INT:
08207 case CASE:
08208 case GOTO:
08209 case IF:
08210 case WHILE:
08211 case REPEAT:
08212 case FOR:
08213 case WITH:
08214 case RAISE:
08215 case TRY:
08216 case IDENT:
08217 {
08218 statement();
08219 if (inputState->guessing==0) {
08220 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08221 }
08222 break;
08223 }
08224 case SEMI:
08225 case UNTIL:
08226 {
08227 break;
08228 }
08229 default:
08230 {
08231 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08232 }
08233 }
08234 }
08235 }
08236 else {
08237 goto _loop332;
08238 }
08239
08240 }
08241 _loop332:;
08242 }
08243 match(UNTIL);
08244 expression();
08245 if (inputState->guessing==0) {
08246 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08247 }
08248 repeatStatement_AST = (currentAST.root);
08249 }
08250 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08251 if( inputState->guessing == 0 ) {
08252 reportError(ex);
08253 consume();
08254 consumeUntil(_tokenSet_16);
08255 } else {
08256 throw;
08257 }
08258 }
08259 returnAST = repeatStatement_AST;
08260 }
08261
08262 void PascalParser::whileStatement() {
08263 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08264 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08265 RefPascalAST whileStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08266
08267 try {
08268 RefPascalAST tmp302_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08269 if ( inputState->guessing == 0 ) {
08270 tmp302_AST = astFactory->create(LT(1));
08271 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp302_AST.get()));
08272 }
08273 match(WHILE);
08274 expression();
08275 if (inputState->guessing==0) {
08276 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08277 }
08278 match(DO);
08279 statement();
08280 if (inputState->guessing==0) {
08281 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08282 }
08283 whileStatement_AST = (currentAST.root);
08284 }
08285 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08286 if( inputState->guessing == 0 ) {
08287 reportError(ex);
08288 consume();
08289 consumeUntil(_tokenSet_16);
08290 } else {
08291 throw;
08292 }
08293 }
08294 returnAST = whileStatement_AST;
08295 }
08296
08297 void PascalParser::caseListElement() {
08298 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08299 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08300 RefPascalAST caseListElement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08301
08302 try {
08303 constList();
08304 if (inputState->guessing==0) {
08305 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08306 }
08307 RefPascalAST tmp304_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08308 if ( inputState->guessing == 0 ) {
08309 tmp304_AST = astFactory->create(LT(1));
08310 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp304_AST.get()));
08311 }
08312 match(COLON);
08313 statement();
08314 if (inputState->guessing==0) {
08315 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08316 }
08317 caseListElement_AST = (currentAST.root);
08318 }
08319 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08320 if( inputState->guessing == 0 ) {
08321 reportError(ex);
08322 consume();
08323 consumeUntil(_tokenSet_67);
08324 } else {
08325 throw;
08326 }
08327 }
08328 returnAST = caseListElement_AST;
08329 }
08330
08331 void PascalParser::constList() {
08332 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08333 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08334 RefPascalAST constList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08335
08336 try {
08337 constant();
08338 if (inputState->guessing==0) {
08339 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08340 }
08341 {
08342 for (;;) {
08343 if ((LA(1) == COMMA)) {
08344 match(COMMA);
08345 constant();
08346 if (inputState->guessing==0) {
08347 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08348 }
08349 }
08350 else {
08351 goto _loop327;
08352 }
08353
08354 }
08355 _loop327:;
08356 }
08357 if ( inputState->guessing==0 ) {
08358 constList_AST = RefPascalAST(currentAST.root);
08359 #line 746 "pascal.g"
08360 constList_AST = RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(astFactory->create(CONSTLIST).get()))->add(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(constList_AST.get()))));
08361 #line 8362 "PascalParser.cpp"
08362 currentAST.root = constList_AST;
08363 if ( constList_AST!=static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) &&
08364 constList_AST->getFirstChild() != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
08365 currentAST.child = constList_AST->getFirstChild();
08366 else
08367 currentAST.child = constList_AST;
08368 currentAST.advanceChildToEnd();
08369 }
08370 constList_AST = (currentAST.root);
08371 }
08372 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08373 if( inputState->guessing == 0 ) {
08374 reportError(ex);
08375 consume();
08376 consumeUntil(_tokenSet_55);
08377 } else {
08378 throw;
08379 }
08380 }
08381 returnAST = constList_AST;
08382 }
08383
08384 void PascalParser::forList() {
08385 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08386 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08387 RefPascalAST forList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08388
08389 try {
08390 initialValue();
08391 if (inputState->guessing==0) {
08392 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08393 }
08394 {
08395 switch ( LA(1)) {
08396 case TO:
08397 {
08398 RefPascalAST tmp306_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08399 if ( inputState->guessing == 0 ) {
08400 tmp306_AST = astFactory->create(LT(1));
08401 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp306_AST.get()));
08402 }
08403 match(TO);
08404 break;
08405 }
08406 case DOWNTO:
08407 {
08408 RefPascalAST tmp307_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08409 if ( inputState->guessing == 0 ) {
08410 tmp307_AST = astFactory->create(LT(1));
08411 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp307_AST.get()));
08412 }
08413 match(DOWNTO);
08414 break;
08415 }
08416 default:
08417 {
08418 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08419 }
08420 }
08421 }
08422 finalValue();
08423 if (inputState->guessing==0) {
08424 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08425 }
08426 forList_AST = (currentAST.root);
08427 }
08428 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08429 if( inputState->guessing == 0 ) {
08430 reportError(ex);
08431 consume();
08432 consumeUntil(_tokenSet_68);
08433 } else {
08434 throw;
08435 }
08436 }
08437 returnAST = forList_AST;
08438 }
08439
08440 void PascalParser::initialValue() {
08441 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08442 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08443 RefPascalAST initialValue_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08444
08445 try {
08446 expression();
08447 if (inputState->guessing==0) {
08448 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08449 }
08450 initialValue_AST = (currentAST.root);
08451 }
08452 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08453 if( inputState->guessing == 0 ) {
08454 reportError(ex);
08455 consume();
08456 consumeUntil(_tokenSet_69);
08457 } else {
08458 throw;
08459 }
08460 }
08461 returnAST = initialValue_AST;
08462 }
08463
08464 void PascalParser::finalValue() {
08465 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08466 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08467 RefPascalAST finalValue_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08468
08469 try {
08470 expression();
08471 if (inputState->guessing==0) {
08472 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08473 }
08474 finalValue_AST = (currentAST.root);
08475 }
08476 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08477 if( inputState->guessing == 0 ) {
08478 reportError(ex);
08479 consume();
08480 consumeUntil(_tokenSet_68);
08481 } else {
08482 throw;
08483 }
08484 }
08485 returnAST = finalValue_AST;
08486 }
08487
08488 void PascalParser::recordVariableList() {
08489 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08490 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08491 RefPascalAST recordVariableList_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08492
08493 try {
08494 variable();
08495 if (inputState->guessing==0) {
08496 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08497 }
08498 {
08499 for (;;) {
08500 if ((LA(1) == COMMA)) {
08501 match(COMMA);
08502 variable();
08503 if (inputState->guessing==0) {
08504 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08505 }
08506 }
08507 else {
08508 goto _loop341;
08509 }
08510
08511 }
08512 _loop341:;
08513 }
08514 recordVariableList_AST = (currentAST.root);
08515 }
08516 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08517 if( inputState->guessing == 0 ) {
08518 reportError(ex);
08519 consume();
08520 consumeUntil(_tokenSet_68);
08521 } else {
08522 throw;
08523 }
08524 }
08525 returnAST = recordVariableList_AST;
08526 }
08527
08543 void PascalParser::variable() {
08544 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08545 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08546 RefPascalAST variable_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08547
08548 try {
08549 {
08550 switch ( LA(1)) {
08551 case AT:
08552 {
08553 RefPascalAST tmp309_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08554 if ( inputState->guessing == 0 ) {
08555 tmp309_AST = astFactory->create(LT(1));
08556 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp309_AST.get()));
08557 }
08558 match(AT);
08559 identifier();
08560 if (inputState->guessing==0) {
08561 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08562 }
08563 break;
08564 }
08565 case IDENT:
08566 {
08567 identifier();
08568 if (inputState->guessing==0) {
08569 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08570 }
08571 break;
08572 }
08573 default:
08574 {
08575 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08576 }
08577 }
08578 }
08579 {
08580 for (;;) {
08581 switch ( LA(1)) {
08582 case LBRACK:
08583 {
08584 RefPascalAST tmp310_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08585 if ( inputState->guessing == 0 ) {
08586 tmp310_AST = astFactory->create(LT(1));
08587 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp310_AST.get()));
08588 }
08589 match(LBRACK);
08590 expression();
08591 if (inputState->guessing==0) {
08592 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08593 }
08594 {
08595 for (;;) {
08596 if ((LA(1) == COMMA)) {
08597 match(COMMA);
08598 expression();
08599 if (inputState->guessing==0) {
08600 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08601 }
08602 }
08603 else {
08604 goto _loop346;
08605 }
08606
08607 }
08608 _loop346:;
08609 }
08610 match(RBRACK);
08611 break;
08612 }
08613 case LBRACK2:
08614 {
08615 RefPascalAST tmp313_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08616 if ( inputState->guessing == 0 ) {
08617 tmp313_AST = astFactory->create(LT(1));
08618 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp313_AST.get()));
08619 }
08620 match(LBRACK2);
08621 expression();
08622 if (inputState->guessing==0) {
08623 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08624 }
08625 {
08626 for (;;) {
08627 if ((LA(1) == COMMA)) {
08628 match(COMMA);
08629 expression();
08630 if (inputState->guessing==0) {
08631 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08632 }
08633 }
08634 else {
08635 goto _loop348;
08636 }
08637
08638 }
08639 _loop348:;
08640 }
08641 match(RBRACK2);
08642 break;
08643 }
08644 case DOT:
08645 {
08646 RefPascalAST tmp316_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08647 if ( inputState->guessing == 0 ) {
08648 tmp316_AST = astFactory->create(LT(1));
08649 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp316_AST.get()));
08650 }
08651 match(DOT);
08652 identifier();
08653 if (inputState->guessing==0) {
08654 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08655 }
08656 break;
08657 }
08658 case POINTER:
08659 {
08660 RefPascalAST tmp317_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08661 if ( inputState->guessing == 0 ) {
08662 tmp317_AST = astFactory->create(LT(1));
08663 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp317_AST.get()));
08664 }
08665 match(POINTER);
08666 break;
08667 }
08668 default:
08669 {
08670 goto _loop349;
08671 }
08672 }
08673 }
08674 _loop349:;
08675 }
08676 variable_AST = (currentAST.root);
08677 }
08678 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08679 if( inputState->guessing == 0 ) {
08680 reportError(ex);
08681 consume();
08682 consumeUntil(_tokenSet_70);
08683 } else {
08684 throw;
08685 }
08686 }
08687 returnAST = variable_AST;
08688 }
08689
08690 void PascalParser::operatorDefinition() {
08691 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08692 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08693 RefPascalAST operatorDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08694
08695 try {
08696 RefPascalAST tmp318_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08697 if ( inputState->guessing == 0 ) {
08698 tmp318_AST = astFactory->create(LT(1));
08699 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp318_AST.get()));
08700 }
08701 match(OPERATOR);
08702 {
08703 switch ( LA(1)) {
08704 case ASSIGN:
08705 {
08706 assignmentOperatorDefinition();
08707 if (inputState->guessing==0) {
08708 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08709 }
08710 break;
08711 }
08712 case PLUS:
08713 case MINUS:
08714 case STAR:
08715 case SLASH:
08716 {
08717 arithmeticOperatorDefinition();
08718 if (inputState->guessing==0) {
08719 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08720 }
08721 break;
08722 }
08723 case EQUAL:
08724 case LE:
08725 case GE:
08726 case LTH:
08727 case GT:
08728 {
08729 comparisonOperatorDefinition();
08730 if (inputState->guessing==0) {
08731 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08732 }
08733 break;
08734 }
08735 default:
08736 {
08737 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08738 }
08739 }
08740 }
08741 identifier();
08742 if (inputState->guessing==0) {
08743 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08744 }
08745 match(COLON);
08746 type();
08747 if (inputState->guessing==0) {
08748 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08749 }
08750 match(SEMI);
08751 subroutineBlock();
08752 if (inputState->guessing==0) {
08753 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08754 }
08755 operatorDefinition_AST = /*static_cast<RefPascalAST>*/(currentAST.root);
08756 }
08757 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08758 if( inputState->guessing == 0 ) {
08759 reportError(ex);
08760 consume();
08761 consumeUntil(_tokenSet_0);
08762 } else {
08763 throw;
08764 }
08765 }
08766 returnAST = operatorDefinition_AST;
08767 }
08768
08769 void PascalParser::assignmentOperatorDefinition() {
08770 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08771 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08772 RefPascalAST assignmentOperatorDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08773
08774 try {
08775 match(ASSIGN);
08776 match(LPAREN);
08777 valueParameter();
08778 if (inputState->guessing==0) {
08779 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08780 }
08781 match(RPAREN);
08782 assignmentOperatorDefinition_AST = (currentAST.root);
08783 }
08784 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08785 if( inputState->guessing == 0 ) {
08786 reportError(ex);
08787 consume();
08788 consumeUntil(_tokenSet_71);
08789 } else {
08790 throw;
08791 }
08792 }
08793 returnAST = assignmentOperatorDefinition_AST;
08794 }
08795
08796 void PascalParser::arithmeticOperatorDefinition() {
08797 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08798 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08799 RefPascalAST arithmeticOperatorDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08800
08801 try {
08802 {
08803 switch ( LA(1)) {
08804 case PLUS:
08805 {
08806 match(PLUS);
08807 break;
08808 }
08809 case MINUS:
08810 {
08811 match(MINUS);
08812 break;
08813 }
08814 case SLASH:
08815 {
08816 match(SLASH);
08817 break;
08818 }
08819 default:
08820 if ((LA(1) == STAR) && (LA(2) == LPAREN)) {
08821 match(STAR);
08822 }
08823 else if ((LA(1) == STAR) && (LA(2) == STAR)) {
08824 {
08825 match(STAR);
08826 match(STAR);
08827 }
08828 }
08829 else {
08830 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08831 }
08832 }
08833 }
08834 match(LPAREN);
08835 formalParameterList();
08836 if (inputState->guessing==0) {
08837 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08838 }
08839 match(RPAREN);
08840 arithmeticOperatorDefinition_AST = (currentAST.root);
08841 }
08842 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08843 if( inputState->guessing == 0 ) {
08844 reportError(ex);
08845 consume();
08846 consumeUntil(_tokenSet_71);
08847 } else {
08848 throw;
08849 }
08850 }
08851 returnAST = arithmeticOperatorDefinition_AST;
08852 }
08853
08854 void PascalParser::comparisonOperatorDefinition() {
08855 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08856 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08857 RefPascalAST comparisonOperatorDefinition_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08858
08859 try {
08860 {
08861 switch ( LA(1)) {
08862 case EQUAL:
08863 {
08864 match(EQUAL);
08865 break;
08866 }
08867 case LE:
08868 {
08869 match(LE);
08870 break;
08871 }
08872 case GE:
08873 {
08874 match(GE);
08875 break;
08876 }
08877 case GT:
08878 {
08879 match(GT);
08880 break;
08881 }
08882 case LTH:
08883 {
08884 match(LTH);
08885 break;
08886 }
08887 default:
08888 {
08889 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08890 }
08891 }
08892 }
08893 match(LPAREN);
08894 formalParameterList();
08895 if (inputState->guessing==0) {
08896 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08897 }
08898 match(RPAREN);
08899 comparisonOperatorDefinition_AST = (currentAST.root);
08900 }
08901 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08902 if( inputState->guessing == 0 ) {
08903 reportError(ex);
08904 consume();
08905 consumeUntil(_tokenSet_71);
08906 } else {
08907 throw;
08908 }
08909 }
08910 returnAST = comparisonOperatorDefinition_AST;
08911 }
08912
08913 void PascalParser::tryStatement() {
08914 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08915 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08916 RefPascalAST tryStatement_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08917
08918 try {
08919 RefPascalAST tmp339_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08920 if ( inputState->guessing == 0 ) {
08921 tmp339_AST = astFactory->create(LT(1));
08922 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp339_AST.get()));
08923 }
08924 match(TRY);
08925 {
08926 switch ( LA(1)) {
08927 case BEGIN:
08928 case NUM_INT:
08929 case CASE:
08930 case GOTO:
08931 case IF:
08932 case WHILE:
08933 case REPEAT:
08934 case FOR:
08935 case WITH:
08936 case RAISE:
08937 case TRY:
08938 case IDENT:
08939 {
08940 statements();
08941 if (inputState->guessing==0) {
08942 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08943 }
08944 break;
08945 }
08946 case EXCEPT:
08947 case FINALLY:
08948 {
08949 break;
08950 }
08951 default:
08952 {
08953 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
08954 }
08955 }
08956 }
08957 exceptOrFinallyPart();
08958 if (inputState->guessing==0) {
08959 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08960 }
08961 match(END);
08962 tryStatement_AST = (currentAST.root);
08963 }
08964 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
08965 if( inputState->guessing == 0 ) {
08966 reportError(ex);
08967 consume();
08968 consumeUntil(_tokenSet_16);
08969 } else {
08970 throw;
08971 }
08972 }
08973 returnAST = tryStatement_AST;
08974 }
08975
08976 void PascalParser::statements() {
08977 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08978 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
08979 RefPascalAST statements_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
08980
08981 try {
08982 statement();
08983 if (inputState->guessing==0) {
08984 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08985 }
08986 {
08987 for (;;) {
08988 if ((LA(1) == SEMI)) {
08989 match(SEMI);
08990 statement();
08991 if (inputState->guessing==0) {
08992 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
08993 }
08994 }
08995 else {
08996 goto _loop369;
08997 }
08998
08999 }
09000 _loop369:;
09001 }
09002 statements_AST = (currentAST.root);
09003 }
09004 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09005 if( inputState->guessing == 0 ) {
09006 reportError(ex);
09007 consume();
09008 consumeUntil(_tokenSet_72);
09009 } else {
09010 throw;
09011 }
09012 }
09013 returnAST = statements_AST;
09014 }
09015
09016 void PascalParser::exceptOrFinallyPart() {
09017 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09018 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09019 RefPascalAST exceptOrFinallyPart_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09020
09021 try {
09022 switch ( LA(1)) {
09023 case EXCEPT:
09024 {
09025 match(EXCEPT);
09026 {
09027 switch ( LA(1)) {
09028 case BEGIN:
09029 case NUM_INT:
09030 case CASE:
09031 case GOTO:
09032 case IF:
09033 case WHILE:
09034 case REPEAT:
09035 case FOR:
09036 case WITH:
09037 case RAISE:
09038 case TRY:
09039 case ON:
09040 case IDENT:
09041 {
09042 exceptionHandlers();
09043 if (inputState->guessing==0) {
09044 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09045 }
09046 break;
09047 }
09048 case END:
09049 {
09050 break;
09051 }
09052 default:
09053 {
09054 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09055 }
09056 }
09057 }
09058 exceptOrFinallyPart_AST = (currentAST.root);
09059 break;
09060 }
09061 case FINALLY:
09062 {
09063 match(FINALLY);
09064 {
09065 switch ( LA(1)) {
09066 case BEGIN:
09067 case NUM_INT:
09068 case CASE:
09069 case GOTO:
09070 case IF:
09071 case WHILE:
09072 case REPEAT:
09073 case FOR:
09074 case WITH:
09075 case RAISE:
09076 case TRY:
09077 case IDENT:
09078 {
09079 statements();
09080 if (inputState->guessing==0) {
09081 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09082 }
09083 break;
09084 }
09085 case END:
09086 {
09087 break;
09088 }
09089 default:
09090 {
09091 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09092 }
09093 }
09094 }
09095 exceptOrFinallyPart_AST = (currentAST.root);
09096 break;
09097 }
09098 default:
09099 {
09100 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09101 }
09102 }
09103 }
09104 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09105 if( inputState->guessing == 0 ) {
09106 reportError(ex);
09107 consume();
09108 consumeUntil(_tokenSet_6);
09109 } else {
09110 throw;
09111 }
09112 }
09113 returnAST = exceptOrFinallyPart_AST;
09114 }
09115
09116 void PascalParser::exceptionHandlers() {
09117 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09118 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09119 RefPascalAST exceptionHandlers_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09120
09121 try {
09122 switch ( LA(1)) {
09123 case BEGIN:
09124 case NUM_INT:
09125 case CASE:
09126 case GOTO:
09127 case IF:
09128 case WHILE:
09129 case REPEAT:
09130 case FOR:
09131 case WITH:
09132 case RAISE:
09133 case TRY:
09134 case IDENT:
09135 {
09136 statements();
09137 if (inputState->guessing==0) {
09138 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09139 }
09140 exceptionHandlers_AST = (currentAST.root);
09141 break;
09142 }
09143 case ON:
09144 {
09145 exceptionHandler();
09146 if (inputState->guessing==0) {
09147 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09148 }
09149 {
09150 for (;;) {
09151 if ((LA(1) == SEMI)) {
09152 match(SEMI);
09153 exceptionHandler();
09154 if (inputState->guessing==0) {
09155 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09156 }
09157 }
09158 else {
09159 goto _loop372;
09160 }
09161
09162 }
09163 _loop372:;
09164 }
09165 {
09166 switch ( LA(1)) {
09167 case ELSE:
09168 {
09169 match(ELSE);
09170 statements();
09171 if (inputState->guessing==0) {
09172 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09173 }
09174 break;
09175 }
09176 case END:
09177 {
09178 break;
09179 }
09180 default:
09181 {
09182 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09183 }
09184 }
09185 }
09186 exceptionHandlers_AST = (currentAST.root);
09187 break;
09188 }
09189 default:
09190 {
09191 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09192 }
09193 }
09194 }
09195 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09196 if( inputState->guessing == 0 ) {
09197 reportError(ex);
09198 consume();
09199 consumeUntil(_tokenSet_6);
09200 } else {
09201 throw;
09202 }
09203 }
09204 returnAST = exceptionHandlers_AST;
09205 }
09206
09207 void PascalParser::exceptionHandler() {
09208 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09209 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09210 RefPascalAST exceptionHandler_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09211
09212 try {
09213 match(ON);
09214 {
09215 if ((LA(1) == IDENT) && (LA(2) == COLON)) {
09216 identifier();
09217 if (inputState->guessing==0) {
09218 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09219 }
09220 match(COLON);
09221 }
09222 else if ((LA(1) == IDENT) && (LA(2) == DO)) {
09223 }
09224 else {
09225 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09226 }
09227
09228 }
09229 identifier();
09230 if (inputState->guessing==0) {
09231 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09232 }
09233 match(DO);
09234 statement();
09235 if (inputState->guessing==0) {
09236 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09237 }
09238 exceptionHandler_AST = (currentAST.root);
09239 }
09240 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09241 if( inputState->guessing == 0 ) {
09242 reportError(ex);
09243 consume();
09244 consumeUntil(_tokenSet_73);
09245 } else {
09246 throw;
09247 }
09248 }
09249 returnAST = exceptionHandler_AST;
09250 }
09251
09252 void PascalParser::sign() {
09253 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09254 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09255 RefPascalAST sign_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09256
09257 try {
09258 switch ( LA(1)) {
09259 case PLUS:
09260 {
09261 RefPascalAST tmp349_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09262 if ( inputState->guessing == 0 ) {
09263 tmp349_AST = astFactory->create(LT(1));
09264 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp349_AST.get()));
09265 }
09266 match(PLUS);
09267 sign_AST = (currentAST.root);
09268 break;
09269 }
09270 case MINUS:
09271 {
09272 RefPascalAST tmp350_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09273 if ( inputState->guessing == 0 ) {
09274 tmp350_AST = astFactory->create(LT(1));
09275 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp350_AST.get()));
09276 }
09277 match(MINUS);
09278 sign_AST = (currentAST.root);
09279 break;
09280 }
09281 default:
09282 {
09283 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09284 }
09285 }
09286 }
09287 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09288 if( inputState->guessing == 0 ) {
09289 reportError(ex);
09290 consume();
09291 consumeUntil(_tokenSet_74);
09292 } else {
09293 throw;
09294 }
09295 }
09296 returnAST = sign_AST;
09297 }
09298
09299 void PascalParser::constantChr() {
09300 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09301 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09302 RefPascalAST constantChr_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09303
09304 try {
09305 RefPascalAST tmp351_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09306 if ( inputState->guessing == 0 ) {
09307 tmp351_AST = astFactory->create(LT(1));
09308 astFactory->makeASTRoot(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp351_AST.get()));
09309 }
09310 match(CHR);
09311 match(LPAREN);
09312 unsignedInteger();
09313 if (inputState->guessing==0) {
09314 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09315 }
09316 match(RPAREN);
09317 constantChr_AST = (currentAST.root);
09318 }
09319 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09320 if( inputState->guessing == 0 ) {
09321 reportError(ex);
09322 consume();
09323 consumeUntil(_tokenSet_75);
09324 } else {
09325 throw;
09326 }
09327 }
09328 returnAST = constantChr_AST;
09329 }
09330
09331 void PascalParser::unsignedNumber() {
09332 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09333 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09334 RefPascalAST unsignedNumber_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09335
09336 try {
09337 switch ( LA(1)) {
09338 case NUM_INT:
09339 {
09340 unsignedInteger();
09341 if (inputState->guessing==0) {
09342 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09343 }
09344 unsignedNumber_AST = (currentAST.root);
09345 break;
09346 }
09347 case NUM_REAL:
09348 {
09349 unsignedReal();
09350 if (inputState->guessing==0) {
09351 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(returnAST.get()));
09352 }
09353 unsignedNumber_AST = (currentAST.root);
09354 break;
09355 }
09356 default:
09357 {
09358 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
09359 }
09360 }
09361 }
09362 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09363 if( inputState->guessing == 0 ) {
09364 reportError(ex);
09365 consume();
09366 consumeUntil(_tokenSet_76);
09367 } else {
09368 throw;
09369 }
09370 }
09371 returnAST = unsignedNumber_AST;
09372 }
09373
09374 void PascalParser::unsignedReal() {
09375 returnAST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09376 ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
09377 RefPascalAST unsignedReal_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09378
09379 try {
09380 RefPascalAST tmp354_AST = static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get());
09381 if ( inputState->guessing == 0 ) {
09382 tmp354_AST = astFactory->create(LT(1));
09383 astFactory->addASTChild(currentAST, static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(tmp354_AST.get()));
09384 }
09385 match(NUM_REAL);
09386 unsignedReal_AST = (currentAST.root);
09387 }
09388 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
09389 if( inputState->guessing == 0 ) {
09390 reportError(ex);
09391 consume();
09392 consumeUntil(_tokenSet_76);
09393 } else {
09394 throw;
09395 }
09396 }
09397 returnAST = unsignedReal_AST;
09398 }
09399
09400 RefPascalAST PascalParser::getAST()
09401 {
09402 return returnAST;
09403 }
09404
09405 void PascalParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
09406 {
09407 factory.setMaxNodeType(189);
09408 }
09409 const char* PascalParser::tokenNames[] = {
09410 "<0>",
09411 "EOF",
09412 "<2>",
09413 "NULL_TREE_LOOKAHEAD",
09414 "BLOCK",
09415 "IDLIST",
09416 "ELIST",
09417 "FUNC_CALL",
09418 "PROC_CALL",
09419 "SCALARTYPE",
09420 "TYPELIST",
09421 "VARIANT_TAG",
09422 "VARIANT_TAG_NO_ID",
09423 "VARIANT_CASE",
09424 "CONSTLIST",
09425 "FIELDLIST",
09426 "ARGDECLS",
09427 "VARDECL",
09428 "ARGDECL",
09429 "ARGLIST",
09430 "TYPEDECL",
09431 "FIELD",
09432 "DOT",
09433 "\"library\"",
09434 "SEMI",
09435 "\"end\"",
09436 "\"exports\"",
09437 "COMMA",
09438 "\"index\"",
09439 "\"name\"",
09440 "\"uses\"",
09441 "\"unit\"",
09442 "\"interface\"",
09443 "\"implementation\"",
09444 "\"begin\"",
09445 "\"program\"",
09446 "LPAREN",
09447 "RPAREN",
09448 "\"initialization\"",
09449 "\"finalization\"",
09450 "\"label\"",
09451 "\"const\"",
09452 "\"resourcestring\"",
09453 "EQUAL",
09454 "\"type\"",
09455 "\"var\"",
09456 "COLON",
09457 "\"procedure\"",
09458 "\"forward\"",
09459 "\"function\"",
09460 "\"array\"",
09461 "\"of\"",
09462 "\"external\"",
09463 "\"public\"",
09464 "\"alias\"",
09465 "INTERRUPT",
09466 "\"export\"",
09467 "\"register\"",
09468 "\"pascal\"",
09469 "\"cdecl\"",
09470 "\"stdcall\"",
09471 "\"popstack\"",
09472 "\"saveregisters\"",
09473 "\"inline\"",
09474 "\"safecall\"",
09475 "\"near\"",
09476 "\"far\"",
09477 "NUM_INT",
09478 "\"integer\"",
09479 "\"shortint\"",
09480 "\"smallint\"",
09481 "\"longint\"",
09482 "\"int64\"",
09483 "\"byte\"",
09484 "\"word\"",
09485 "\"cardinal\"",
09486 "\"qword\"",
09487 "\"boolean\"",
09488 "BYTEBOOL",
09489 "LONGBOOL",
09490 "\"char\"",
09491 "DOTDOT",
09492 "ASSIGN",
09493 "\"real\"",
09494 "\"single\"",
09495 "\"double\"",
09496 "\"extended\"",
09497 "\"comp\"",
09498 "\"string\"",
09499 "LBRACK",
09500 "RBRACK",
09501 "\"packed\"",
09502 "\"record\"",
09503 "\"case\"",
09504 "\"set\"",
09505 "\"file\"",
09506 "POINTER",
09507 "\"object\"",
09508 "\"virtual\"",
09509 "\"abstract\"",
09510 "\"private\"",
09511 "\"protected\"",
09512 "\"constructor\"",
09513 "\"destructor\"",
09514 "\"class\"",
09515 "\"override\"",
09516 "MESSAGE",
09517 "\"published\"",
09518 "\"property\"",
09519 "\"read\"",
09520 "\"write\"",
09521 "\"default\"",
09522 "\"nodefault\"",
09523 "LE",
09524 "GE",
09525 "LTH",
09526 "GT",
09527 "NOT_EQUAL",
09528 "\"in\"",
09529 "\"is\"",
09530 "PLUS",
09531 "MINUS",
09532 "\"or\"",
09533 "\"xor\"",
09534 "STAR",
09535 "SLASH",
09536 "\"div\"",
09537 "\"mod\"",
09538 "\"and\"",
09539 "\"shl\"",
09540 "\"shr\"",
09541 "\"not\"",
09542 "\"true\"",
09543 "\"false\"",
09544 "AT",
09545 "PLUSEQ",
09546 "MINUSEQ",
09547 "STAREQ",
09548 "SLASHQE",
09549 "\"goto\"",
09550 "\"if\"",
09551 "\"then\"",
09552 "\"else\"",
09553 "\"while\"",
09554 "\"do\"",
09555 "\"repeat\"",
09556 "\"until\"",
09557 "\"for\"",
09558 "\"to\"",
09559 "\"downto\"",
09560 "\"with\"",
09561 "LBRACK2",
09562 "RBRACK2",
09563 "\"operator\"",
09564 "\"raise\"",
09565 "\"try\"",
09566 "\"except\"",
09567 "\"finally\"",
09568 "\"on\"",
09569 "STRING_LITERAL",
09570 "\"chr\"",
09571 "\"nil\"",
09572 "NUM_REAL",
09573 "IDENT",
09574 "\"absolute\"",
09575 "\"as\"",
09576 "\"asm\"",
09577 "\"assembler\"",
09578 "\"break\"",
09579 "\"continue\"",
09580 "\"dispose\"",
09581 "\"exit\"",
09582 "\"inherited\"",
09583 "\"new\"",
09584 "\"self\"",
09585 "METHOD",
09586 "ADDSUBOR",
09587 "ASSIGNEQUAL",
09588 "SIGN",
09589 "FUNC",
09590 "NODE_NOT_EMIT",
09591 "MYASTVAR",
09592 "LF",
09593 "LCURLY",
09594 "RCURLY",
09595 "WS",
09596 "COMMENT_1",
09597 "COMMENT_2",
09598 "COMMENT_3",
09599 "EXPONENT",
09600 0
09601 };
09602
09603 const unsigned long PascalParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09604
09605 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_0(_tokenSet_0_data_,6);
09606 const unsigned long PascalParser::_tokenSet_1_data_[] = { 1073741824UL, 177924UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09607
09608
09609 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_1(_tokenSet_1_data_,8);
09610 const unsigned long PascalParser::_tokenSet_2_data_[] = { 100663296UL, 177990UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09611
09612
09613 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_2(_tokenSet_2_data_,8);
09614 const unsigned long PascalParser::_tokenSet_3_data_[] = { 121634818UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09615
09616
09617 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_3(_tokenSet_3_data_,8);
09618 const unsigned long PascalParser::_tokenSet_4_data_[] = { 994050050UL, 706736UL, 101056512UL, 4294963649UL, 833972167UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09619
09620
09621
09622
09623
09624
09625
09626 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_4(_tokenSet_4_data_,12);
09627 const unsigned long PascalParser::_tokenSet_5_data_[] = { 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09628
09629 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_5(_tokenSet_5_data_,6);
09630 const unsigned long PascalParser::_tokenSet_6_data_[] = { 33554432UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09631
09632 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_6(_tokenSet_6_data_,6);
09633 const unsigned long PascalParser::_tokenSet_7_data_[] = { 100663296UL, 68UL, 0UL, 0UL, 0UL, 0UL };
09634
09635 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_7(_tokenSet_7_data_,6);
09636 const unsigned long PascalParser::_tokenSet_8_data_[] = { 184549376UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09637
09638 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_8(_tokenSet_8_data_,6);
09639 const unsigned long PascalParser::_tokenSet_9_data_[] = { 788529154UL, 177988UL, 0UL, 127424UL, 0UL, 0UL, 0UL, 0UL };
09640
09641
09642
09643 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_9(_tokenSet_9_data_,8);
09644 const unsigned long PascalParser::_tokenSet_10_data_[] = { 1056964610UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09645
09646
09647
09648 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_10(_tokenSet_10_data_,8);
09649 const unsigned long PascalParser::_tokenSet_11_data_[] = { 16777216UL, 16416UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09650
09651 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_11(_tokenSet_11_data_,8);
09652 const unsigned long PascalParser::_tokenSet_12_data_[] = { 0UL, 2UL, 0UL, 0UL, 0UL, 0UL };
09653
09654 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_12(_tokenSet_12_data_,6);
09655 const unsigned long PascalParser::_tokenSet_13_data_[] = { 33554432UL, 68UL, 0UL, 0UL, 0UL, 0UL };
09656
09657 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_13(_tokenSet_13_data_,6);
09658 const unsigned long PascalParser::_tokenSet_14_data_[] = { 33554432UL, 128UL, 0UL, 0UL, 0UL, 0UL };
09659
09660 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_14(_tokenSet_14_data_,6);
09661 const unsigned long PascalParser::_tokenSet_15_data_[] = { 0UL, 168450UL, 0UL, 0UL, 0UL, 0UL };
09662
09663 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_15(_tokenSet_15_data_,6);
09664 const unsigned long PascalParser::_tokenSet_16_data_[] = { 50331648UL, 128UL, 0UL, 0UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09665
09666 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_16(_tokenSet_16_data_,12);
09667 const unsigned long PascalParser::_tokenSet_17_data_[] = { 100663296UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09668
09669
09670 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_17(_tokenSet_17_data_,8);
09671 const unsigned long PascalParser::_tokenSet_18_data_[] = { 184549376UL, 16512UL, 0UL, 0UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09672
09673 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_18(_tokenSet_18_data_,12);
09674 const unsigned long PascalParser::_tokenSet_19_data_[] = { 100663296UL, 177990UL, 0UL, 192UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09675
09676
09677
09678 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_19(_tokenSet_19_data_,12);
09679 const unsigned long PascalParser::_tokenSet_20_data_[] = { 100663296UL, 177988UL, 0UL, 192UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09680
09681
09682 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_20(_tokenSet_20_data_,12);
09683 const unsigned long PascalParser::_tokenSet_21_data_[] = { 1061158914UL, 720868UL, 67239936UL, 4294840768UL, 825581575UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09684
09685
09686
09687
09688
09689
09690 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_21(_tokenSet_21_data_,12);
09691 const unsigned long PascalParser::_tokenSet_22_data_[] = { 16777216UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09692
09693 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_22(_tokenSet_22_data_,6);
09694 const unsigned long PascalParser::_tokenSet_23_data_[] = { 16777216UL, 2080UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09695
09696 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_23(_tokenSet_23_data_,8);
09697 const unsigned long PascalParser::_tokenSet_24_data_[] = { 0UL, 4UL, 536870920UL, 0UL, 206215168UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09698
09699
09700 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_24(_tokenSet_24_data_,12);
09701 const unsigned long PascalParser::_tokenSet_25_data_[] = { 121634818UL, 178116UL, 0UL, 192UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09702
09703
09704
09705 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_25(_tokenSet_25_data_,12);
09706 const unsigned long PascalParser::_tokenSet_26_data_[] = { 16777216UL, 1818406UL, 67108864UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09707
09708
09709
09710 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_26(_tokenSet_26_data_,8);
09711 const unsigned long PascalParser::_tokenSet_27_data_[] = { 117440514UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09712
09713
09714 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_27(_tokenSet_27_data_,8);
09715 const unsigned long PascalParser::_tokenSet_28_data_[] = { 16777216UL, 16400UL, 0UL, 0UL, 0UL, 0UL };
09716
09717 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_28(_tokenSet_28_data_,6);
09718 const unsigned long PascalParser::_tokenSet_29_data_[] = { 16777216UL, 16416UL, 0UL, 0UL, 0UL, 0UL };
09719
09720 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_29(_tokenSet_29_data_,6);
09721 const unsigned long PascalParser::_tokenSet_30_data_[] = { 16777216UL, 32UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09722
09723 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_30(_tokenSet_30_data_,8);
09724 const unsigned long PascalParser::_tokenSet_31_data_[] = { 0UL, 426000UL, 3657039864UL, 50331907UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09725
09726
09727
09728
09729
09730 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_31(_tokenSet_31_data_,12);
09731 const unsigned long PascalParser::_tokenSet_32_data_[] = { 188743680UL, 524448UL, 67239936UL, 0UL, 825581568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09732
09733
09734 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_32(_tokenSet_32_data_,12);
09735 const unsigned long PascalParser::_tokenSet_33_data_[] = { 0UL, 0UL, 8UL, 50331648UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09736
09737 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_33(_tokenSet_33_data_,12);
09738 const unsigned long PascalParser::_tokenSet_34_data_[] = { 16777216UL, 16UL, 8UL, 0UL, 0UL, 12UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09739
09740 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_34(_tokenSet_34_data_,12);
09741 const unsigned long PascalParser::_tokenSet_35_data_[] = { 0UL, 16UL, 8UL, 50331648UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09742
09743 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_35(_tokenSet_35_data_,12);
09744 const unsigned long PascalParser::_tokenSet_36_data_[] = { 0UL, 16UL, 33554440UL, 50331648UL, 2147483768UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09745
09746
09747 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_36(_tokenSet_36_data_,12);
09748 const unsigned long PascalParser::_tokenSet_37_data_[] = { 16777216UL, 2064UL, 100663304UL, 4294836224UL, 2147483775UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09749
09750
09751
09752 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_37(_tokenSet_37_data_,12);
09753 const unsigned long PascalParser::_tokenSet_38_data_[] = { 184549378UL, 182304UL, 67239936UL, 4544UL, 0UL, 0UL, 0UL, 0UL };
09754
09755
09756 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_38(_tokenSet_38_data_,8);
09757 const unsigned long PascalParser::_tokenSet_39_data_[] = { 150994944UL, 32UL, 0UL, 0UL, 0UL, 0UL };
09758
09759 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_39(_tokenSet_39_data_,6);
09760 const unsigned long PascalParser::_tokenSet_40_data_[] = { 150994944UL, 2080UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09761
09762 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_40(_tokenSet_40_data_,8);
09763 const unsigned long PascalParser::_tokenSet_41_data_[] = { 318767104UL, 165936UL, 67108864UL, 127424UL, 0UL, 0UL, 0UL, 0UL };
09764
09765
09766
09767 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_41(_tokenSet_41_data_,8);
09768 const unsigned long PascalParser::_tokenSet_42_data_[] = { 0UL, 32UL, 0UL, 0UL, 0UL, 0UL };
09769
09770 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_42(_tokenSet_42_data_,6);
09771 const unsigned long PascalParser::_tokenSet_43_data_[] = { 792723458UL, 720868UL, 67239936UL, 4294963648UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09772
09773
09774
09775
09776
09777
09778
09779 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_43(_tokenSet_43_data_,12);
09780 const unsigned long PascalParser::_tokenSet_44_data_[] = { 0UL, 2064UL, 100794376UL, 4294836224UL, 2147483775UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09781
09782
09783
09784 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_44(_tokenSet_44_data_,12);
09785 const unsigned long PascalParser::_tokenSet_45_data_[] = { 134217728UL, 0UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09786
09787 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_45(_tokenSet_45_data_,8);
09788 const unsigned long PascalParser::_tokenSet_46_data_[] = { 33554432UL, 32UL, 536870912UL, 0UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09789
09790 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_46(_tokenSet_46_data_,12);
09791 const unsigned long PascalParser::_tokenSet_47_data_[] = { 50331648UL, 32UL, 536870912UL, 0UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09792
09793 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_47(_tokenSet_47_data_,12);
09794 const unsigned long PascalParser::_tokenSet_48_data_[] = { 33554432UL, 2260992UL, 0UL, 6640UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09795
09796
09797 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_48(_tokenSet_48_data_,12);
09798 const unsigned long PascalParser::_tokenSet_49_data_[] = { 0UL, 163840UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09799
09800 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_49(_tokenSet_49_data_,8);
09801 const unsigned long PascalParser::_tokenSet_50_data_[] = { 33554432UL, 163840UL, 0UL, 4544UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09802
09803
09804 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_50(_tokenSet_50_data_,12);
09805 const unsigned long PascalParser::_tokenSet_51_data_[] = { 33554432UL, 163840UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
09806
09807 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_51(_tokenSet_51_data_,8);
09808 const unsigned long PascalParser::_tokenSet_52_data_[] = { 0UL, 163840UL, 0UL, 4544UL, 0UL, 0UL, 0UL, 0UL };
09809
09810 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_52(_tokenSet_52_data_,8);
09811 const unsigned long PascalParser::_tokenSet_53_data_[] = { 33554432UL, 163840UL, 0UL, 4544UL, 0UL, 0UL, 0UL, 0UL };
09812
09813 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_53(_tokenSet_53_data_,8);
09814 const unsigned long PascalParser::_tokenSet_54_data_[] = { 33554432UL, 163840UL, 0UL, 127424UL, 0UL, 0UL, 0UL, 0UL };
09815
09816
09817 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_54(_tokenSet_54_data_,8);
09818 const unsigned long PascalParser::_tokenSet_55_data_[] = { 0UL, 16384UL, 0UL, 0UL, 0UL, 0UL };
09819
09820 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_55(_tokenSet_55_data_,6);
09821 const unsigned long PascalParser::_tokenSet_56_data_[] = { 33554432UL, 163840UL, 0UL, 119232UL, 0UL, 0UL, 0UL, 0UL };
09822
09823
09824 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_56(_tokenSet_56_data_,8);
09825 const unsigned long PascalParser::_tokenSet_57_data_[] = { 33554432UL, 163840UL, 0UL, 102848UL, 0UL, 0UL, 0UL, 0UL };
09826
09827
09828 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_57(_tokenSet_57_data_,8);
09829 const unsigned long PascalParser::_tokenSet_58_data_[] = { 188743680UL, 526496UL, 67239936UL, 16646144UL, 825581568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09830
09831
09832
09833 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_58(_tokenSet_58_data_,12);
09834 const unsigned long PascalParser::_tokenSet_59_data_[] = { 188743680UL, 526496UL, 67239936UL, 268304384UL, 825581568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09835
09836
09837
09838 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_59(_tokenSet_59_data_,12);
09839 const unsigned long PascalParser::_tokenSet_60_data_[] = { 188743680UL, 526512UL, 67239936UL, 4294836224UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09840
09841
09842
09843
09844 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_60(_tokenSet_60_data_,12);
09845 const unsigned long PascalParser::_tokenSet_61_data_[] = { 188743680UL, 526496UL, 67239936UL, 4294836224UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09846
09847
09848
09849
09850 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_61(_tokenSet_61_data_,12);
09851 const unsigned long PascalParser::_tokenSet_62_data_[] = { 50331648UL, 128UL, 0UL, 0UL, 805584960UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09852
09853 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_62(_tokenSet_62_data_,12);
09854 const unsigned long PascalParser::_tokenSet_63_data_[] = { 0UL, 0UL, 33816576UL, 0UL, 1920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09855
09856 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_63(_tokenSet_63_data_,12);
09857 const unsigned long PascalParser::_tokenSet_64_data_[] = { 50331648UL, 144UL, 0UL, 0UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09858
09859 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_64(_tokenSet_64_data_,12);
09860 const unsigned long PascalParser::_tokenSet_65_data_[] = { 0UL, 0UL, 262144UL, 0UL, 1920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09861
09862 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_65(_tokenSet_65_data_,12);
09863 const unsigned long PascalParser::_tokenSet_66_data_[] = { 121634818UL, 178132UL, 570425352UL, 50331840UL, 4233025656UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09864
09865
09866
09867
09868
09869
09870 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_66(_tokenSet_66_data_,12);
09871 const unsigned long PascalParser::_tokenSet_67_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09872
09873 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_67(_tokenSet_67_data_,6);
09874 const unsigned long PascalParser::_tokenSet_68_data_[] = { 0UL, 0UL, 0UL, 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09875
09876 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_68(_tokenSet_68_data_,12);
09877 const unsigned long PascalParser::_tokenSet_69_data_[] = { 0UL, 0UL, 0UL, 0UL, 3145728UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09878
09879 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_69(_tokenSet_69_data_,12);
09880 const unsigned long PascalParser::_tokenSet_70_data_[] = { 134217728UL, 0UL, 0UL, 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09881
09882 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_70(_tokenSet_70_data_,12);
09883 const unsigned long PascalParser::_tokenSet_71_data_[] = { 0UL, 0UL, 0UL, 0UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09884
09885 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_71(_tokenSet_71_data_,12);
09886 const unsigned long PascalParser::_tokenSet_72_data_[] = { 33554432UL, 0UL, 0UL, 0UL, 805306368UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09887
09888 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_72(_tokenSet_72_data_,12);
09889 const unsigned long PascalParser::_tokenSet_73_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 16384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09890
09891 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_73(_tokenSet_73_data_,12);
09892 const unsigned long PascalParser::_tokenSet_74_data_[] = { 0UL, 0UL, 8UL, 0UL, 0UL, 12UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09893
09894 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_74(_tokenSet_74_data_,12);
09895 const unsigned long PascalParser::_tokenSet_75_data_[] = { 1061158914UL, 720868UL, 67239936UL, 4294840768UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09896
09897
09898
09899
09900
09901
09902 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_75(_tokenSet_75_data_,12);
09903 const unsigned long PascalParser::_tokenSet_76_data_[] = { 188743682UL, 706720UL, 67239936UL, 4294840768UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
09904
09905
09906
09907
09908
09909 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_76(_tokenSet_76_data_,12);
09910
09911