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