KDevelop API Documentation

PascalStoreWalker.cpp

Go to the documentation of this file.
00001 /* $ANTLR 2.7.2: "pascal.tree.g" -> "PascalStoreWalker.cpp"$ */
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 {      // for error handling
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 // ARGDECL "var" "procedure" "function" 
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 // SCALARTYPE "array" "integer" "boolean" "char" DOTDOT "real" "string" 
03391 // "packed" "record" "set" "file" POINTER IDENT 
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 // NUM_INT PLUS MINUS STRING_LITERAL "chr" NUM_REAL IDENT 
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 // FUNC_CALL DOT EQUAL NUM_INT LBRACK "set" POINTER LE GE LTH GT NOT_EQUAL 
03398 // "in" PLUS MINUS "or" STAR SLASH "div" "mod" "and" "not" AT LBRACK2 STRING_LITERAL 
03399 // "chr" "nil" NUM_REAL IDENT 
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 // FUNC_CALL DOT EQUAL NUM_INT DOTDOT LBRACK "set" POINTER LE GE LTH GT 
03403 // NOT_EQUAL "in" PLUS MINUS "or" STAR SLASH "div" "mod" "and" "not" AT 
03404 // LBRACK2 STRING_LITERAL "chr" "nil" NUM_REAL IDENT 
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 // BLOCK PROC_CALL COLON ASSIGN "case" "goto" "if" "while" "repeat" "for" 
03408 // "with" 
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 // DOT LBRACK POINTER AT LBRACK2 IDENT 
03412 const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_6(_tokenSet_6_data_,12);
03413 
03414 
KDE Logo
This file is part of the documentation for KDevelop Version 3.1.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 23 00:03:49 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003