00001
00002 #include "PascalStoreWalker.hpp"
00003 #include <antlr/Token.hpp>
00004 #include <antlr/AST.hpp>
00005 #include <antlr/NoViableAltException.hpp>
00006 #include <antlr/MismatchedTokenException.hpp>
00007 #include <antlr/SemanticException.hpp>
00008 #include <antlr/BitSet.hpp>
00009 #line 1 "pascal.tree.g"
00010 #line 11 "PascalStoreWalker.cpp"
00011 PascalStoreWalker::PascalStoreWalker()
00012 : ANTLR_USE_NAMESPACE(antlr)TreeParser() {
00013 }
00014
00015 void PascalStoreWalker::program(RefPascalAST _t) {
00016 RefPascalAST program_AST_in = _t;
00017
00018 try {
00019 programHeading(_t);
00020 _t = _retTree;
00021 block(_t);
00022 _t = _retTree;
00023 }
00024 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00025 reportError(ex);
00026 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00027 _t = _t->getNextSibling();
00028 }
00029 _retTree = _t;
00030 }
00031
00032 void PascalStoreWalker::programHeading(RefPascalAST _t) {
00033 RefPascalAST programHeading_AST_in = _t;
00034
00035 try {
00036 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00037 _t = ASTNULL;
00038 switch ( _t->getType()) {
00039 case PROGRAM:
00040 {
00041 RefPascalAST __t3 = _t;
00042 RefPascalAST tmp1_AST_in = _t;
00043 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PROGRAM);
00044 _t = _t->getFirstChild();
00045 RefPascalAST tmp2_AST_in = _t;
00046 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00047 _t = _t->getNextSibling();
00048 identifierList(_t);
00049 _t = _retTree;
00050 _t = __t3;
00051 _t = _t->getNextSibling();
00052 break;
00053 }
00054 case UNIT:
00055 {
00056 RefPascalAST __t4 = _t;
00057 RefPascalAST tmp3_AST_in = _t;
00058 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),UNIT);
00059 _t = _t->getFirstChild();
00060 RefPascalAST tmp4_AST_in = _t;
00061 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00062 _t = _t->getNextSibling();
00063 _t = __t4;
00064 _t = _t->getNextSibling();
00065 break;
00066 }
00067 default:
00068 {
00069 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00070 }
00071 }
00072 }
00073 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00074 reportError(ex);
00075 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00076 _t = _t->getNextSibling();
00077 }
00078 _retTree = _t;
00079 }
00080
00081 void PascalStoreWalker::block(RefPascalAST _t) {
00082 RefPascalAST block_AST_in = _t;
00083
00084 try {
00085 {
00086 for (;;) {
00087 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00088 _t = ASTNULL;
00089 switch ( _t->getType()) {
00090 case LABEL:
00091 {
00092 labelDeclarationPart(_t);
00093 _t = _retTree;
00094 break;
00095 }
00096 case CONST:
00097 {
00098 constantDefinitionPart(_t);
00099 _t = _retTree;
00100 break;
00101 }
00102 case TYPE:
00103 {
00104 typeDefinitionPart(_t);
00105 _t = _retTree;
00106 break;
00107 }
00108 case VAR:
00109 {
00110 variableDeclarationPart(_t);
00111 _t = _retTree;
00112 break;
00113 }
00114 case PROCEDURE:
00115 case FUNCTION:
00116 {
00117 procedureAndFunctionDeclarationPart(_t);
00118 _t = _retTree;
00119 break;
00120 }
00121 case USES:
00122 {
00123 usesUnitsPart(_t);
00124 _t = _retTree;
00125 break;
00126 }
00127 case IMPLEMENTATION:
00128 {
00129 RefPascalAST tmp5_AST_in = _t;
00130 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IMPLEMENTATION);
00131 _t = _t->getNextSibling();
00132 break;
00133 }
00134 default:
00135 {
00136 goto _loop8;
00137 }
00138 }
00139 }
00140 _loop8:;
00141 }
00142 compoundStatement(_t);
00143 _t = _retTree;
00144 }
00145 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00146 reportError(ex);
00147 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00148 _t = _t->getNextSibling();
00149 }
00150 _retTree = _t;
00151 }
00152
00153 void PascalStoreWalker::identifierList(RefPascalAST _t) {
00154 RefPascalAST identifierList_AST_in = _t;
00155
00156 try {
00157 RefPascalAST __t104 = _t;
00158 RefPascalAST tmp6_AST_in = _t;
00159 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDLIST);
00160 _t = _t->getFirstChild();
00161 {
00162 int _cnt106=0;
00163 for (;;) {
00164 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00165 _t = ASTNULL;
00166 if ((_t->getType() == IDENT)) {
00167 RefPascalAST tmp7_AST_in = _t;
00168 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00169 _t = _t->getNextSibling();
00170 }
00171 else {
00172 if ( _cnt106>=1 ) { goto _loop106; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
00173 }
00174
00175 _cnt106++;
00176 }
00177 _loop106:;
00178 }
00179 _t = __t104;
00180 _t = _t->getNextSibling();
00181 }
00182 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00183 reportError(ex);
00184 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00185 _t = _t->getNextSibling();
00186 }
00187 _retTree = _t;
00188 }
00189
00190 void PascalStoreWalker::identifier(RefPascalAST _t) {
00191 RefPascalAST identifier_AST_in = _t;
00192
00193 try {
00194 RefPascalAST tmp8_AST_in = _t;
00195 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00196 _t = _t->getNextSibling();
00197 }
00198 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00199 reportError(ex);
00200 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00201 _t = _t->getNextSibling();
00202 }
00203 _retTree = _t;
00204 }
00205
00206 void PascalStoreWalker::labelDeclarationPart(RefPascalAST _t) {
00207 RefPascalAST labelDeclarationPart_AST_in = _t;
00208
00209 try {
00210 RefPascalAST __t12 = _t;
00211 RefPascalAST tmp9_AST_in = _t;
00212 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LABEL);
00213 _t = _t->getFirstChild();
00214 {
00215 int _cnt14=0;
00216 for (;;) {
00217 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00218 _t = ASTNULL;
00219 if ((_t->getType() == NUM_INT)) {
00220 label(_t);
00221 _t = _retTree;
00222 }
00223 else {
00224 if ( _cnt14>=1 ) { goto _loop14; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
00225 }
00226
00227 _cnt14++;
00228 }
00229 _loop14:;
00230 }
00231 _t = __t12;
00232 _t = _t->getNextSibling();
00233 }
00234 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00235 reportError(ex);
00236 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00237 _t = _t->getNextSibling();
00238 }
00239 _retTree = _t;
00240 }
00241
00242 void PascalStoreWalker::constantDefinitionPart(RefPascalAST _t) {
00243 RefPascalAST constantDefinitionPart_AST_in = _t;
00244
00245 try {
00246 RefPascalAST __t17 = _t;
00247 RefPascalAST tmp10_AST_in = _t;
00248 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CONST);
00249 _t = _t->getFirstChild();
00250 {
00251 int _cnt19=0;
00252 for (;;) {
00253 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00254 _t = ASTNULL;
00255 if ((_t->getType() == EQUAL)) {
00256 constantDefinition(_t);
00257 _t = _retTree;
00258 }
00259 else {
00260 if ( _cnt19>=1 ) { goto _loop19; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
00261 }
00262
00263 _cnt19++;
00264 }
00265 _loop19:;
00266 }
00267 _t = __t17;
00268 _t = _t->getNextSibling();
00269 }
00270 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00271 reportError(ex);
00272 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00273 _t = _t->getNextSibling();
00274 }
00275 _retTree = _t;
00276 }
00277
00278 void PascalStoreWalker::typeDefinitionPart(RefPascalAST _t) {
00279 RefPascalAST typeDefinitionPart_AST_in = _t;
00280
00281 try {
00282 RefPascalAST __t31 = _t;
00283 RefPascalAST tmp11_AST_in = _t;
00284 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),TYPE);
00285 _t = _t->getFirstChild();
00286 {
00287 int _cnt33=0;
00288 for (;;) {
00289 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00290 _t = ASTNULL;
00291 if ((_t->getType() == TYPEDECL)) {
00292 typeDefinition(_t);
00293 _t = _retTree;
00294 }
00295 else {
00296 if ( _cnt33>=1 ) { goto _loop33; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
00297 }
00298
00299 _cnt33++;
00300 }
00301 _loop33:;
00302 }
00303 _t = __t31;
00304 _t = _t->getNextSibling();
00305 }
00306 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00307 reportError(ex);
00308 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00309 _t = _t->getNextSibling();
00310 }
00311 _retTree = _t;
00312 }
00313
00315 void PascalStoreWalker::variableDeclarationPart(RefPascalAST _t) {
00316 RefPascalAST variableDeclarationPart_AST_in = _t;
00317
00318 try {
00319 RefPascalAST __t83 = _t;
00320 RefPascalAST tmp12_AST_in = _t;
00321 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VAR);
00322 _t = _t->getFirstChild();
00323 {
00324 int _cnt85=0;
00325 for (;;) {
00326 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00327 _t = ASTNULL;
00328 if ((_t->getType() == VARDECL)) {
00329 variableDeclaration(_t);
00330 _t = _retTree;
00331 }
00332 else {
00333 if ( _cnt85>=1 ) { goto _loop85; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
00334 }
00335
00336 _cnt85++;
00337 }
00338 _loop85:;
00339 }
00340 _t = __t83;
00341 _t = _t->getNextSibling();
00342 }
00343 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00344 reportError(ex);
00345 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00346 _t = _t->getNextSibling();
00347 }
00348 _retTree = _t;
00349 }
00350
00351 void PascalStoreWalker::procedureAndFunctionDeclarationPart(RefPascalAST _t) {
00352 RefPascalAST procedureAndFunctionDeclarationPart_AST_in = _t;
00353
00354 try {
00355 procedureOrFunctionDeclaration(_t);
00356 _t = _retTree;
00357 }
00358 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00359 reportError(ex);
00360 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00361 _t = _t->getNextSibling();
00362 }
00363 _retTree = _t;
00364 }
00365
00366 void PascalStoreWalker::usesUnitsPart(RefPascalAST _t) {
00367 RefPascalAST usesUnitsPart_AST_in = _t;
00368
00369 try {
00370 RefPascalAST __t10 = _t;
00371 RefPascalAST tmp13_AST_in = _t;
00372 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),USES);
00373 _t = _t->getFirstChild();
00374 identifierList(_t);
00375 _t = _retTree;
00376 _t = __t10;
00377 _t = _t->getNextSibling();
00378 }
00379 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00380 reportError(ex);
00381 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00382 _t = _t->getNextSibling();
00383 }
00384 _retTree = _t;
00385 }
00386
00387 void PascalStoreWalker::compoundStatement(RefPascalAST _t) {
00388 RefPascalAST compoundStatement_AST_in = _t;
00389
00390 try {
00391 statements(_t);
00392 _t = _retTree;
00393 }
00394 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00395 reportError(ex);
00396 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00397 _t = _t->getNextSibling();
00398 }
00399 _retTree = _t;
00400 }
00401
00402 void PascalStoreWalker::label(RefPascalAST _t) {
00403 RefPascalAST label_AST_in = _t;
00404
00405 try {
00406 RefPascalAST tmp14_AST_in = _t;
00407 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
00408 _t = _t->getNextSibling();
00409 }
00410 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00411 reportError(ex);
00412 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00413 _t = _t->getNextSibling();
00414 }
00415 _retTree = _t;
00416 }
00417
00418 void PascalStoreWalker::constantDefinition(RefPascalAST _t) {
00419 RefPascalAST constantDefinition_AST_in = _t;
00420
00421 try {
00422 RefPascalAST __t21 = _t;
00423 RefPascalAST tmp15_AST_in = _t;
00424 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),EQUAL);
00425 _t = _t->getFirstChild();
00426 RefPascalAST tmp16_AST_in = _t;
00427 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00428 _t = _t->getNextSibling();
00429 constant(_t);
00430 _t = _retTree;
00431 _t = __t21;
00432 _t = _t->getNextSibling();
00433 }
00434 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00435 reportError(ex);
00436 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00437 _t = _t->getNextSibling();
00438 }
00439 _retTree = _t;
00440 }
00441
00442 void PascalStoreWalker::constant(RefPascalAST _t) {
00443 RefPascalAST constant_AST_in = _t;
00444
00445 try {
00446 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00447 _t = ASTNULL;
00448 switch ( _t->getType()) {
00449 case NUM_INT:
00450 {
00451 RefPascalAST tmp17_AST_in = _t;
00452 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
00453 _t = _t->getNextSibling();
00454 break;
00455 }
00456 case NUM_REAL:
00457 {
00458 RefPascalAST tmp18_AST_in = _t;
00459 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
00460 _t = _t->getNextSibling();
00461 break;
00462 }
00463 case PLUS:
00464 {
00465 RefPascalAST __t23 = _t;
00466 RefPascalAST tmp19_AST_in = _t;
00467 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PLUS);
00468 _t = _t->getFirstChild();
00469 {
00470 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00471 _t = ASTNULL;
00472 switch ( _t->getType()) {
00473 case NUM_INT:
00474 {
00475 RefPascalAST tmp20_AST_in = _t;
00476 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
00477 _t = _t->getNextSibling();
00478 break;
00479 }
00480 case NUM_REAL:
00481 {
00482 RefPascalAST tmp21_AST_in = _t;
00483 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
00484 _t = _t->getNextSibling();
00485 break;
00486 }
00487 case IDENT:
00488 {
00489 RefPascalAST tmp22_AST_in = _t;
00490 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00491 _t = _t->getNextSibling();
00492 break;
00493 }
00494 default:
00495 {
00496 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00497 }
00498 }
00499 }
00500 _t = __t23;
00501 _t = _t->getNextSibling();
00502 break;
00503 }
00504 case MINUS:
00505 {
00506 RefPascalAST __t25 = _t;
00507 RefPascalAST tmp23_AST_in = _t;
00508 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MINUS);
00509 _t = _t->getFirstChild();
00510 {
00511 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00512 _t = ASTNULL;
00513 switch ( _t->getType()) {
00514 case NUM_INT:
00515 {
00516 RefPascalAST tmp24_AST_in = _t;
00517 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
00518 _t = _t->getNextSibling();
00519 break;
00520 }
00521 case NUM_REAL:
00522 {
00523 RefPascalAST tmp25_AST_in = _t;
00524 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
00525 _t = _t->getNextSibling();
00526 break;
00527 }
00528 case IDENT:
00529 {
00530 RefPascalAST tmp26_AST_in = _t;
00531 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00532 _t = _t->getNextSibling();
00533 break;
00534 }
00535 default:
00536 {
00537 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00538 }
00539 }
00540 }
00541 _t = __t25;
00542 _t = _t->getNextSibling();
00543 break;
00544 }
00545 case IDENT:
00546 {
00547 RefPascalAST tmp27_AST_in = _t;
00548 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00549 _t = _t->getNextSibling();
00550 break;
00551 }
00552 case STRING_LITERAL:
00553 {
00554 RefPascalAST tmp28_AST_in = _t;
00555 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STRING_LITERAL);
00556 _t = _t->getNextSibling();
00557 break;
00558 }
00559 case CHR:
00560 {
00561 RefPascalAST __t27 = _t;
00562 RefPascalAST tmp29_AST_in = _t;
00563 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CHR);
00564 _t = _t->getFirstChild();
00565 {
00566 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00567 _t = ASTNULL;
00568 switch ( _t->getType()) {
00569 case NUM_INT:
00570 {
00571 RefPascalAST tmp30_AST_in = _t;
00572 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
00573 _t = _t->getNextSibling();
00574 break;
00575 }
00576 case NUM_REAL:
00577 {
00578 RefPascalAST tmp31_AST_in = _t;
00579 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
00580 _t = _t->getNextSibling();
00581 break;
00582 }
00583 default:
00584 {
00585 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00586 }
00587 }
00588 }
00589 _t = __t27;
00590 _t = _t->getNextSibling();
00591 break;
00592 }
00593 default:
00594 {
00595 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00596 }
00597 }
00598 }
00599 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00600 reportError(ex);
00601 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00602 _t = _t->getNextSibling();
00603 }
00604 _retTree = _t;
00605 }
00606
00607 void PascalStoreWalker::string(RefPascalAST _t) {
00608 RefPascalAST string_AST_in = _t;
00609
00610 try {
00611 RefPascalAST tmp32_AST_in = _t;
00612 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STRING_LITERAL);
00613 _t = _t->getNextSibling();
00614 }
00615 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00616 reportError(ex);
00617 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00618 _t = _t->getNextSibling();
00619 }
00620 _retTree = _t;
00621 }
00622
00623 void PascalStoreWalker::typeDefinition(RefPascalAST _t) {
00624 RefPascalAST typeDefinition_AST_in = _t;
00625
00626 try {
00627 RefPascalAST __t35 = _t;
00628 RefPascalAST tmp33_AST_in = _t;
00629 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),TYPEDECL);
00630 _t = _t->getFirstChild();
00631 RefPascalAST tmp34_AST_in = _t;
00632 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00633 _t = _t->getNextSibling();
00634 {
00635 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00636 _t = ASTNULL;
00637 switch ( _t->getType()) {
00638 case SCALARTYPE:
00639 case ARRAY:
00640 case INTEGER:
00641 case BOOLEAN:
00642 case CHAR:
00643 case DOTDOT:
00644 case REAL:
00645 case STRING:
00646 case PACKED:
00647 case RECORD:
00648 case SET:
00649 case FILE:
00650 case POINTER:
00651 case IDENT:
00652 {
00653 type(_t);
00654 _t = _retTree;
00655 break;
00656 }
00657 case FUNCTION:
00658 {
00659 RefPascalAST __t37 = _t;
00660 RefPascalAST tmp35_AST_in = _t;
00661 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FUNCTION);
00662 _t = _t->getFirstChild();
00663 {
00664 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00665 _t = ASTNULL;
00666 switch ( _t->getType()) {
00667 case ARGDECLS:
00668 {
00669 formalParameterList(_t);
00670 _t = _retTree;
00671 break;
00672 }
00673 case INTEGER:
00674 case BOOLEAN:
00675 case CHAR:
00676 case REAL:
00677 case STRING:
00678 case IDENT:
00679 {
00680 break;
00681 }
00682 default:
00683 {
00684 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00685 }
00686 }
00687 }
00688 resultType(_t);
00689 _t = _retTree;
00690 _t = __t37;
00691 _t = _t->getNextSibling();
00692 break;
00693 }
00694 case PROCEDURE:
00695 {
00696 RefPascalAST __t39 = _t;
00697 RefPascalAST tmp36_AST_in = _t;
00698 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PROCEDURE);
00699 _t = _t->getFirstChild();
00700 {
00701 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00702 _t = ASTNULL;
00703 switch ( _t->getType()) {
00704 case ARGDECLS:
00705 {
00706 formalParameterList(_t);
00707 _t = _retTree;
00708 break;
00709 }
00710 case 3:
00711 {
00712 break;
00713 }
00714 default:
00715 {
00716 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00717 }
00718 }
00719 }
00720 _t = __t39;
00721 _t = _t->getNextSibling();
00722 break;
00723 }
00724 default:
00725 {
00726 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00727 }
00728 }
00729 }
00730 _t = __t35;
00731 _t = _t->getNextSibling();
00732 }
00733 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00734 reportError(ex);
00735 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00736 _t = _t->getNextSibling();
00737 }
00738 _retTree = _t;
00739 }
00740
00741 void PascalStoreWalker::type(RefPascalAST _t) {
00742 RefPascalAST type_AST_in = _t;
00743
00744 try {
00745 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00746 _t = ASTNULL;
00747 switch ( _t->getType()) {
00748 case SCALARTYPE:
00749 {
00750 RefPascalAST __t42 = _t;
00751 RefPascalAST tmp37_AST_in = _t;
00752 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SCALARTYPE);
00753 _t = _t->getFirstChild();
00754 identifierList(_t);
00755 _t = _retTree;
00756 _t = __t42;
00757 _t = _t->getNextSibling();
00758 break;
00759 }
00760 case DOTDOT:
00761 {
00762 RefPascalAST __t43 = _t;
00763 RefPascalAST tmp38_AST_in = _t;
00764 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOTDOT);
00765 _t = _t->getFirstChild();
00766 constant(_t);
00767 _t = _retTree;
00768 constant(_t);
00769 _t = _retTree;
00770 _t = __t43;
00771 _t = _t->getNextSibling();
00772 break;
00773 }
00774 case INTEGER:
00775 case BOOLEAN:
00776 case CHAR:
00777 case REAL:
00778 case STRING:
00779 case IDENT:
00780 {
00781 typeIdentifier(_t);
00782 _t = _retTree;
00783 break;
00784 }
00785 case ARRAY:
00786 case PACKED:
00787 case RECORD:
00788 case SET:
00789 case FILE:
00790 {
00791 structuredType(_t);
00792 _t = _retTree;
00793 break;
00794 }
00795 case POINTER:
00796 {
00797 RefPascalAST __t44 = _t;
00798 RefPascalAST tmp39_AST_in = _t;
00799 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),POINTER);
00800 _t = _t->getFirstChild();
00801 typeIdentifier(_t);
00802 _t = _retTree;
00803 _t = __t44;
00804 _t = _t->getNextSibling();
00805 break;
00806 }
00807 default:
00808 {
00809 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00810 }
00811 }
00812 }
00813 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00814 reportError(ex);
00815 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00816 _t = _t->getNextSibling();
00817 }
00818 _retTree = _t;
00819 }
00820
00821 void PascalStoreWalker::formalParameterList(RefPascalAST _t) {
00822 RefPascalAST formalParameterList_AST_in = _t;
00823
00824 try {
00825 RefPascalAST __t94 = _t;
00826 RefPascalAST tmp40_AST_in = _t;
00827 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARGDECLS);
00828 _t = _t->getFirstChild();
00829 {
00830 int _cnt96=0;
00831 for (;;) {
00832 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00833 _t = ASTNULL;
00834 if ((_tokenSet_0.member(_t->getType()))) {
00835 formalParameterSection(_t);
00836 _t = _retTree;
00837 }
00838 else {
00839 if ( _cnt96>=1 ) { goto _loop96; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
00840 }
00841
00842 _cnt96++;
00843 }
00844 _loop96:;
00845 }
00846 _t = __t94;
00847 _t = _t->getNextSibling();
00848 }
00849 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00850 reportError(ex);
00851 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00852 _t = _t->getNextSibling();
00853 }
00854 _retTree = _t;
00855 }
00856
00857 void PascalStoreWalker::resultType(RefPascalAST _t) {
00858 RefPascalAST resultType_AST_in = _t;
00859
00860 try {
00861 typeIdentifier(_t);
00862 _t = _retTree;
00863 }
00864 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00865 reportError(ex);
00866 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00867 _t = _t->getNextSibling();
00868 }
00869 _retTree = _t;
00870 }
00871
00872 void PascalStoreWalker::typeIdentifier(RefPascalAST _t) {
00873 RefPascalAST typeIdentifier_AST_in = _t;
00874
00875 try {
00876 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00877 _t = ASTNULL;
00878 switch ( _t->getType()) {
00879 case IDENT:
00880 {
00881 RefPascalAST tmp41_AST_in = _t;
00882 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00883 _t = _t->getNextSibling();
00884 break;
00885 }
00886 case CHAR:
00887 {
00888 RefPascalAST tmp42_AST_in = _t;
00889 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CHAR);
00890 _t = _t->getNextSibling();
00891 break;
00892 }
00893 case BOOLEAN:
00894 {
00895 RefPascalAST tmp43_AST_in = _t;
00896 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BOOLEAN);
00897 _t = _t->getNextSibling();
00898 break;
00899 }
00900 case INTEGER:
00901 {
00902 RefPascalAST tmp44_AST_in = _t;
00903 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),INTEGER);
00904 _t = _t->getNextSibling();
00905 break;
00906 }
00907 case REAL:
00908 {
00909 RefPascalAST tmp45_AST_in = _t;
00910 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),REAL);
00911 _t = _t->getNextSibling();
00912 break;
00913 }
00914 case STRING:
00915 {
00916 RefPascalAST __t46 = _t;
00917 RefPascalAST tmp46_AST_in = _t;
00918 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STRING);
00919 _t = _t->getFirstChild();
00920 {
00921 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00922 _t = ASTNULL;
00923 switch ( _t->getType()) {
00924 case IDENT:
00925 {
00926 RefPascalAST tmp47_AST_in = _t;
00927 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
00928 _t = _t->getNextSibling();
00929 break;
00930 }
00931 case NUM_INT:
00932 {
00933 RefPascalAST tmp48_AST_in = _t;
00934 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
00935 _t = _t->getNextSibling();
00936 break;
00937 }
00938 case NUM_REAL:
00939 {
00940 RefPascalAST tmp49_AST_in = _t;
00941 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
00942 _t = _t->getNextSibling();
00943 break;
00944 }
00945 case 3:
00946 {
00947 break;
00948 }
00949 default:
00950 {
00951 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00952 }
00953 }
00954 }
00955 _t = __t46;
00956 _t = _t->getNextSibling();
00957 break;
00958 }
00959 default:
00960 {
00961 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
00962 }
00963 }
00964 }
00965 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
00966 reportError(ex);
00967 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00968 _t = _t->getNextSibling();
00969 }
00970 _retTree = _t;
00971 }
00972
00973 void PascalStoreWalker::structuredType(RefPascalAST _t) {
00974 RefPascalAST structuredType_AST_in = _t;
00975
00976 try {
00977 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
00978 _t = ASTNULL;
00979 switch ( _t->getType()) {
00980 case PACKED:
00981 {
00982 RefPascalAST __t49 = _t;
00983 RefPascalAST tmp50_AST_in = _t;
00984 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PACKED);
00985 _t = _t->getFirstChild();
00986 unpackedStructuredType(_t);
00987 _t = _retTree;
00988 _t = __t49;
00989 _t = _t->getNextSibling();
00990 break;
00991 }
00992 case ARRAY:
00993 case RECORD:
00994 case SET:
00995 case FILE:
00996 {
00997 unpackedStructuredType(_t);
00998 _t = _retTree;
00999 break;
01000 }
01001 default:
01002 {
01003 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01004 }
01005 }
01006 }
01007 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01008 reportError(ex);
01009 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01010 _t = _t->getNextSibling();
01011 }
01012 _retTree = _t;
01013 }
01014
01015 void PascalStoreWalker::unpackedStructuredType(RefPascalAST _t) {
01016 RefPascalAST unpackedStructuredType_AST_in = _t;
01017
01018 try {
01019 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01020 _t = ASTNULL;
01021 switch ( _t->getType()) {
01022 case ARRAY:
01023 {
01024 arrayType(_t);
01025 _t = _retTree;
01026 break;
01027 }
01028 case RECORD:
01029 {
01030 recordType(_t);
01031 _t = _retTree;
01032 break;
01033 }
01034 case SET:
01035 {
01036 setType(_t);
01037 _t = _retTree;
01038 break;
01039 }
01040 case FILE:
01041 {
01042 fileType(_t);
01043 _t = _retTree;
01044 break;
01045 }
01046 default:
01047 {
01048 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01049 }
01050 }
01051 }
01052 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01053 reportError(ex);
01054 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01055 _t = _t->getNextSibling();
01056 }
01057 _retTree = _t;
01058 }
01059
01064 void PascalStoreWalker::arrayType(RefPascalAST _t) {
01065 RefPascalAST arrayType_AST_in = _t;
01066
01067 try {
01068 RefPascalAST __t52 = _t;
01069 RefPascalAST tmp51_AST_in = _t;
01070 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARRAY);
01071 _t = _t->getFirstChild();
01072 typeList(_t);
01073 _t = _retTree;
01074 type(_t);
01075 _t = _retTree;
01076 _t = __t52;
01077 _t = _t->getNextSibling();
01078 }
01079 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01080 reportError(ex);
01081 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01082 _t = _t->getNextSibling();
01083 }
01084 _retTree = _t;
01085 }
01086
01087 void PascalStoreWalker::recordType(RefPascalAST _t) {
01088 RefPascalAST recordType_AST_in = _t;
01089
01090 try {
01091 RefPascalAST __t58 = _t;
01092 RefPascalAST tmp52_AST_in = _t;
01093 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),RECORD);
01094 _t = _t->getFirstChild();
01095 fieldList(_t);
01096 _t = _retTree;
01097 _t = __t58;
01098 _t = _t->getNextSibling();
01099 }
01100 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01101 reportError(ex);
01102 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01103 _t = _t->getNextSibling();
01104 }
01105 _retTree = _t;
01106 }
01107
01108 void PascalStoreWalker::setType(RefPascalAST _t) {
01109 RefPascalAST setType_AST_in = _t;
01110
01111 try {
01112 RefPascalAST __t78 = _t;
01113 RefPascalAST tmp53_AST_in = _t;
01114 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SET);
01115 _t = _t->getFirstChild();
01116 type(_t);
01117 _t = _retTree;
01118 _t = __t78;
01119 _t = _t->getNextSibling();
01120 }
01121 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01122 reportError(ex);
01123 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01124 _t = _t->getNextSibling();
01125 }
01126 _retTree = _t;
01127 }
01128
01129 void PascalStoreWalker::fileType(RefPascalAST _t) {
01130 RefPascalAST fileType_AST_in = _t;
01131
01132 try {
01133 RefPascalAST __t80 = _t;
01134 RefPascalAST tmp54_AST_in = _t;
01135 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FILE);
01136 _t = _t->getFirstChild();
01137 {
01138 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01139 _t = ASTNULL;
01140 switch ( _t->getType()) {
01141 case SCALARTYPE:
01142 case ARRAY:
01143 case INTEGER:
01144 case BOOLEAN:
01145 case CHAR:
01146 case DOTDOT:
01147 case REAL:
01148 case STRING:
01149 case PACKED:
01150 case RECORD:
01151 case SET:
01152 case FILE:
01153 case POINTER:
01154 case IDENT:
01155 {
01156 type(_t);
01157 _t = _retTree;
01158 break;
01159 }
01160 case 3:
01161 {
01162 break;
01163 }
01164 default:
01165 {
01166 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01167 }
01168 }
01169 }
01170 _t = __t80;
01171 _t = _t->getNextSibling();
01172 }
01173 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01174 reportError(ex);
01175 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01176 _t = _t->getNextSibling();
01177 }
01178 _retTree = _t;
01179 }
01180
01181 void PascalStoreWalker::typeList(RefPascalAST _t) {
01182 RefPascalAST typeList_AST_in = _t;
01183
01184 try {
01185 RefPascalAST __t54 = _t;
01186 RefPascalAST tmp55_AST_in = _t;
01187 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),TYPELIST);
01188 _t = _t->getFirstChild();
01189 {
01190 int _cnt56=0;
01191 for (;;) {
01192 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01193 _t = ASTNULL;
01194 if ((_tokenSet_1.member(_t->getType()))) {
01195 type(_t);
01196 _t = _retTree;
01197 }
01198 else {
01199 if ( _cnt56>=1 ) { goto _loop56; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
01200 }
01201
01202 _cnt56++;
01203 }
01204 _loop56:;
01205 }
01206 _t = __t54;
01207 _t = _t->getNextSibling();
01208 }
01209 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01210 reportError(ex);
01211 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01212 _t = _t->getNextSibling();
01213 }
01214 _retTree = _t;
01215 }
01216
01217 void PascalStoreWalker::fieldList(RefPascalAST _t) {
01218 RefPascalAST fieldList_AST_in = _t;
01219
01220 try {
01221 RefPascalAST __t60 = _t;
01222 RefPascalAST tmp56_AST_in = _t;
01223 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FIELDLIST);
01224 _t = _t->getFirstChild();
01225 {
01226 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01227 _t = ASTNULL;
01228 switch ( _t->getType()) {
01229 case FIELD:
01230 {
01231 fixedPart(_t);
01232 _t = _retTree;
01233 {
01234 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01235 _t = ASTNULL;
01236 switch ( _t->getType()) {
01237 case CASE:
01238 {
01239 variantPart(_t);
01240 _t = _retTree;
01241 break;
01242 }
01243 case 3:
01244 {
01245 break;
01246 }
01247 default:
01248 {
01249 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01250 }
01251 }
01252 }
01253 break;
01254 }
01255 case CASE:
01256 {
01257 variantPart(_t);
01258 _t = _retTree;
01259 break;
01260 }
01261 default:
01262 {
01263 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01264 }
01265 }
01266 }
01267 _t = __t60;
01268 _t = _t->getNextSibling();
01269 }
01270 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01271 reportError(ex);
01272 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01273 _t = _t->getNextSibling();
01274 }
01275 _retTree = _t;
01276 }
01277
01278 void PascalStoreWalker::fixedPart(RefPascalAST _t) {
01279 RefPascalAST fixedPart_AST_in = _t;
01280
01281 try {
01282 {
01283 int _cnt65=0;
01284 for (;;) {
01285 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01286 _t = ASTNULL;
01287 if ((_t->getType() == FIELD)) {
01288 recordSection(_t);
01289 _t = _retTree;
01290 }
01291 else {
01292 if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
01293 }
01294
01295 _cnt65++;
01296 }
01297 _loop65:;
01298 }
01299 }
01300 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01301 reportError(ex);
01302 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01303 _t = _t->getNextSibling();
01304 }
01305 _retTree = _t;
01306 }
01307
01308 void PascalStoreWalker::variantPart(RefPascalAST _t) {
01309 RefPascalAST variantPart_AST_in = _t;
01310
01311 try {
01312 RefPascalAST __t69 = _t;
01313 RefPascalAST tmp57_AST_in = _t;
01314 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CASE);
01315 _t = _t->getFirstChild();
01316 tag(_t);
01317 _t = _retTree;
01318 {
01319 int _cnt71=0;
01320 for (;;) {
01321 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01322 _t = ASTNULL;
01323 if ((_t->getType() == VARIANT_CASE)) {
01324 variant(_t);
01325 _t = _retTree;
01326 }
01327 else {
01328 if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
01329 }
01330
01331 _cnt71++;
01332 }
01333 _loop71:;
01334 }
01335 _t = __t69;
01336 _t = _t->getNextSibling();
01337 }
01338 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01339 reportError(ex);
01340 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01341 _t = _t->getNextSibling();
01342 }
01343 _retTree = _t;
01344 }
01345
01346 void PascalStoreWalker::recordSection(RefPascalAST _t) {
01347 RefPascalAST recordSection_AST_in = _t;
01348
01349 try {
01350 RefPascalAST __t67 = _t;
01351 RefPascalAST tmp58_AST_in = _t;
01352 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FIELD);
01353 _t = _t->getFirstChild();
01354 identifierList(_t);
01355 _t = _retTree;
01356 type(_t);
01357 _t = _retTree;
01358 _t = __t67;
01359 _t = _t->getNextSibling();
01360 }
01361 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01362 reportError(ex);
01363 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01364 _t = _t->getNextSibling();
01365 }
01366 _retTree = _t;
01367 }
01368
01369 void PascalStoreWalker::tag(RefPascalAST _t) {
01370 RefPascalAST tag_AST_in = _t;
01371
01372 try {
01373 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01374 _t = ASTNULL;
01375 switch ( _t->getType()) {
01376 case VARIANT_TAG:
01377 {
01378 RefPascalAST __t73 = _t;
01379 RefPascalAST tmp59_AST_in = _t;
01380 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VARIANT_TAG);
01381 _t = _t->getFirstChild();
01382 identifier(_t);
01383 _t = _retTree;
01384 typeIdentifier(_t);
01385 _t = _retTree;
01386 _t = __t73;
01387 _t = _t->getNextSibling();
01388 break;
01389 }
01390 case VARIANT_TAG_NO_ID:
01391 {
01392 RefPascalAST __t74 = _t;
01393 RefPascalAST tmp60_AST_in = _t;
01394 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VARIANT_TAG_NO_ID);
01395 _t = _t->getFirstChild();
01396 typeIdentifier(_t);
01397 _t = _retTree;
01398 _t = __t74;
01399 _t = _t->getNextSibling();
01400 break;
01401 }
01402 default:
01403 {
01404 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01405 }
01406 }
01407 }
01408 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01409 reportError(ex);
01410 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01411 _t = _t->getNextSibling();
01412 }
01413 _retTree = _t;
01414 }
01415
01416 void PascalStoreWalker::variant(RefPascalAST _t) {
01417 RefPascalAST variant_AST_in = _t;
01418
01419 try {
01420 RefPascalAST __t76 = _t;
01421 RefPascalAST tmp61_AST_in = _t;
01422 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VARIANT_CASE);
01423 _t = _t->getFirstChild();
01424 constList(_t);
01425 _t = _retTree;
01426 fieldList(_t);
01427 _t = _retTree;
01428 _t = __t76;
01429 _t = _t->getNextSibling();
01430 }
01431 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01432 reportError(ex);
01433 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01434 _t = _t->getNextSibling();
01435 }
01436 _retTree = _t;
01437 }
01438
01439 void PascalStoreWalker::constList(RefPascalAST _t) {
01440 RefPascalAST constList_AST_in = _t;
01441
01442 try {
01443 RefPascalAST __t108 = _t;
01444 RefPascalAST tmp62_AST_in = _t;
01445 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CONSTLIST);
01446 _t = _t->getFirstChild();
01447 {
01448 int _cnt110=0;
01449 for (;;) {
01450 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01451 _t = ASTNULL;
01452 if ((_tokenSet_2.member(_t->getType()))) {
01453 constant(_t);
01454 _t = _retTree;
01455 }
01456 else {
01457 if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
01458 }
01459
01460 _cnt110++;
01461 }
01462 _loop110:;
01463 }
01464 _t = __t108;
01465 _t = _t->getNextSibling();
01466 }
01467 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01468 reportError(ex);
01469 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01470 _t = _t->getNextSibling();
01471 }
01472 _retTree = _t;
01473 }
01474
01475 void PascalStoreWalker::variableDeclaration(RefPascalAST _t) {
01476 RefPascalAST variableDeclaration_AST_in = _t;
01477
01478 try {
01479 RefPascalAST __t87 = _t;
01480 RefPascalAST tmp63_AST_in = _t;
01481 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VARDECL);
01482 _t = _t->getFirstChild();
01483 identifierList(_t);
01484 _t = _retTree;
01485 type(_t);
01486 _t = _retTree;
01487 _t = __t87;
01488 _t = _t->getNextSibling();
01489 }
01490 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01491 reportError(ex);
01492 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01493 _t = _t->getNextSibling();
01494 }
01495 _retTree = _t;
01496 }
01497
01498 void PascalStoreWalker::procedureOrFunctionDeclaration(RefPascalAST _t) {
01499 RefPascalAST procedureOrFunctionDeclaration_AST_in = _t;
01500
01501 try {
01502 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01503 _t = ASTNULL;
01504 switch ( _t->getType()) {
01505 case PROCEDURE:
01506 {
01507 procedureDeclaration(_t);
01508 _t = _retTree;
01509 break;
01510 }
01511 case FUNCTION:
01512 {
01513 functionDeclaration(_t);
01514 _t = _retTree;
01515 break;
01516 }
01517 default:
01518 {
01519 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01520 }
01521 }
01522 }
01523 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01524 reportError(ex);
01525 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01526 _t = _t->getNextSibling();
01527 }
01528 _retTree = _t;
01529 }
01530
01531 void PascalStoreWalker::procedureDeclaration(RefPascalAST _t) {
01532 RefPascalAST procedureDeclaration_AST_in = _t;
01533
01534 try {
01535 RefPascalAST __t91 = _t;
01536 RefPascalAST tmp64_AST_in = _t;
01537 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PROCEDURE);
01538 _t = _t->getFirstChild();
01539 RefPascalAST tmp65_AST_in = _t;
01540 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01541 _t = _t->getNextSibling();
01542 {
01543 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01544 _t = ASTNULL;
01545 switch ( _t->getType()) {
01546 case ARGDECLS:
01547 {
01548 formalParameterList(_t);
01549 _t = _retTree;
01550 break;
01551 }
01552 case BLOCK:
01553 case USES:
01554 case IMPLEMENTATION:
01555 case LABEL:
01556 case CONST:
01557 case TYPE:
01558 case VAR:
01559 case PROCEDURE:
01560 case FUNCTION:
01561 {
01562 break;
01563 }
01564 default:
01565 {
01566 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01567 }
01568 }
01569 }
01570 block(_t);
01571 _t = _retTree;
01572 _t = __t91;
01573 _t = _t->getNextSibling();
01574 }
01575 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01576 reportError(ex);
01577 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01578 _t = _t->getNextSibling();
01579 }
01580 _retTree = _t;
01581 }
01582
01583 void PascalStoreWalker::functionDeclaration(RefPascalAST _t) {
01584 RefPascalAST functionDeclaration_AST_in = _t;
01585
01586 try {
01587 RefPascalAST __t112 = _t;
01588 RefPascalAST tmp66_AST_in = _t;
01589 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FUNCTION);
01590 _t = _t->getFirstChild();
01591 RefPascalAST tmp67_AST_in = _t;
01592 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01593 _t = _t->getNextSibling();
01594 {
01595 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01596 _t = ASTNULL;
01597 switch ( _t->getType()) {
01598 case ARGDECLS:
01599 {
01600 formalParameterList(_t);
01601 _t = _retTree;
01602 break;
01603 }
01604 case INTEGER:
01605 case BOOLEAN:
01606 case CHAR:
01607 case REAL:
01608 case STRING:
01609 case IDENT:
01610 {
01611 break;
01612 }
01613 default:
01614 {
01615 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01616 }
01617 }
01618 }
01619 resultType(_t);
01620 _t = _retTree;
01621 block(_t);
01622 _t = _retTree;
01623 _t = __t112;
01624 _t = _t->getNextSibling();
01625 }
01626 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01627 reportError(ex);
01628 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01629 _t = _t->getNextSibling();
01630 }
01631 _retTree = _t;
01632 }
01633
01634 void PascalStoreWalker::formalParameterSection(RefPascalAST _t) {
01635 RefPascalAST formalParameterSection_AST_in = _t;
01636
01637 try {
01638 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01639 _t = ASTNULL;
01640 switch ( _t->getType()) {
01641 case ARGDECL:
01642 {
01643 parameterGroup(_t);
01644 _t = _retTree;
01645 break;
01646 }
01647 case VAR:
01648 {
01649 RefPascalAST __t98 = _t;
01650 RefPascalAST tmp68_AST_in = _t;
01651 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),VAR);
01652 _t = _t->getFirstChild();
01653 parameterGroup(_t);
01654 _t = _retTree;
01655 _t = __t98;
01656 _t = _t->getNextSibling();
01657 break;
01658 }
01659 case FUNCTION:
01660 {
01661 RefPascalAST __t99 = _t;
01662 RefPascalAST tmp69_AST_in = _t;
01663 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FUNCTION);
01664 _t = _t->getFirstChild();
01665 parameterGroup(_t);
01666 _t = _retTree;
01667 _t = __t99;
01668 _t = _t->getNextSibling();
01669 break;
01670 }
01671 case PROCEDURE:
01672 {
01673 RefPascalAST __t100 = _t;
01674 RefPascalAST tmp70_AST_in = _t;
01675 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PROCEDURE);
01676 _t = _t->getFirstChild();
01677 parameterGroup(_t);
01678 _t = _retTree;
01679 _t = __t100;
01680 _t = _t->getNextSibling();
01681 break;
01682 }
01683 default:
01684 {
01685 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01686 }
01687 }
01688 }
01689 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01690 reportError(ex);
01691 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01692 _t = _t->getNextSibling();
01693 }
01694 _retTree = _t;
01695 }
01696
01697 void PascalStoreWalker::parameterGroup(RefPascalAST _t) {
01698 RefPascalAST parameterGroup_AST_in = _t;
01699
01700 try {
01701 RefPascalAST __t102 = _t;
01702 RefPascalAST tmp71_AST_in = _t;
01703 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARGDECL);
01704 _t = _t->getFirstChild();
01705 identifierList(_t);
01706 _t = _retTree;
01707 typeIdentifier(_t);
01708 _t = _retTree;
01709 _t = __t102;
01710 _t = _t->getNextSibling();
01711 }
01712 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01713 reportError(ex);
01714 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01715 _t = _t->getNextSibling();
01716 }
01717 _retTree = _t;
01718 }
01719
01720 void PascalStoreWalker::statement(RefPascalAST _t) {
01721 RefPascalAST statement_AST_in = _t;
01722
01723 try {
01724 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01725 _t = ASTNULL;
01726 switch ( _t->getType()) {
01727 case COLON:
01728 {
01729 RefPascalAST __t116 = _t;
01730 RefPascalAST tmp72_AST_in = _t;
01731 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),COLON);
01732 _t = _t->getFirstChild();
01733 label(_t);
01734 _t = _retTree;
01735 unlabelledStatement(_t);
01736 _t = _retTree;
01737 _t = __t116;
01738 _t = _t->getNextSibling();
01739 break;
01740 }
01741 case BLOCK:
01742 case PROC_CALL:
01743 case ASSIGN:
01744 case CASE:
01745 case GOTO:
01746 case IF:
01747 case WHILE:
01748 case REPEAT:
01749 case FOR:
01750 case WITH:
01751 {
01752 unlabelledStatement(_t);
01753 _t = _retTree;
01754 break;
01755 }
01756 default:
01757 {
01758 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01759 }
01760 }
01761 }
01762 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01763 reportError(ex);
01764 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01765 _t = _t->getNextSibling();
01766 }
01767 _retTree = _t;
01768 }
01769
01770 void PascalStoreWalker::unlabelledStatement(RefPascalAST _t) {
01771 RefPascalAST unlabelledStatement_AST_in = _t;
01772
01773 try {
01774 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01775 _t = ASTNULL;
01776 switch ( _t->getType()) {
01777 case PROC_CALL:
01778 case ASSIGN:
01779 case GOTO:
01780 {
01781 simpleStatement(_t);
01782 _t = _retTree;
01783 break;
01784 }
01785 case BLOCK:
01786 case CASE:
01787 case IF:
01788 case WHILE:
01789 case REPEAT:
01790 case FOR:
01791 case WITH:
01792 {
01793 structuredStatement(_t);
01794 _t = _retTree;
01795 break;
01796 }
01797 default:
01798 {
01799 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01800 }
01801 }
01802 }
01803 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01804 reportError(ex);
01805 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01806 _t = _t->getNextSibling();
01807 }
01808 _retTree = _t;
01809 }
01810
01811 void PascalStoreWalker::simpleStatement(RefPascalAST _t) {
01812 RefPascalAST simpleStatement_AST_in = _t;
01813
01814 try {
01815 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01816 _t = ASTNULL;
01817 switch ( _t->getType()) {
01818 case ASSIGN:
01819 {
01820 assignmentStatement(_t);
01821 _t = _retTree;
01822 break;
01823 }
01824 case PROC_CALL:
01825 {
01826 procedureStatement(_t);
01827 _t = _retTree;
01828 break;
01829 }
01830 case GOTO:
01831 {
01832 gotoStatement(_t);
01833 _t = _retTree;
01834 break;
01835 }
01836 default:
01837 {
01838 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01839 }
01840 }
01841 }
01842 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01843 reportError(ex);
01844 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01845 _t = _t->getNextSibling();
01846 }
01847 _retTree = _t;
01848 }
01849
01850 void PascalStoreWalker::structuredStatement(RefPascalAST _t) {
01851 RefPascalAST structuredStatement_AST_in = _t;
01852
01853 try {
01854 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01855 _t = ASTNULL;
01856 switch ( _t->getType()) {
01857 case BLOCK:
01858 {
01859 compoundStatement(_t);
01860 _t = _retTree;
01861 break;
01862 }
01863 case CASE:
01864 case IF:
01865 {
01866 conditionalStatement(_t);
01867 _t = _retTree;
01868 break;
01869 }
01870 case WHILE:
01871 case REPEAT:
01872 case FOR:
01873 {
01874 repetetiveStatement(_t);
01875 _t = _retTree;
01876 break;
01877 }
01878 case WITH:
01879 {
01880 withStatement(_t);
01881 _t = _retTree;
01882 break;
01883 }
01884 default:
01885 {
01886 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01887 }
01888 }
01889 }
01890 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01891 reportError(ex);
01892 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01893 _t = _t->getNextSibling();
01894 }
01895 _retTree = _t;
01896 }
01897
01898 void PascalStoreWalker::assignmentStatement(RefPascalAST _t) {
01899 RefPascalAST assignmentStatement_AST_in = _t;
01900
01901 try {
01902 RefPascalAST __t120 = _t;
01903 RefPascalAST tmp73_AST_in = _t;
01904 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ASSIGN);
01905 _t = _t->getFirstChild();
01906 variable(_t);
01907 _t = _retTree;
01908 expression(_t);
01909 _t = _retTree;
01910 _t = __t120;
01911 _t = _t->getNextSibling();
01912 }
01913 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01914 reportError(ex);
01915 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01916 _t = _t->getNextSibling();
01917 }
01918 _retTree = _t;
01919 }
01920
01921 void PascalStoreWalker::procedureStatement(RefPascalAST _t) {
01922 RefPascalAST procedureStatement_AST_in = _t;
01923
01924 try {
01925 RefPascalAST __t166 = _t;
01926 RefPascalAST tmp74_AST_in = _t;
01927 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PROC_CALL);
01928 _t = _t->getFirstChild();
01929 RefPascalAST tmp75_AST_in = _t;
01930 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
01931 _t = _t->getNextSibling();
01932 {
01933 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01934 _t = ASTNULL;
01935 switch ( _t->getType()) {
01936 case ARGLIST:
01937 {
01938 parameterList(_t);
01939 _t = _retTree;
01940 break;
01941 }
01942 case 3:
01943 {
01944 break;
01945 }
01946 default:
01947 {
01948 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
01949 }
01950 }
01951 }
01952 _t = __t166;
01953 _t = _t->getNextSibling();
01954 }
01955 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01956 reportError(ex);
01957 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01958 _t = _t->getNextSibling();
01959 }
01960 _retTree = _t;
01961 }
01962
01963 void PascalStoreWalker::gotoStatement(RefPascalAST _t) {
01964 RefPascalAST gotoStatement_AST_in = _t;
01965
01966 try {
01967 RefPascalAST __t170 = _t;
01968 RefPascalAST tmp76_AST_in = _t;
01969 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),GOTO);
01970 _t = _t->getFirstChild();
01971 label(_t);
01972 _t = _retTree;
01973 _t = __t170;
01974 _t = _t->getNextSibling();
01975 }
01976 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
01977 reportError(ex);
01978 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
01979 _t = _t->getNextSibling();
01980 }
01981 _retTree = _t;
01982 }
01983
01999 void PascalStoreWalker::variable(RefPascalAST _t) {
02000 RefPascalAST variable_AST_in = _t;
02001
02002 try {
02003 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02004 _t = ASTNULL;
02005 switch ( _t->getType()) {
02006 case LBRACK:
02007 {
02008 RefPascalAST __t122 = _t;
02009 RefPascalAST tmp77_AST_in = _t;
02010 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LBRACK);
02011 _t = _t->getFirstChild();
02012 variable(_t);
02013 _t = _retTree;
02014 {
02015 int _cnt124=0;
02016 for (;;) {
02017 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02018 _t = ASTNULL;
02019 if ((_tokenSet_3.member(_t->getType()))) {
02020 expression(_t);
02021 _t = _retTree;
02022 }
02023 else {
02024 if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
02025 }
02026
02027 _cnt124++;
02028 }
02029 _loop124:;
02030 }
02031 _t = __t122;
02032 _t = _t->getNextSibling();
02033 break;
02034 }
02035 case LBRACK2:
02036 {
02037 RefPascalAST __t125 = _t;
02038 RefPascalAST tmp78_AST_in = _t;
02039 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LBRACK2);
02040 _t = _t->getFirstChild();
02041 variable(_t);
02042 _t = _retTree;
02043 {
02044 int _cnt127=0;
02045 for (;;) {
02046 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02047 _t = ASTNULL;
02048 if ((_tokenSet_3.member(_t->getType()))) {
02049 expression(_t);
02050 _t = _retTree;
02051 }
02052 else {
02053 if ( _cnt127>=1 ) { goto _loop127; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
02054 }
02055
02056 _cnt127++;
02057 }
02058 _loop127:;
02059 }
02060 _t = __t125;
02061 _t = _t->getNextSibling();
02062 break;
02063 }
02064 case DOT:
02065 {
02066 RefPascalAST __t128 = _t;
02067 RefPascalAST tmp79_AST_in = _t;
02068 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOT);
02069 _t = _t->getFirstChild();
02070 variable(_t);
02071 _t = _retTree;
02072 RefPascalAST tmp80_AST_in = _t;
02073 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02074 _t = _t->getNextSibling();
02075 _t = __t128;
02076 _t = _t->getNextSibling();
02077 break;
02078 }
02079 case POINTER:
02080 {
02081 RefPascalAST __t129 = _t;
02082 RefPascalAST tmp81_AST_in = _t;
02083 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),POINTER);
02084 _t = _t->getFirstChild();
02085 variable(_t);
02086 _t = _retTree;
02087 _t = __t129;
02088 _t = _t->getNextSibling();
02089 break;
02090 }
02091 case AT:
02092 {
02093 RefPascalAST __t130 = _t;
02094 RefPascalAST tmp82_AST_in = _t;
02095 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),AT);
02096 _t = _t->getFirstChild();
02097 RefPascalAST tmp83_AST_in = _t;
02098 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02099 _t = _t->getNextSibling();
02100 _t = __t130;
02101 _t = _t->getNextSibling();
02102 break;
02103 }
02104 case IDENT:
02105 {
02106 RefPascalAST tmp84_AST_in = _t;
02107 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02108 _t = _t->getNextSibling();
02109 break;
02110 }
02111 default:
02112 {
02113 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02114 }
02115 }
02116 }
02117 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02118 reportError(ex);
02119 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02120 _t = _t->getNextSibling();
02121 }
02122 _retTree = _t;
02123 }
02124
02125 void PascalStoreWalker::expression(RefPascalAST _t) {
02126 RefPascalAST expression_AST_in = _t;
02127
02128 try {
02129 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02130 _t = ASTNULL;
02131 switch ( _t->getType()) {
02132 case EQUAL:
02133 {
02134 RefPascalAST __t132 = _t;
02135 RefPascalAST tmp85_AST_in = _t;
02136 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),EQUAL);
02137 _t = _t->getFirstChild();
02138 expression(_t);
02139 _t = _retTree;
02140 expression(_t);
02141 _t = _retTree;
02142 _t = __t132;
02143 _t = _t->getNextSibling();
02144 break;
02145 }
02146 case NOT_EQUAL:
02147 {
02148 RefPascalAST __t133 = _t;
02149 RefPascalAST tmp86_AST_in = _t;
02150 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NOT_EQUAL);
02151 _t = _t->getFirstChild();
02152 expression(_t);
02153 _t = _retTree;
02154 expression(_t);
02155 _t = _retTree;
02156 _t = __t133;
02157 _t = _t->getNextSibling();
02158 break;
02159 }
02160 case LTH:
02161 {
02162 RefPascalAST __t134 = _t;
02163 RefPascalAST tmp87_AST_in = _t;
02164 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LTH);
02165 _t = _t->getFirstChild();
02166 expression(_t);
02167 _t = _retTree;
02168 expression(_t);
02169 _t = _retTree;
02170 _t = __t134;
02171 _t = _t->getNextSibling();
02172 break;
02173 }
02174 case LE:
02175 {
02176 RefPascalAST __t135 = _t;
02177 RefPascalAST tmp88_AST_in = _t;
02178 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),LE);
02179 _t = _t->getFirstChild();
02180 expression(_t);
02181 _t = _retTree;
02182 expression(_t);
02183 _t = _retTree;
02184 _t = __t135;
02185 _t = _t->getNextSibling();
02186 break;
02187 }
02188 case GE:
02189 {
02190 RefPascalAST __t136 = _t;
02191 RefPascalAST tmp89_AST_in = _t;
02192 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),GE);
02193 _t = _t->getFirstChild();
02194 expression(_t);
02195 _t = _retTree;
02196 expression(_t);
02197 _t = _retTree;
02198 _t = __t136;
02199 _t = _t->getNextSibling();
02200 break;
02201 }
02202 case GT:
02203 {
02204 RefPascalAST __t137 = _t;
02205 RefPascalAST tmp90_AST_in = _t;
02206 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),GT);
02207 _t = _t->getFirstChild();
02208 expression(_t);
02209 _t = _retTree;
02210 expression(_t);
02211 _t = _retTree;
02212 _t = __t137;
02213 _t = _t->getNextSibling();
02214 break;
02215 }
02216 case IN:
02217 {
02218 RefPascalAST __t138 = _t;
02219 RefPascalAST tmp91_AST_in = _t;
02220 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IN);
02221 _t = _t->getFirstChild();
02222 expression(_t);
02223 _t = _retTree;
02224 expression(_t);
02225 _t = _retTree;
02226 _t = __t138;
02227 _t = _t->getNextSibling();
02228 break;
02229 }
02230 case PLUS:
02231 {
02232 RefPascalAST __t139 = _t;
02233 RefPascalAST tmp92_AST_in = _t;
02234 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),PLUS);
02235 _t = _t->getFirstChild();
02236 expression(_t);
02237 _t = _retTree;
02238 {
02239 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02240 _t = ASTNULL;
02241 switch ( _t->getType()) {
02242 case FUNC_CALL:
02243 case DOT:
02244 case EQUAL:
02245 case NUM_INT:
02246 case LBRACK:
02247 case SET:
02248 case POINTER:
02249 case LE:
02250 case GE:
02251 case LTH:
02252 case GT:
02253 case NOT_EQUAL:
02254 case IN:
02255 case PLUS:
02256 case MINUS:
02257 case OR:
02258 case STAR:
02259 case SLASH:
02260 case DIV:
02261 case MOD:
02262 case AND:
02263 case NOT:
02264 case AT:
02265 case LBRACK2:
02266 case STRING_LITERAL:
02267 case CHR:
02268 case NIL:
02269 case NUM_REAL:
02270 case IDENT:
02271 {
02272 expression(_t);
02273 _t = _retTree;
02274 break;
02275 }
02276 case 3:
02277 {
02278 break;
02279 }
02280 default:
02281 {
02282 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02283 }
02284 }
02285 }
02286 _t = __t139;
02287 _t = _t->getNextSibling();
02288 break;
02289 }
02290 case MINUS:
02291 {
02292 RefPascalAST __t141 = _t;
02293 RefPascalAST tmp93_AST_in = _t;
02294 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MINUS);
02295 _t = _t->getFirstChild();
02296 expression(_t);
02297 _t = _retTree;
02298 {
02299 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02300 _t = ASTNULL;
02301 switch ( _t->getType()) {
02302 case FUNC_CALL:
02303 case DOT:
02304 case EQUAL:
02305 case NUM_INT:
02306 case LBRACK:
02307 case SET:
02308 case POINTER:
02309 case LE:
02310 case GE:
02311 case LTH:
02312 case GT:
02313 case NOT_EQUAL:
02314 case IN:
02315 case PLUS:
02316 case MINUS:
02317 case OR:
02318 case STAR:
02319 case SLASH:
02320 case DIV:
02321 case MOD:
02322 case AND:
02323 case NOT:
02324 case AT:
02325 case LBRACK2:
02326 case STRING_LITERAL:
02327 case CHR:
02328 case NIL:
02329 case NUM_REAL:
02330 case IDENT:
02331 {
02332 expression(_t);
02333 _t = _retTree;
02334 break;
02335 }
02336 case 3:
02337 {
02338 break;
02339 }
02340 default:
02341 {
02342 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02343 }
02344 }
02345 }
02346 _t = __t141;
02347 _t = _t->getNextSibling();
02348 break;
02349 }
02350 case OR:
02351 {
02352 RefPascalAST __t143 = _t;
02353 RefPascalAST tmp94_AST_in = _t;
02354 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),OR);
02355 _t = _t->getFirstChild();
02356 expression(_t);
02357 _t = _retTree;
02358 expression(_t);
02359 _t = _retTree;
02360 _t = __t143;
02361 _t = _t->getNextSibling();
02362 break;
02363 }
02364 case STAR:
02365 {
02366 RefPascalAST __t144 = _t;
02367 RefPascalAST tmp95_AST_in = _t;
02368 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),STAR);
02369 _t = _t->getFirstChild();
02370 expression(_t);
02371 _t = _retTree;
02372 expression(_t);
02373 _t = _retTree;
02374 _t = __t144;
02375 _t = _t->getNextSibling();
02376 break;
02377 }
02378 case SLASH:
02379 {
02380 RefPascalAST __t145 = _t;
02381 RefPascalAST tmp96_AST_in = _t;
02382 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SLASH);
02383 _t = _t->getFirstChild();
02384 expression(_t);
02385 _t = _retTree;
02386 expression(_t);
02387 _t = _retTree;
02388 _t = __t145;
02389 _t = _t->getNextSibling();
02390 break;
02391 }
02392 case DIV:
02393 {
02394 RefPascalAST __t146 = _t;
02395 RefPascalAST tmp97_AST_in = _t;
02396 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DIV);
02397 _t = _t->getFirstChild();
02398 expression(_t);
02399 _t = _retTree;
02400 expression(_t);
02401 _t = _retTree;
02402 _t = __t146;
02403 _t = _t->getNextSibling();
02404 break;
02405 }
02406 case MOD:
02407 {
02408 RefPascalAST __t147 = _t;
02409 RefPascalAST tmp98_AST_in = _t;
02410 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),MOD);
02411 _t = _t->getFirstChild();
02412 expression(_t);
02413 _t = _retTree;
02414 expression(_t);
02415 _t = _retTree;
02416 _t = __t147;
02417 _t = _t->getNextSibling();
02418 break;
02419 }
02420 case AND:
02421 {
02422 RefPascalAST __t148 = _t;
02423 RefPascalAST tmp99_AST_in = _t;
02424 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),AND);
02425 _t = _t->getFirstChild();
02426 expression(_t);
02427 _t = _retTree;
02428 expression(_t);
02429 _t = _retTree;
02430 _t = __t148;
02431 _t = _t->getNextSibling();
02432 break;
02433 }
02434 case NOT:
02435 {
02436 RefPascalAST __t149 = _t;
02437 RefPascalAST tmp100_AST_in = _t;
02438 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NOT);
02439 _t = _t->getFirstChild();
02440 expression(_t);
02441 _t = _retTree;
02442 _t = __t149;
02443 _t = _t->getNextSibling();
02444 break;
02445 }
02446 case DOT:
02447 case LBRACK:
02448 case POINTER:
02449 case AT:
02450 case LBRACK2:
02451 case IDENT:
02452 {
02453 variable(_t);
02454 _t = _retTree;
02455 break;
02456 }
02457 case FUNC_CALL:
02458 {
02459 functionDesignator(_t);
02460 _t = _retTree;
02461 break;
02462 }
02463 case SET:
02464 {
02465 set(_t);
02466 _t = _retTree;
02467 break;
02468 }
02469 case NUM_INT:
02470 {
02471 RefPascalAST tmp101_AST_in = _t;
02472 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
02473 _t = _t->getNextSibling();
02474 break;
02475 }
02476 case NUM_REAL:
02477 {
02478 RefPascalAST tmp102_AST_in = _t;
02479 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
02480 _t = _t->getNextSibling();
02481 break;
02482 }
02483 case CHR:
02484 {
02485 RefPascalAST __t150 = _t;
02486 RefPascalAST tmp103_AST_in = _t;
02487 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CHR);
02488 _t = _t->getFirstChild();
02489 {
02490 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02491 _t = ASTNULL;
02492 switch ( _t->getType()) {
02493 case NUM_INT:
02494 {
02495 RefPascalAST tmp104_AST_in = _t;
02496 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_INT);
02497 _t = _t->getNextSibling();
02498 break;
02499 }
02500 case NUM_REAL:
02501 {
02502 RefPascalAST tmp105_AST_in = _t;
02503 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NUM_REAL);
02504 _t = _t->getNextSibling();
02505 break;
02506 }
02507 default:
02508 {
02509 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02510 }
02511 }
02512 }
02513 _t = __t150;
02514 _t = _t->getNextSibling();
02515 break;
02516 }
02517 case STRING_LITERAL:
02518 {
02519 string(_t);
02520 _t = _retTree;
02521 break;
02522 }
02523 case NIL:
02524 {
02525 RefPascalAST tmp106_AST_in = _t;
02526 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),NIL);
02527 _t = _t->getNextSibling();
02528 break;
02529 }
02530 default:
02531 {
02532 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02533 }
02534 }
02535 }
02536 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02537 reportError(ex);
02538 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02539 _t = _t->getNextSibling();
02540 }
02541 _retTree = _t;
02542 }
02543
02544 void PascalStoreWalker::functionDesignator(RefPascalAST _t) {
02545 RefPascalAST functionDesignator_AST_in = _t;
02546
02547 try {
02548 RefPascalAST __t153 = _t;
02549 RefPascalAST tmp107_AST_in = _t;
02550 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FUNC_CALL);
02551 _t = _t->getFirstChild();
02552 RefPascalAST tmp108_AST_in = _t;
02553 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
02554 _t = _t->getNextSibling();
02555 {
02556 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02557 _t = ASTNULL;
02558 switch ( _t->getType()) {
02559 case ARGLIST:
02560 {
02561 parameterList(_t);
02562 _t = _retTree;
02563 break;
02564 }
02565 case 3:
02566 {
02567 break;
02568 }
02569 default:
02570 {
02571 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02572 }
02573 }
02574 }
02575 _t = __t153;
02576 _t = _t->getNextSibling();
02577 }
02578 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02579 reportError(ex);
02580 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02581 _t = _t->getNextSibling();
02582 }
02583 _retTree = _t;
02584 }
02585
02586 void PascalStoreWalker::set(RefPascalAST _t) {
02587 RefPascalAST set_AST_in = _t;
02588
02589 try {
02590 RefPascalAST __t160 = _t;
02591 RefPascalAST tmp109_AST_in = _t;
02592 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),SET);
02593 _t = _t->getFirstChild();
02594 {
02595 for (;;) {
02596 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02597 _t = ASTNULL;
02598 if ((_tokenSet_4.member(_t->getType()))) {
02599 element(_t);
02600 _t = _retTree;
02601 }
02602 else {
02603 goto _loop162;
02604 }
02605
02606 }
02607 _loop162:;
02608 }
02609 _t = __t160;
02610 _t = _t->getNextSibling();
02611 }
02612 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02613 reportError(ex);
02614 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02615 _t = _t->getNextSibling();
02616 }
02617 _retTree = _t;
02618 }
02619
02620 void PascalStoreWalker::parameterList(RefPascalAST _t) {
02621 RefPascalAST parameterList_AST_in = _t;
02622
02623 try {
02624 RefPascalAST __t156 = _t;
02625 RefPascalAST tmp110_AST_in = _t;
02626 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),ARGLIST);
02627 _t = _t->getFirstChild();
02628 {
02629 int _cnt158=0;
02630 for (;;) {
02631 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02632 _t = ASTNULL;
02633 if ((_tokenSet_3.member(_t->getType()))) {
02634 actualParameter(_t);
02635 _t = _retTree;
02636 }
02637 else {
02638 if ( _cnt158>=1 ) { goto _loop158; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
02639 }
02640
02641 _cnt158++;
02642 }
02643 _loop158:;
02644 }
02645 _t = __t156;
02646 _t = _t->getNextSibling();
02647 }
02648 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02649 reportError(ex);
02650 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02651 _t = _t->getNextSibling();
02652 }
02653 _retTree = _t;
02654 }
02655
02656 void PascalStoreWalker::actualParameter(RefPascalAST _t) {
02657 RefPascalAST actualParameter_AST_in = _t;
02658
02659 try {
02660 expression(_t);
02661 _t = _retTree;
02662 }
02663 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02664 reportError(ex);
02665 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02666 _t = _t->getNextSibling();
02667 }
02668 _retTree = _t;
02669 }
02670
02671 void PascalStoreWalker::element(RefPascalAST _t) {
02672 RefPascalAST element_AST_in = _t;
02673
02674 try {
02675 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02676 _t = ASTNULL;
02677 switch ( _t->getType()) {
02678 case DOTDOT:
02679 {
02680 RefPascalAST __t164 = _t;
02681 RefPascalAST tmp111_AST_in = _t;
02682 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOTDOT);
02683 _t = _t->getFirstChild();
02684 expression(_t);
02685 _t = _retTree;
02686 expression(_t);
02687 _t = _retTree;
02688 _t = __t164;
02689 _t = _t->getNextSibling();
02690 break;
02691 }
02692 case FUNC_CALL:
02693 case DOT:
02694 case EQUAL:
02695 case NUM_INT:
02696 case LBRACK:
02697 case SET:
02698 case POINTER:
02699 case LE:
02700 case GE:
02701 case LTH:
02702 case GT:
02703 case NOT_EQUAL:
02704 case IN:
02705 case PLUS:
02706 case MINUS:
02707 case OR:
02708 case STAR:
02709 case SLASH:
02710 case DIV:
02711 case MOD:
02712 case AND:
02713 case NOT:
02714 case AT:
02715 case LBRACK2:
02716 case STRING_LITERAL:
02717 case CHR:
02718 case NIL:
02719 case NUM_REAL:
02720 case IDENT:
02721 {
02722 expression(_t);
02723 _t = _retTree;
02724 break;
02725 }
02726 default:
02727 {
02728 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02729 }
02730 }
02731 }
02732 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02733 reportError(ex);
02734 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02735 _t = _t->getNextSibling();
02736 }
02737 _retTree = _t;
02738 }
02739
02740 void PascalStoreWalker::conditionalStatement(RefPascalAST _t) {
02741 RefPascalAST conditionalStatement_AST_in = _t;
02742
02743 try {
02744 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02745 _t = ASTNULL;
02746 switch ( _t->getType()) {
02747 case IF:
02748 {
02749 ifStatement(_t);
02750 _t = _retTree;
02751 break;
02752 }
02753 case CASE:
02754 {
02755 caseStatement(_t);
02756 _t = _retTree;
02757 break;
02758 }
02759 default:
02760 {
02761 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02762 }
02763 }
02764 }
02765 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02766 reportError(ex);
02767 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02768 _t = _t->getNextSibling();
02769 }
02770 _retTree = _t;
02771 }
02772
02773 void PascalStoreWalker::repetetiveStatement(RefPascalAST _t) {
02774 RefPascalAST repetetiveStatement_AST_in = _t;
02775
02776 try {
02777 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02778 _t = ASTNULL;
02779 switch ( _t->getType()) {
02780 case WHILE:
02781 {
02782 whileStatement(_t);
02783 _t = _retTree;
02784 break;
02785 }
02786 case REPEAT:
02787 {
02788 repeatStatement(_t);
02789 _t = _retTree;
02790 break;
02791 }
02792 case FOR:
02793 {
02794 forStatement(_t);
02795 _t = _retTree;
02796 break;
02797 }
02798 default:
02799 {
02800 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02801 }
02802 }
02803 }
02804 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02805 reportError(ex);
02806 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02807 _t = _t->getNextSibling();
02808 }
02809 _retTree = _t;
02810 }
02811
02812 void PascalStoreWalker::withStatement(RefPascalAST _t) {
02813 RefPascalAST withStatement_AST_in = _t;
02814
02815 try {
02816 RefPascalAST __t201 = _t;
02817 RefPascalAST tmp112_AST_in = _t;
02818 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),WITH);
02819 _t = _t->getFirstChild();
02820 recordVariableList(_t);
02821 _t = _retTree;
02822 statement(_t);
02823 _t = _retTree;
02824 _t = __t201;
02825 _t = _t->getNextSibling();
02826 }
02827 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02828 reportError(ex);
02829 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02830 _t = _t->getNextSibling();
02831 }
02832 _retTree = _t;
02833 }
02834
02835 void PascalStoreWalker::statements(RefPascalAST _t) {
02836 RefPascalAST statements_AST_in = _t;
02837
02838 try {
02839 RefPascalAST __t174 = _t;
02840 RefPascalAST tmp113_AST_in = _t;
02841 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),BLOCK);
02842 _t = _t->getFirstChild();
02843 {
02844 for (;;) {
02845 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02846 _t = ASTNULL;
02847 if ((_tokenSet_5.member(_t->getType()))) {
02848 statement(_t);
02849 _t = _retTree;
02850 }
02851 else {
02852 goto _loop176;
02853 }
02854
02855 }
02856 _loop176:;
02857 }
02858 _t = __t174;
02859 _t = _t->getNextSibling();
02860 }
02861 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02862 reportError(ex);
02863 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02864 _t = _t->getNextSibling();
02865 }
02866 _retTree = _t;
02867 }
02868
02869 void PascalStoreWalker::ifStatement(RefPascalAST _t) {
02870 RefPascalAST ifStatement_AST_in = _t;
02871
02872 try {
02873 RefPascalAST __t179 = _t;
02874 RefPascalAST tmp114_AST_in = _t;
02875 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IF);
02876 _t = _t->getFirstChild();
02877 expression(_t);
02878 _t = _retTree;
02879 statement(_t);
02880 _t = _retTree;
02881 {
02882 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02883 _t = ASTNULL;
02884 switch ( _t->getType()) {
02885 case BLOCK:
02886 case PROC_CALL:
02887 case COLON:
02888 case ASSIGN:
02889 case CASE:
02890 case GOTO:
02891 case IF:
02892 case WHILE:
02893 case REPEAT:
02894 case FOR:
02895 case WITH:
02896 {
02897 statement(_t);
02898 _t = _retTree;
02899 break;
02900 }
02901 case 3:
02902 {
02903 break;
02904 }
02905 default:
02906 {
02907 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02908 }
02909 }
02910 }
02911 _t = __t179;
02912 _t = _t->getNextSibling();
02913 }
02914 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02915 reportError(ex);
02916 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02917 _t = _t->getNextSibling();
02918 }
02919 _retTree = _t;
02920 }
02921
02922 void PascalStoreWalker::caseStatement(RefPascalAST _t) {
02923 RefPascalAST caseStatement_AST_in = _t;
02924
02925 try {
02926 RefPascalAST __t182 = _t;
02927 RefPascalAST tmp115_AST_in = _t;
02928 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),CASE);
02929 _t = _t->getFirstChild();
02930 expression(_t);
02931 _t = _retTree;
02932 {
02933 int _cnt184=0;
02934 for (;;) {
02935 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02936 _t = ASTNULL;
02937 if ((_t->getType() == COLON)) {
02938 caseListElement(_t);
02939 _t = _retTree;
02940 }
02941 else {
02942 if ( _cnt184>=1 ) { goto _loop184; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
02943 }
02944
02945 _cnt184++;
02946 }
02947 _loop184:;
02948 }
02949 {
02950 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02951 _t = ASTNULL;
02952 switch ( _t->getType()) {
02953 case BLOCK:
02954 {
02955 statements(_t);
02956 _t = _retTree;
02957 break;
02958 }
02959 case 3:
02960 {
02961 break;
02962 }
02963 default:
02964 {
02965 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
02966 }
02967 }
02968 }
02969 _t = __t182;
02970 _t = _t->getNextSibling();
02971 }
02972 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02973 reportError(ex);
02974 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02975 _t = _t->getNextSibling();
02976 }
02977 _retTree = _t;
02978 }
02979
02980 void PascalStoreWalker::caseListElement(RefPascalAST _t) {
02981 RefPascalAST caseListElement_AST_in = _t;
02982
02983 try {
02984 RefPascalAST __t187 = _t;
02985 RefPascalAST tmp116_AST_in = _t;
02986 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),COLON);
02987 _t = _t->getFirstChild();
02988 constList(_t);
02989 _t = _retTree;
02990 statement(_t);
02991 _t = _retTree;
02992 _t = __t187;
02993 _t = _t->getNextSibling();
02994 }
02995 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
02996 reportError(ex);
02997 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
02998 _t = _t->getNextSibling();
02999 }
03000 _retTree = _t;
03001 }
03002
03003 void PascalStoreWalker::whileStatement(RefPascalAST _t) {
03004 RefPascalAST whileStatement_AST_in = _t;
03005
03006 try {
03007 RefPascalAST __t190 = _t;
03008 RefPascalAST tmp117_AST_in = _t;
03009 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),WHILE);
03010 _t = _t->getFirstChild();
03011 expression(_t);
03012 _t = _retTree;
03013 statement(_t);
03014 _t = _retTree;
03015 _t = __t190;
03016 _t = _t->getNextSibling();
03017 }
03018 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03019 reportError(ex);
03020 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03021 _t = _t->getNextSibling();
03022 }
03023 _retTree = _t;
03024 }
03025
03026 void PascalStoreWalker::repeatStatement(RefPascalAST _t) {
03027 RefPascalAST repeatStatement_AST_in = _t;
03028
03029 try {
03030 RefPascalAST __t192 = _t;
03031 RefPascalAST tmp118_AST_in = _t;
03032 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),REPEAT);
03033 _t = _t->getFirstChild();
03034 statements(_t);
03035 _t = _retTree;
03036 expression(_t);
03037 _t = _retTree;
03038 _t = __t192;
03039 _t = _t->getNextSibling();
03040 }
03041 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03042 reportError(ex);
03043 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03044 _t = _t->getNextSibling();
03045 }
03046 _retTree = _t;
03047 }
03048
03049 void PascalStoreWalker::forStatement(RefPascalAST _t) {
03050 RefPascalAST forStatement_AST_in = _t;
03051
03052 try {
03053 RefPascalAST __t194 = _t;
03054 RefPascalAST tmp119_AST_in = _t;
03055 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),FOR);
03056 _t = _t->getFirstChild();
03057 RefPascalAST tmp120_AST_in = _t;
03058 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),IDENT);
03059 _t = _t->getNextSibling();
03060 forList(_t);
03061 _t = _retTree;
03062 statement(_t);
03063 _t = _retTree;
03064 _t = __t194;
03065 _t = _t->getNextSibling();
03066 }
03067 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03068 reportError(ex);
03069 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03070 _t = _t->getNextSibling();
03071 }
03072 _retTree = _t;
03073 }
03074
03075 void PascalStoreWalker::forList(RefPascalAST _t) {
03076 RefPascalAST forList_AST_in = _t;
03077
03078 try {
03079 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03080 _t = ASTNULL;
03081 switch ( _t->getType()) {
03082 case TO:
03083 {
03084 RefPascalAST __t196 = _t;
03085 RefPascalAST tmp121_AST_in = _t;
03086 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),TO);
03087 _t = _t->getFirstChild();
03088 initialValue(_t);
03089 _t = _retTree;
03090 finalValue(_t);
03091 _t = _retTree;
03092 _t = __t196;
03093 _t = _t->getNextSibling();
03094 break;
03095 }
03096 case DOWNTO:
03097 {
03098 RefPascalAST __t197 = _t;
03099 RefPascalAST tmp122_AST_in = _t;
03100 match(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()),DOWNTO);
03101 _t = _t->getFirstChild();
03102 initialValue(_t);
03103 _t = _retTree;
03104 finalValue(_t);
03105 _t = _retTree;
03106 _t = __t197;
03107 _t = _t->getNextSibling();
03108 break;
03109 }
03110 default:
03111 {
03112 throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));
03113 }
03114 }
03115 }
03116 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03117 reportError(ex);
03118 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03119 _t = _t->getNextSibling();
03120 }
03121 _retTree = _t;
03122 }
03123
03124 void PascalStoreWalker::initialValue(RefPascalAST _t) {
03125 RefPascalAST initialValue_AST_in = _t;
03126
03127 try {
03128 expression(_t);
03129 _t = _retTree;
03130 }
03131 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03132 reportError(ex);
03133 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03134 _t = _t->getNextSibling();
03135 }
03136 _retTree = _t;
03137 }
03138
03139 void PascalStoreWalker::finalValue(RefPascalAST _t) {
03140 RefPascalAST finalValue_AST_in = _t;
03141
03142 try {
03143 expression(_t);
03144 _t = _retTree;
03145 }
03146 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03147 reportError(ex);
03148 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03149 _t = _t->getNextSibling();
03150 }
03151 _retTree = _t;
03152 }
03153
03154 void PascalStoreWalker::recordVariableList(RefPascalAST _t) {
03155 RefPascalAST recordVariableList_AST_in = _t;
03156
03157 try {
03158 {
03159 int _cnt204=0;
03160 for (;;) {
03161 if (_t == static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03162 _t = ASTNULL;
03163 if ((_tokenSet_6.member(_t->getType()))) {
03164 variable(_t);
03165 _t = _retTree;
03166 }
03167 else {
03168 if ( _cnt204>=1 ) { goto _loop204; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(static_cast<ANTLR_USE_NAMESPACE(antlr)RefAST>(_t.get()));}
03169 }
03170
03171 _cnt204++;
03172 }
03173 _loop204:;
03174 }
03175 }
03176 catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
03177 reportError(ex);
03178 if ( _t != static_cast<RefPascalAST>(ANTLR_USE_NAMESPACE(antlr)nullAST.get()) )
03179 _t = _t->getNextSibling();
03180 }
03181 _retTree = _t;
03182 }
03183
03184 RefPascalAST PascalStoreWalker::getAST()
03185 {
03186 return returnAST;
03187 }
03188
03189 void PascalStoreWalker::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
03190 {
03191 }
03192 const char* PascalStoreWalker::tokenNames[] = {
03193 "<0>",
03194 "EOF",
03195 "<2>",
03196 "NULL_TREE_LOOKAHEAD",
03197 "BLOCK",
03198 "IDLIST",
03199 "ELIST",
03200 "FUNC_CALL",
03201 "PROC_CALL",
03202 "SCALARTYPE",
03203 "TYPELIST",
03204 "VARIANT_TAG",
03205 "VARIANT_TAG_NO_ID",
03206 "VARIANT_CASE",
03207 "CONSTLIST",
03208 "FIELDLIST",
03209 "ARGDECLS",
03210 "VARDECL",
03211 "ARGDECL",
03212 "ARGLIST",
03213 "TYPEDECL",
03214 "FIELD",
03215 "DOT",
03216 "\"library\"",
03217 "SEMI",
03218 "\"end\"",
03219 "\"exports\"",
03220 "COMMA",
03221 "\"index\"",
03222 "\"name\"",
03223 "\"uses\"",
03224 "\"unit\"",
03225 "\"interface\"",
03226 "\"implementation\"",
03227 "\"begin\"",
03228 "\"program\"",
03229 "LPAREN",
03230 "RPAREN",
03231 "\"initialization\"",
03232 "\"finalization\"",
03233 "\"label\"",
03234 "\"const\"",
03235 "\"resourcestring\"",
03236 "EQUAL",
03237 "\"type\"",
03238 "\"var\"",
03239 "COLON",
03240 "\"procedure\"",
03241 "\"forward\"",
03242 "\"function\"",
03243 "\"array\"",
03244 "\"of\"",
03245 "\"external\"",
03246 "\"public\"",
03247 "\"alias\"",
03248 "INTERRUPT",
03249 "\"export\"",
03250 "\"register\"",
03251 "\"pascal\"",
03252 "\"cdecl\"",
03253 "\"stdcall\"",
03254 "\"popstack\"",
03255 "\"saveregisters\"",
03256 "\"inline\"",
03257 "\"safecall\"",
03258 "\"near\"",
03259 "\"far\"",
03260 "NUM_INT",
03261 "\"integer\"",
03262 "\"shortint\"",
03263 "\"smallint\"",
03264 "\"longint\"",
03265 "\"int64\"",
03266 "\"byte\"",
03267 "\"word\"",
03268 "\"cardinal\"",
03269 "\"qword\"",
03270 "\"boolean\"",
03271 "BYTEBOOL",
03272 "LONGBOOL",
03273 "\"char\"",
03274 "DOTDOT",
03275 "ASSIGN",
03276 "\"real\"",
03277 "\"single\"",
03278 "\"double\"",
03279 "\"extended\"",
03280 "\"comp\"",
03281 "\"string\"",
03282 "LBRACK",
03283 "RBRACK",
03284 "\"packed\"",
03285 "\"record\"",
03286 "\"case\"",
03287 "\"set\"",
03288 "\"file\"",
03289 "POINTER",
03290 "\"object\"",
03291 "\"virtual\"",
03292 "\"abstract\"",
03293 "\"private\"",
03294 "\"protected\"",
03295 "\"constructor\"",
03296 "\"destructor\"",
03297 "\"class\"",
03298 "\"override\"",
03299 "MESSAGE",
03300 "\"published\"",
03301 "\"property\"",
03302 "\"read\"",
03303 "\"write\"",
03304 "\"default\"",
03305 "\"nodefault\"",
03306 "LE",
03307 "GE",
03308 "LTH",
03309 "GT",
03310 "NOT_EQUAL",
03311 "\"in\"",
03312 "\"is\"",
03313 "PLUS",
03314 "MINUS",
03315 "\"or\"",
03316 "\"xor\"",
03317 "STAR",
03318 "SLASH",
03319 "\"div\"",
03320 "\"mod\"",
03321 "\"and\"",
03322 "\"shl\"",
03323 "\"shr\"",
03324 "\"not\"",
03325 "\"true\"",
03326 "\"false\"",
03327 "AT",
03328 "PLUSEQ",
03329 "MINUSEQ",
03330 "STAREQ",
03331 "SLASHQE",
03332 "\"goto\"",
03333 "\"if\"",
03334 "\"then\"",
03335 "\"else\"",
03336 "\"while\"",
03337 "\"do\"",
03338 "\"repeat\"",
03339 "\"until\"",
03340 "\"for\"",
03341 "\"to\"",
03342 "\"downto\"",
03343 "\"with\"",
03344 "LBRACK2",
03345 "RBRACK2",
03346 "\"operator\"",
03347 "\"raise\"",
03348 "\"try\"",
03349 "\"except\"",
03350 "\"finally\"",
03351 "\"on\"",
03352 "STRING_LITERAL",
03353 "\"chr\"",
03354 "\"nil\"",
03355 "NUM_REAL",
03356 "IDENT",
03357 "\"absolute\"",
03358 "\"as\"",
03359 "\"asm\"",
03360 "\"assembler\"",
03361 "\"break\"",
03362 "\"continue\"",
03363 "\"dispose\"",
03364 "\"exit\"",
03365 "\"inherited\"",
03366 "\"new\"",
03367 "\"self\"",
03368 "METHOD",
03369 "ADDSUBOR",
03370 "ASSIGNEQUAL",
03371 "SIGN",
03372 "FUNC",
03373 "NODE_NOT_EMIT",
03374 "MYASTVAR",
03375 "LF",
03376 "LCURLY",
03377 "RCURLY",
03378 "WS",
03379 "COMMENT_1",
03380 "COMMENT_2",
03381 "COMMENT_3",
03382 "EXPONENT",
03383 0
03384 };
03385
03386 const unsigned long PascalStoreWalker::_tokenSet_0_data_[] = { 262144UL, 172032UL, 0UL, 0UL, 0UL, 0UL };
03387
03388 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_0(_tokenSet_0_data_,6);
03389 const unsigned long PascalStoreWalker::_tokenSet_1_data_[] = { 512UL, 262144UL, 3641384976UL, 1UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03390
03391
03392 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_1(_tokenSet_1_data_,12);
03393 const unsigned long PascalStoreWalker::_tokenSet_2_data_[] = { 0UL, 0UL, 8UL, 50331648UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03394
03395 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_2(_tokenSet_2_data_,12);
03396 const unsigned long PascalStoreWalker::_tokenSet_3_data_[] = { 4194432UL, 2048UL, 1107296264UL, 4152229889UL, 2155872329UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03397
03398
03399
03400 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_3(_tokenSet_3_data_,12);
03401 const unsigned long PascalStoreWalker::_tokenSet_4_data_[] = { 4194432UL, 2048UL, 1107427336UL, 4152229889UL, 2155872329UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03402
03403
03404
03405 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_4(_tokenSet_4_data_,12);
03406 const unsigned long PascalStoreWalker::_tokenSet_5_data_[] = { 272UL, 16384UL, 537133056UL, 0UL, 4888576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03407
03408
03409 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_5(_tokenSet_5_data_,12);
03410 const unsigned long PascalStoreWalker::_tokenSet_6_data_[] = { 4194304UL, 0UL, 33554432UL, 1UL, 8388672UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
03411
03412 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_6(_tokenSet_6_data_,12);
03413
03414