summaryrefslogtreecommitdiffstats
path: root/languages/pascal/PascalParser.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'languages/pascal/PascalParser.cpp')
-rw-r--r--languages/pascal/PascalParser.cpp9744
1 files changed, 9744 insertions, 0 deletions
diff --git a/languages/pascal/PascalParser.cpp b/languages/pascal/PascalParser.cpp
new file mode 100644
index 00000000..172f4a49
--- /dev/null
+++ b/languages/pascal/PascalParser.cpp
@@ -0,0 +1,9744 @@
+/* $ANTLR 2.7.7 (20061129): "pascal.g" -> "PascalParser.cpp"$ */
+#include "PascalParser.hpp"
+#include <antlr/NoViableAltException.hpp>
+#include <antlr/SemanticException.hpp>
+#include <antlr/ASTFactory.hpp>
+#line 1 "pascal.g"
+#line 8 "PascalParser.cpp"
+PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,k)
+{
+}
+
+PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(tokenBuf,2)
+{
+}
+
+PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,k)
+{
+}
+
+PascalParser::PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(lexer,2)
+{
+}
+
+PascalParser::PascalParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state)
+: ANTLR_USE_NAMESPACE(antlr)LLkParser(state,2)
+{
+}
+
+void PascalParser::compilationUnit() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST compilationUnit_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PROGRAM:
+ {
+ program();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ compilationUnit_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LIBRARY:
+ {
+ library();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ compilationUnit_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case UNIT:
+ {
+ unit();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ compilationUnit_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = compilationUnit_AST;
+}
+
+void PascalParser::program() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST program_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ programHeading();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case USES:
+ {
+ usesClause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case BEGIN:
+ case LABEL:
+ case CONST:
+ case RESOURCESTRING:
+ case TYPE:
+ case VAR:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ block();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DOT);
+ program_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = program_AST;
+}
+
+void PascalParser::library() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST library_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp2_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp2_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp2_AST));
+ }
+ match(LIBRARY);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ {
+ switch ( LA(1)) {
+ case USES:
+ {
+ usesClause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case EXPORTS:
+ case BEGIN:
+ case LABEL:
+ case CONST:
+ case RESOURCESTRING:
+ case TYPE:
+ case VAR:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ libraryBlock();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ exportsClause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ match(DOT);
+ library_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = library_AST;
+}
+
+void PascalParser::unit() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST unit_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp6_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp6_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp6_AST));
+ }
+ match(UNIT);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ interfacePart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ implementationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case INITIALIZATION:
+ {
+ {
+ initializationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case FINALIZATION:
+ {
+ finalizationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ break;
+ }
+ case BEGIN:
+ {
+ realizationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(END);
+ unit_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = unit_AST;
+}
+
+void PascalParser::programHeading() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST programHeading_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp9_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp9_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp9_AST));
+ }
+ match(PROGRAM);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ match(LPAREN);
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ programHeading_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_1);
+ } else {
+ throw;
+ }
+ }
+ returnAST = programHeading_AST;
+}
+
+void PascalParser::usesClause() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST usesClause_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp13_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp13_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp13_AST));
+ }
+ match(USES);
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ usesClause_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_2);
+ } else {
+ throw;
+ }
+ }
+ returnAST = usesClause_AST;
+}
+
+void PascalParser::block() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST block_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ declarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ statementPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ block_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_3);
+ } else {
+ throw;
+ }
+ }
+ returnAST = block_AST;
+}
+
+void PascalParser::identifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST identifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp15_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp15_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp15_AST));
+ }
+ match(IDENT);
+ identifier_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_4);
+ } else {
+ throw;
+ }
+ }
+ returnAST = identifier_AST;
+}
+
+void PascalParser::libraryBlock() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST libraryBlock_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ declarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ {
+ statementPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case EXPORTS:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ libraryBlock_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_5);
+ } else {
+ throw;
+ }
+ }
+ returnAST = libraryBlock_AST;
+}
+
+void PascalParser::exportsClause() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exportsClause_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp16_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp16_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp16_AST));
+ }
+ match(EXPORTS);
+ exportsList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ exportsClause_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exportsClause_AST;
+}
+
+void PascalParser::declarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST declarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case LABEL:
+ {
+ labelDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case CONST:
+ {
+ constantDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RESOURCESTRING:
+ {
+ resourcestringDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case TYPE:
+ {
+ typeDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case VAR:
+ {
+ variableDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ procedureAndFunctionDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop41;
+ }
+ }
+ }
+ _loop41:;
+ } // ( ... )*
+ declarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_7);
+ } else {
+ throw;
+ }
+ }
+ returnAST = declarationPart_AST;
+}
+
+void PascalParser::statementPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST statementPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ compoundStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ statementPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_3);
+ } else {
+ throw;
+ }
+ }
+ returnAST = statementPart_AST;
+}
+
+void PascalParser::exportsList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exportsList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ exportsEntry();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ exportsEntry();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop11;
+ }
+
+ }
+ _loop11:;
+ } // ( ... )*
+ {
+ switch ( LA(1)) {
+ case SEMI:
+ {
+ match(SEMI);
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ exportsList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exportsList_AST;
+}
+
+void PascalParser::exportsEntry() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exportsEntry_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_index:
+ {
+ RefPascalAST tmp19_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp19_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp19_AST));
+ }
+ match(LITERAL_index);
+ integerConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ case COMMA:
+ case LITERAL_name:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_name:
+ {
+ RefPascalAST tmp20_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp20_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp20_AST));
+ }
+ match(LITERAL_name);
+ stringConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ case COMMA:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ exportsEntry_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_8);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exportsEntry_AST;
+}
+
+void PascalParser::integerConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST integerConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefPascalAST s_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefPascalAST n_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case NUM_INT:
+ {
+ unsignedInteger();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ integerConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PLUS:
+ case MINUS:
+ {
+ sign();
+ if (inputState->guessing==0) {
+ s_AST = returnAST;
+ }
+ unsignedInteger();
+ if (inputState->guessing==0) {
+ n_AST = returnAST;
+ }
+ if ( inputState->guessing==0 ) {
+ integerConstant_AST = RefPascalAST(currentAST.root);
+#line 880 "pascal.g"
+ integerConstant_AST=RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST))));
+#line 780 "PascalParser.cpp"
+ currentAST.root = integerConstant_AST;
+ if ( integerConstant_AST!=RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ integerConstant_AST->getFirstChild() != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = integerConstant_AST->getFirstChild();
+ else
+ currentAST.child = integerConstant_AST;
+ currentAST.advanceChildToEnd();
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_9);
+ } else {
+ throw;
+ }
+ }
+ returnAST = integerConstant_AST;
+}
+
+void PascalParser::stringConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST stringConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case STRING_LITERAL:
+ {
+ string();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ stringConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CHR:
+ {
+ constantChr();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ stringConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_10);
+ } else {
+ throw;
+ }
+ }
+ returnAST = stringConstant_AST;
+}
+
+void PascalParser::identifierList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST identifierList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop378;
+ }
+
+ }
+ _loop378:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ identifierList_AST = RefPascalAST(currentAST.root);
+#line 867 "pascal.g"
+ identifierList_AST = RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(IDLIST)))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(identifierList_AST))));
+#line 880 "PascalParser.cpp"
+ currentAST.root = identifierList_AST;
+ if ( identifierList_AST!=RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ identifierList_AST->getFirstChild() != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = identifierList_AST->getFirstChild();
+ else
+ currentAST.child = identifierList_AST;
+ currentAST.advanceChildToEnd();
+ }
+ identifierList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_11);
+ } else {
+ throw;
+ }
+ }
+ returnAST = identifierList_AST;
+}
+
+void PascalParser::interfacePart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST interfacePart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp22_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp22_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp22_AST));
+ }
+ match(INTERFACE);
+ {
+ switch ( LA(1)) {
+ case USES:
+ {
+ usesClause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IMPLEMENTATION:
+ case CONST:
+ case TYPE:
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case CONST:
+ {
+ constantDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case TYPE:
+ {
+ typeDeclarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ procedureHeadersPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ goto _loop24;
+ }
+ }
+ }
+ _loop24:;
+ } // ( ... )*
+ interfacePart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_12);
+ } else {
+ throw;
+ }
+ }
+ returnAST = interfacePart_AST;
+}
+
+void PascalParser::implementationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST implementationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp23_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp23_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp23_AST));
+ }
+ match(IMPLEMENTATION);
+ {
+ switch ( LA(1)) {
+ case USES:
+ {
+ usesClause();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case BEGIN:
+ case INITIALIZATION:
+ case LABEL:
+ case CONST:
+ case RESOURCESTRING:
+ case TYPE:
+ case VAR:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ declarationPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ implementationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_13);
+ } else {
+ throw;
+ }
+ }
+ returnAST = implementationPart_AST;
+}
+
+void PascalParser::initializationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST initializationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp24_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp24_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp24_AST));
+ }
+ match(INITIALIZATION);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop34;
+ }
+
+ }
+ _loop34:;
+ } // ( ... )*
+ initializationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_14);
+ } else {
+ throw;
+ }
+ }
+ returnAST = initializationPart_AST;
+}
+
+void PascalParser::finalizationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST finalizationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp26_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp26_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp26_AST));
+ }
+ match(FINALIZATION);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop37;
+ }
+
+ }
+ _loop37:;
+ } // ( ... )*
+ finalizationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = finalizationPart_AST;
+}
+
+void PascalParser::realizationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST realizationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp28_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp28_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp28_AST));
+ }
+ match(BEGIN);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop29;
+ }
+
+ }
+ _loop29:;
+ } // ( ... )*
+ realizationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = realizationPart_AST;
+}
+
+void PascalParser::constantDeclarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constantDeclarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp30_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp30_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp30_AST));
+ }
+ match(CONST);
+ { // ( ... )+
+ int _cnt47=0;
+ for (;;) {
+ if ((LA(1) == IDENT) && (LA(2) == EQUAL)) {
+ constantDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+ typedConstantDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt47>=1 ) { goto _loop47; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt47++;
+ }
+ _loop47:;
+ } // ( ... )+
+ constantDeclarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_2);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constantDeclarationPart_AST;
+}
+
+void PascalParser::typeDeclarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST typeDeclarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp31_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp31_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp31_AST));
+ }
+ match(TYPE);
+ { // ( ... )+
+ int _cnt54=0;
+ for (;;) {
+ if ((LA(1) == IDENT)) {
+ typeDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt54>=1 ) { goto _loop54; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt54++;
+ }
+ _loop54:;
+ } // ( ... )+
+ typeDeclarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_2);
+ } else {
+ throw;
+ }
+ }
+ returnAST = typeDeclarationPart_AST;
+}
+
+void PascalParser::procedureHeadersPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST procedureHeadersPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ procedureHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureHeadersPart_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ functionHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureHeadersPart_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_15);
+ } else {
+ throw;
+ }
+ }
+ returnAST = procedureHeadersPart_AST;
+}
+
+void PascalParser::statement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST statement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case NUM_INT:
+ {
+ label();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ break;
+ }
+ case BEGIN:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case IDENT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case GOTO:
+ case RAISE:
+ case IDENT:
+ {
+ simpleStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case BEGIN:
+ case CASE:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case TRY:
+ {
+ structuredStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ statement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = statement_AST;
+}
+
+void PascalParser::labelDeclarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST labelDeclarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp33_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp33_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp33_AST));
+ }
+ match(LABEL);
+ label();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ label();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop44;
+ }
+
+ }
+ _loop44:;
+ } // ( ... )*
+ match(SEMI);
+ labelDeclarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = labelDeclarationPart_AST;
+}
+
+void PascalParser::resourcestringDeclarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST resourcestringDeclarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp36_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp36_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp36_AST));
+ }
+ match(RESOURCESTRING);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == IDENT)) {
+ stringConstantDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop50;
+ }
+
+ }
+ _loop50:;
+ } // ( ... )*
+ resourcestringDeclarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = resourcestringDeclarationPart_AST;
+}
+
+void PascalParser::variableDeclarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST variableDeclarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp37_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp37_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp37_AST));
+ }
+ match(VAR);
+ variableDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI) && (LA(2) == IDENT)) {
+ match(SEMI);
+ variableDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop57;
+ }
+
+ }
+ _loop57:;
+ } // ( ... )*
+ match(SEMI);
+ variableDeclarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = variableDeclarationPart_AST;
+}
+
+void PascalParser::procedureAndFunctionDeclarationPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST procedureAndFunctionDeclarationPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ procedureAndFunctionDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureAndFunctionDeclarationPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = procedureAndFunctionDeclarationPart_AST;
+}
+
+void PascalParser::label() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST label_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ unsignedInteger();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ label_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_18);
+ } else {
+ throw;
+ }
+ }
+ returnAST = label_AST;
+}
+
+void PascalParser::constantDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constantDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(EQUAL);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ constantDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_19);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constantDeclaration_AST;
+}
+
+void PascalParser::typedConstantDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST typedConstantDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(EQUAL);
+ typedConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ typedConstantDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_19);
+ } else {
+ throw;
+ }
+ }
+ returnAST = typedConstantDeclaration_AST;
+}
+
+void PascalParser::stringConstantDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST stringConstantDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(EQUAL);
+ string();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ stringConstantDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_20);
+ } else {
+ throw;
+ }
+ }
+ returnAST = stringConstantDeclaration_AST;
+}
+
+void PascalParser::string() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST string_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp46_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp46_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp46_AST));
+ }
+ match(STRING_LITERAL);
+ string_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_21);
+ } else {
+ throw;
+ }
+ }
+ returnAST = string_AST;
+}
+
+void PascalParser::typeDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST typeDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(EQUAL);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ typeDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_19);
+ } else {
+ throw;
+ }
+ }
+ returnAST = typeDeclaration_AST;
+}
+
+void PascalParser::variableDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST variableDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)RefToken c = ANTLR_USE_NAMESPACE(antlr)nullToken;
+ RefPascalAST c_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ c = LT(1);
+ if ( inputState->guessing == 0 ) {
+ c_AST = astFactory->create(c);
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(c_AST));
+ }
+ match(COLON);
+ if ( inputState->guessing==0 ) {
+#line 246 "pascal.g"
+ c_AST->setType(VARDECL);
+#line 1741 "PascalParser.cpp"
+ }
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ variableDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = variableDeclaration_AST;
+}
+
+void PascalParser::type() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST type_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case INTEGER:
+ case SHORTINT:
+ case SMALLINT:
+ case LONGINT:
+ case INT64:
+ case BYTE:
+ case WORD:
+ case CARDINAL:
+ case QWORD:
+ case BOOLEAN:
+ case BYTEBOOL:
+ case LONGBOOL:
+ case CHAR:
+ case REAL:
+ case SINGLE:
+ case DOUBLE:
+ case EXTENDED:
+ case COMP:
+ {
+ simpleType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case STRING_LITERAL:
+ case CHR:
+ case NUM_REAL:
+ case IDENT:
+ {
+ subrangeTypeOrTypeIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LPAREN:
+ {
+ enumeratedType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case STRING:
+ {
+ stringType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case ARRAY:
+ case PACKED:
+ case RECORD:
+ case SET:
+ case FILE:
+ case OBJECT:
+ case CLASS:
+ {
+ structuredType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case POINTER:
+ {
+ pointerType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ proceduralType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ type_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = type_AST;
+}
+
+void PascalParser::procedureAndFunctionDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST procedureAndFunctionDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PROCEDURE:
+ {
+ procedureDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureAndFunctionDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case FUNCTION:
+ {
+ functionDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureAndFunctionDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CONSTRUCTOR:
+ {
+ constructorDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureAndFunctionDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case DESTRUCTOR:
+ {
+ destructorDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ procedureAndFunctionDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = procedureAndFunctionDeclaration_AST;
+}
+
+void PascalParser::procedureDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST procedureDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ procedureHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subroutineBlock();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ procedureDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = procedureDeclaration_AST;
+}
+
+void PascalParser::functionDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST functionDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ functionHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subroutineBlock();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ functionDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = functionDeclaration_AST;
+}
+
+void PascalParser::constructorDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constructorDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ constructorHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ subroutineBlock();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constructorDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constructorDeclaration_AST;
+}
+
+void PascalParser::destructorDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST destructorDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ destructorHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ subroutineBlock();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ destructorDeclaration_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_17);
+ } else {
+ throw;
+ }
+ }
+ returnAST = destructorDeclaration_AST;
+}
+
+void PascalParser::compoundStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST compoundStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if ((LA(1) == BEGIN) && (LA(2) == END)) {
+ match(BEGIN);
+ match(END);
+ compoundStatement_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == BEGIN) && (LA(2) == SEMI)) {
+ match(BEGIN);
+ { // ( ... )+
+ int _cnt312=0;
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ }
+ else {
+ if ( _cnt312>=1 ) { goto _loop312; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt312++;
+ }
+ _loop312:;
+ } // ( ... )+
+ match(END);
+ compoundStatement_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == BEGIN) && (_tokenSet_24.member(LA(2)))) {
+ match(BEGIN);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ case NUM_INT:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case IDENT:
+ {
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ goto _loop315;
+ }
+
+ }
+ _loop315:;
+ } // ( ... )*
+ match(END);
+ compoundStatement_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_25);
+ } else {
+ throw;
+ }
+ }
+ returnAST = compoundStatement_AST;
+}
+
+void PascalParser::procedureHeader() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST procedureHeader_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp61_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp61_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp61_AST));
+ }
+ match(PROCEDURE);
+ {
+ if ((LA(1) == IDENT) && (LA(2) == SEMI || LA(2) == LPAREN)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+ qualifiedMethodIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop68;
+ }
+
+ }
+ _loop68:;
+ } // ( ... )*
+ procedureHeader_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_26);
+ } else {
+ throw;
+ }
+ }
+ returnAST = procedureHeader_AST;
+}
+
+void PascalParser::subroutineBlock() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST subroutineBlock_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case BEGIN:
+ case LABEL:
+ case CONST:
+ case RESOURCESTRING:
+ case TYPE:
+ case VAR:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ block();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subroutineBlock_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case EXTERNAL:
+ {
+ externalDirective();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subroutineBlock_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case FORWARD:
+ {
+ match(FORWARD);
+ subroutineBlock_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_27);
+ } else {
+ throw;
+ }
+ }
+ returnAST = subroutineBlock_AST;
+}
+
+void PascalParser::functionHeader() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST functionHeader_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched74 = false;
+ if (((LA(1) == FUNCTION) && (LA(2) == IDENT))) {
+ int _m74 = mark();
+ synPredMatched74 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(FUNCTION);
+ identifier();
+ match(COLON);
+ type();
+ match(SEMI);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched74 = false;
+ }
+ rewind(_m74);
+ inputState->guessing--;
+ }
+ if ( synPredMatched74 ) {
+ RefPascalAST tmp65_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp65_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp65_AST));
+ }
+ match(FUNCTION);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop76;
+ }
+
+ }
+ _loop76:;
+ } // ( ... )*
+ functionHeader_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched78 = false;
+ if (((LA(1) == FUNCTION) && (LA(2) == IDENT))) {
+ int _m78 = mark();
+ synPredMatched78 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(FUNCTION);
+ identifier();
+ match(COLON);
+ match(COLON);
+ identifier();
+ match(COLON);
+ type();
+ match(SEMI);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched78 = false;
+ }
+ rewind(_m78);
+ inputState->guessing--;
+ }
+ if ( synPredMatched78 ) {
+ RefPascalAST tmp69_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp69_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp69_AST));
+ }
+ match(FUNCTION);
+ qualifiedMethodIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop80;
+ }
+
+ }
+ _loop80:;
+ } // ( ... )*
+ functionHeader_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched82 = false;
+ if (((LA(1) == FUNCTION) && (LA(2) == IDENT))) {
+ int _m82 = mark();
+ synPredMatched82 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(FUNCTION);
+ identifier();
+ match(COLON);
+ match(COLON);
+ identifier();
+ match(LPAREN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched82 = false;
+ }
+ rewind(_m82);
+ inputState->guessing--;
+ }
+ if ( synPredMatched82 ) {
+ RefPascalAST tmp73_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp73_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp73_AST));
+ }
+ match(FUNCTION);
+ qualifiedMethodIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop84;
+ }
+
+ }
+ _loop84:;
+ } // ( ... )*
+ functionHeader_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == FUNCTION) && (LA(2) == IDENT)) {
+ RefPascalAST tmp77_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp77_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp77_AST));
+ }
+ match(FUNCTION);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop86;
+ }
+
+ }
+ _loop86:;
+ } // ( ... )*
+ functionHeader_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }}
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_26);
+ } else {
+ throw;
+ }
+ }
+ returnAST = functionHeader_AST;
+}
+
+void PascalParser::qualifiedMethodIdentifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST qualifiedMethodIdentifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ match(COLON);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ qualifiedMethodIdentifier_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_28);
+ } else {
+ throw;
+ }
+ }
+ returnAST = qualifiedMethodIdentifier_AST;
+}
+
+void PascalParser::formalParameterList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST formalParameterList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LPAREN);
+ parameterDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ parameterDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop96;
+ }
+
+ }
+ _loop96:;
+ } // ( ... )*
+ match(RPAREN);
+ formalParameterList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_29);
+ } else {
+ throw;
+ }
+ }
+ returnAST = formalParameterList_AST;
+}
+
+void PascalParser::modifiers() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST modifiers_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PUBLIC:
+ {
+ match(PUBLIC);
+ modifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case ALIAS:
+ {
+ {
+ match(ALIAS);
+ stringConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ modifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case INTERRUPT:
+ {
+ match(INTERRUPT);
+ modifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case REGISTER:
+ case PASCAL:
+ case CDECL:
+ case STDCALL:
+ case POPSTACK:
+ case SAVEREGISTERS:
+ case INLINE:
+ case SAFECALL:
+ case NEAR:
+ case FAR:
+ {
+ callModifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ modifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case EXPORT:
+ {
+ match(EXPORT);
+ modifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = modifiers_AST;
+}
+
+void PascalParser::externalDirective() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST externalDirective_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp90_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp90_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp90_AST));
+ }
+ match(EXTERNAL);
+ {
+ switch ( LA(1)) {
+ case STRING_LITERAL:
+ case CHR:
+ {
+ stringConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_name:
+ {
+ {
+ RefPascalAST tmp91_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp91_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp91_AST));
+ }
+ match(LITERAL_name);
+ stringConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ break;
+ }
+ case LITERAL_index:
+ {
+ {
+ RefPascalAST tmp92_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp92_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp92_AST));
+ }
+ match(LITERAL_index);
+ integerConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ break;
+ }
+ case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
+ case SEMI:
+ case END:
+ case EXPORTS:
+ case BEGIN:
+ case INITIALIZATION:
+ case LABEL:
+ case CONST:
+ case RESOURCESTRING:
+ case TYPE:
+ case VAR:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE:
+ case SEMI:
+ case END:
+ case EXPORTS:
+ case BEGIN:
+ case INITIALIZATION:
+ case LABEL:
+ case CONST:
+ case RESOURCESTRING:
+ case TYPE:
+ case VAR:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ externalDirective_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_27);
+ } else {
+ throw;
+ }
+ }
+ returnAST = externalDirective_AST;
+}
+
+void PascalParser::functionHeaderEnding() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST functionHeaderEnding_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case COLON:
+ {
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop91;
+ }
+
+ }
+ _loop91:;
+ } // ( ... )*
+ functionHeaderEnding_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LPAREN:
+ {
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PUBLIC && LA(1) <= FAR))) {
+ modifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ }
+ else {
+ goto _loop93;
+ }
+
+ }
+ _loop93:;
+ } // ( ... )*
+ functionHeaderEnding_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = functionHeaderEnding_AST;
+}
+
+void PascalParser::parameterDeclaration() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST parameterDeclaration_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ valueParameter();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ parameterDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case VAR:
+ {
+ variableParameter();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ parameterDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CONST:
+ {
+ constantParameter();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ parameterDeclaration_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_30);
+ } else {
+ throw;
+ }
+ }
+ returnAST = parameterDeclaration_AST;
+}
+
+void PascalParser::valueParameter() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST valueParameter_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched100 = false;
+ if (((LA(1) == IDENT) && (LA(2) == COMMA || LA(2) == COLON))) {
+ int _m100 = mark();
+ synPredMatched100 = true;
+ inputState->guessing++;
+ try {
+ {
+ identifierList();
+ match(COLON);
+ match(ARRAY);
+ match(OF);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched100 = false;
+ }
+ rewind(_m100);
+ inputState->guessing--;
+ }
+ if ( synPredMatched100 ) {
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ match(ARRAY);
+ match(OF);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ valueParameter_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == COMMA || LA(2) == COLON)) {
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ valueParameter_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_30);
+ } else {
+ throw;
+ }
+ }
+ returnAST = valueParameter_AST;
+}
+
+void PascalParser::variableParameter() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST variableParameter_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp103_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp103_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp103_AST));
+ }
+ match(VAR);
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case COLON:
+ {
+ untypedParameterPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ variableParameter_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_30);
+ } else {
+ throw;
+ }
+ }
+ returnAST = variableParameter_AST;
+}
+
+void PascalParser::constantParameter() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constantParameter_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp104_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp104_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp104_AST));
+ }
+ match(CONST);
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case COLON:
+ {
+ untypedParameterPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case RPAREN:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ constantParameter_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_30);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constantParameter_AST;
+}
+
+void PascalParser::untypedParameterPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST untypedParameterPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched105 = false;
+ if (((LA(1) == COLON) && (LA(2) == ARRAY))) {
+ int _m105 = mark();
+ synPredMatched105 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(COLON);
+ match(ARRAY);
+ match(OF);
+ type();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched105 = false;
+ }
+ rewind(_m105);
+ inputState->guessing--;
+ }
+ if ( synPredMatched105 ) {
+ match(COLON);
+ match(ARRAY);
+ match(OF);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ untypedParameterPart_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == COLON) && (_tokenSet_31.member(LA(2)))) {
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ untypedParameterPart_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_30);
+ } else {
+ throw;
+ }
+ }
+ returnAST = untypedParameterPart_AST;
+}
+
+void PascalParser::callModifiers() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST callModifiers_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case REGISTER:
+ {
+ match(REGISTER);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PASCAL:
+ {
+ match(PASCAL);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CDECL:
+ {
+ match(CDECL);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case STDCALL:
+ {
+ match(STDCALL);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case POPSTACK:
+ {
+ match(POPSTACK);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case SAVEREGISTERS:
+ {
+ match(SAVEREGISTERS);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case INLINE:
+ {
+ match(INLINE);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case SAFECALL:
+ {
+ match(SAFECALL);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NEAR:
+ {
+ match(NEAR);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case FAR:
+ {
+ match(FAR);
+ callModifiers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = callModifiers_AST;
+}
+
+void PascalParser::expression() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST expression_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ simpleExpression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case EQUAL:
+ case LE:
+ case GE:
+ case LTH:
+ case GT:
+ case NOT_EQUAL:
+ case IN:
+ case IS:
+ {
+ expressionSign();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleExpression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DOT:
+ case SEMI:
+ case END:
+ case COMMA:
+ case RPAREN:
+ case FINALIZATION:
+ case OF:
+ case DOTDOT:
+ case RBRACK:
+ case THEN:
+ case ELSE:
+ case DO:
+ case UNTIL:
+ case TO:
+ case DOWNTO:
+ case RBRACK2:
+ case EXCEPT:
+ case FINALLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ expression_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_32);
+ } else {
+ throw;
+ }
+ }
+ returnAST = expression_AST;
+}
+
+void PascalParser::typedConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST typedConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched120 = false;
+ if (((_tokenSet_33.member(LA(1))) && (_tokenSet_34.member(LA(2))))) {
+ int _m120 = mark();
+ synPredMatched120 = true;
+ inputState->guessing++;
+ try {
+ {
+ constant();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched120 = false;
+ }
+ rewind(_m120);
+ inputState->guessing--;
+ }
+ if ( synPredMatched120 ) {
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ typedConstant_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched122 = false;
+ if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
+ int _m122 = mark();
+ synPredMatched122 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(LPAREN);
+ identifier();
+ match(COLON);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched122 = false;
+ }
+ rewind(_m122);
+ inputState->guessing--;
+ }
+ if ( synPredMatched122 ) {
+ recordConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ typedConstant_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched124 = false;
+ if (((LA(1) == LPAREN) && (_tokenSet_35.member(LA(2))))) {
+ int _m124 = mark();
+ synPredMatched124 = true;
+ inputState->guessing++;
+ try {
+ {
+ arrayConstant();
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched124 = false;
+ }
+ rewind(_m124);
+ inputState->guessing--;
+ }
+ if ( synPredMatched124 ) {
+ arrayConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ typedConstant_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((_tokenSet_36.member(LA(1))) && (_tokenSet_37.member(LA(2)))) {
+ proceduralConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ typedConstant_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }}
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = typedConstant_AST;
+}
+
+void PascalParser::constant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefPascalAST s_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefPascalAST n_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefPascalAST s2_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ RefPascalAST id_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case NUM_INT:
+ case NUM_REAL:
+ {
+ unsignedNumber();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case IDENT:
+ {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case STRING_LITERAL:
+ {
+ string();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CHR:
+ {
+ constantChr();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ if ((LA(1) == PLUS || LA(1) == MINUS) && (LA(2) == NUM_INT || LA(2) == NUM_REAL)) {
+ sign();
+ if (inputState->guessing==0) {
+ s_AST = returnAST;
+ }
+ unsignedNumber();
+ if (inputState->guessing==0) {
+ n_AST = returnAST;
+ }
+ if ( inputState->guessing==0 ) {
+ constant_AST = RefPascalAST(currentAST.root);
+#line 901 "pascal.g"
+ constant_AST=RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(n_AST))));
+#line 3461 "PascalParser.cpp"
+ currentAST.root = constant_AST;
+ if ( constant_AST!=RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ constant_AST->getFirstChild() != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = constant_AST->getFirstChild();
+ else
+ currentAST.child = constant_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else if ((LA(1) == PLUS || LA(1) == MINUS) && (LA(2) == IDENT)) {
+ sign();
+ if (inputState->guessing==0) {
+ s2_AST = returnAST;
+ }
+ identifier();
+ if (inputState->guessing==0) {
+ id_AST = returnAST;
+ }
+ if ( inputState->guessing==0 ) {
+ constant_AST = RefPascalAST(currentAST.root);
+#line 903 "pascal.g"
+ constant_AST=RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(s2_AST))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(id_AST))));
+#line 3484 "PascalParser.cpp"
+ currentAST.root = constant_AST;
+ if ( constant_AST!=RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ constant_AST->getFirstChild() != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = constant_AST->getFirstChild();
+ else
+ currentAST.child = constant_AST;
+ currentAST.advanceChildToEnd();
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_38);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constant_AST;
+}
+
+void PascalParser::recordConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST recordConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LPAREN);
+ {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ }
+ else {
+ goto _loop134;
+ }
+
+ }
+ _loop134:;
+ } // ( ... )*
+ match(RPAREN);
+ recordConstant_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = recordConstant_AST;
+}
+
+void PascalParser::arrayConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST arrayConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LPAREN);
+ {
+ switch ( LA(1)) {
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case STRING_LITERAL:
+ case CHR:
+ case NUM_REAL:
+ case IDENT:
+ {
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case LPAREN:
+ {
+ arrayConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ {
+ switch ( LA(1)) {
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case STRING_LITERAL:
+ case CHR:
+ case NUM_REAL:
+ case IDENT:
+ {
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case LPAREN:
+ {
+ arrayConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ goto _loop129;
+ }
+
+ }
+ _loop129:;
+ } // ( ... )*
+ match(RPAREN);
+ arrayConstant_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_39);
+ } else {
+ throw;
+ }
+ }
+ returnAST = arrayConstant_AST;
+}
+
+void PascalParser::proceduralConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST proceduralConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ proceduralConstant_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = proceduralConstant_AST;
+}
+
+void PascalParser::addressConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST addressConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp127_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp127_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp127_AST));
+ }
+ match(NUM_INT);
+ addressConstant_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = addressConstant_AST;
+}
+
+void PascalParser::simpleType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST simpleType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case INTEGER:
+ case SHORTINT:
+ case SMALLINT:
+ case LONGINT:
+ case INT64:
+ case BYTE:
+ case WORD:
+ case CARDINAL:
+ case QWORD:
+ case BOOLEAN:
+ case BYTEBOOL:
+ case LONGBOOL:
+ case CHAR:
+ {
+ ordinalType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case REAL:
+ case SINGLE:
+ case DOUBLE:
+ case EXTENDED:
+ case COMP:
+ {
+ realType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = simpleType_AST;
+}
+
+void PascalParser::subrangeTypeOrTypeIdentifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST subrangeTypeOrTypeIdentifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case DOTDOT:
+ {
+ match(DOTDOT);
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case RPAREN:
+ case EQUAL:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ subrangeTypeOrTypeIdentifier_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = subrangeTypeOrTypeIdentifier_AST;
+}
+
+void PascalParser::enumeratedType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST enumeratedType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched147 = false;
+ if (((LA(1) == LPAREN) && (LA(2) == IDENT))) {
+ int _m147 = mark();
+ synPredMatched147 = true;
+ inputState->guessing++;
+ try {
+ {
+ match(LPAREN);
+ identifier();
+ match(ASSIGN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched147 = false;
+ }
+ rewind(_m147);
+ inputState->guessing--;
+ }
+ if ( synPredMatched147 ) {
+ match(LPAREN);
+ assignedEnumList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ enumeratedType_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == LPAREN) && (LA(2) == IDENT)) {
+ match(LPAREN);
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ enumeratedType_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } else {
+ throw;
+ }
+ }
+ returnAST = enumeratedType_AST;
+}
+
+void PascalParser::stringType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST stringType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp133_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp133_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp133_AST));
+ }
+ match(STRING);
+ {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ match(LBRACK);
+ unsignedInteger();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RBRACK);
+ break;
+ }
+ case SEMI:
+ case RPAREN:
+ case EQUAL:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ stringType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = stringType_AST;
+}
+
+void PascalParser::structuredType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST structuredType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case PACKED:
+ {
+ match(PACKED);
+ break;
+ }
+ case ARRAY:
+ case RECORD:
+ case SET:
+ case FILE:
+ case OBJECT:
+ case CLASS:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case ARRAY:
+ {
+ arrayType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RECORD:
+ {
+ recordType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case OBJECT:
+ {
+ objectType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case CLASS:
+ {
+ classType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SET:
+ {
+ setType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case FILE:
+ {
+ fileType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ structuredType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = structuredType_AST;
+}
+
+void PascalParser::pointerType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST pointerType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp137_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp137_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp137_AST));
+ }
+ match(POINTER);
+ typeIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ pointerType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = pointerType_AST;
+}
+
+void PascalParser::proceduralType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST proceduralType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched185 = false;
+ if (((LA(1) == PROCEDURE || LA(1) == FUNCTION) && (LA(2) == IDENT))) {
+ int _m185 = mark();
+ synPredMatched185 = true;
+ inputState->guessing++;
+ try {
+ {
+ proceduralTypePart1();
+ match(SEMI);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched185 = false;
+ }
+ rewind(_m185);
+ inputState->guessing--;
+ }
+ if ( synPredMatched185 ) {
+ proceduralTypePart1();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ callModifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ proceduralType_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == PROCEDURE || LA(1) == FUNCTION) && (LA(2) == IDENT)) {
+ proceduralTypePart1();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ proceduralType_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = proceduralType_AST;
+}
+
+void PascalParser::ordinalType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST ordinalType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case INTEGER:
+ {
+ match(INTEGER);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case SHORTINT:
+ {
+ match(SHORTINT);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case SMALLINT:
+ {
+ match(SMALLINT);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LONGINT:
+ {
+ match(LONGINT);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case INT64:
+ {
+ match(INT64);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case BYTE:
+ {
+ match(BYTE);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case WORD:
+ {
+ match(WORD);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CARDINAL:
+ {
+ match(CARDINAL);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case QWORD:
+ {
+ match(QWORD);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case BOOLEAN:
+ {
+ match(BOOLEAN);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case BYTEBOOL:
+ {
+ match(BYTEBOOL);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LONGBOOL:
+ {
+ match(LONGBOOL);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CHAR:
+ {
+ match(CHAR);
+ ordinalType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_40);
+ } else {
+ throw;
+ }
+ }
+ returnAST = ordinalType_AST;
+}
+
+void PascalParser::realType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST realType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case REAL:
+ {
+ match(REAL);
+ realType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case SINGLE:
+ {
+ match(SINGLE);
+ realType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case DOUBLE:
+ {
+ match(DOUBLE);
+ realType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case EXTENDED:
+ {
+ match(EXTENDED);
+ realType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case COMP:
+ {
+ match(COMP);
+ realType_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = realType_AST;
+}
+
+void PascalParser::typeIdentifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST typeIdentifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ typeIdentifier_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_41);
+ } else {
+ throw;
+ }
+ }
+ returnAST = typeIdentifier_AST;
+}
+
+void PascalParser::subrangeType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST subrangeType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DOTDOT);
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ subrangeType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = subrangeType_AST;
+}
+
+void PascalParser::assignedEnumList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST assignedEnumList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(ASSIGN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(ASSIGN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ }
+ else {
+ goto _loop152;
+ }
+
+ }
+ _loop152:;
+ } // ( ... )*
+ assignedEnumList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_42);
+ } else {
+ throw;
+ }
+ }
+ returnAST = assignedEnumList_AST;
+}
+
+void PascalParser::unsignedInteger() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST unsignedInteger_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp161_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp161_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp161_AST));
+ }
+ match(NUM_INT);
+ unsignedInteger_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_43);
+ } else {
+ throw;
+ }
+ }
+ returnAST = unsignedInteger_AST;
+}
+
+void PascalParser::arrayType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST arrayType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp162_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp162_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp162_AST));
+ }
+ match(ARRAY);
+ match(LBRACK);
+ arrayIndexType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ arrayIndexType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop161;
+ }
+
+ }
+ _loop161:;
+ } // ( ... )*
+ match(RBRACK);
+ match(OF);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ arrayType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = arrayType_AST;
+}
+
+void PascalParser::recordType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST recordType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp167_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp167_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp167_AST));
+ }
+ match(RECORD);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == CASE || LA(1) == IDENT)) {
+ fieldList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop168;
+ }
+
+ }
+ _loop168:;
+ } // ( ... )*
+ match(END);
+ recordType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = recordType_AST;
+}
+
+void PascalParser::objectType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST objectType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp169_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp169_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp169_AST));
+ }
+ match(OBJECT);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ heritage();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case PUBLIC:
+ case PRIVATE:
+ case PROTECTED:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case IDENT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case IDENT:
+ {
+ componentList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PUBLIC:
+ case PRIVATE:
+ case PROTECTED:
+ {
+ objectVisibilitySpecifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(END);
+ objectType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = objectType_AST;
+}
+
+void PascalParser::classType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST classType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp171_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp171_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp171_AST));
+ }
+ match(CLASS);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ heritage();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case PUBLIC:
+ case PRIVATE:
+ case PROTECTED:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PUBLISHED:
+ case PROPERTY:
+ case IDENT:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ case IDENT:
+ {
+ classComponentList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PUBLIC:
+ case PRIVATE:
+ case PROTECTED:
+ case PUBLISHED:
+ {
+ classVisibilitySpecifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(END);
+ classType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = classType_AST;
+}
+
+void PascalParser::setType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST setType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp173_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp173_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp173_AST));
+ }
+ match(SET);
+ match(OF);
+ ordinalType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ setType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = setType_AST;
+}
+
+void PascalParser::fileType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST fileType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp175_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp175_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp175_AST));
+ }
+ match(FILE);
+ match(OF);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ fileType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = fileType_AST;
+}
+
+void PascalParser::arrayIndexType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST arrayIndexType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if (((LA(1) >= INTEGER && LA(1) <= CHAR))) {
+ ordinalType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ arrayIndexType_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched164 = false;
+ if (((_tokenSet_36.member(LA(1))) && (_tokenSet_44.member(LA(2))))) {
+ int _m164 = mark();
+ synPredMatched164 = true;
+ inputState->guessing++;
+ try {
+ {
+ expression();
+ match(DOTDOT);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched164 = false;
+ }
+ rewind(_m164);
+ inputState->guessing--;
+ }
+ if ( synPredMatched164 ) {
+ arraySubrangeType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ arrayIndexType_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == LPAREN) && (LA(2) == IDENT)) {
+ enumeratedType();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ arrayIndexType_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_45);
+ } else {
+ throw;
+ }
+ }
+ returnAST = arrayIndexType_AST;
+}
+
+void PascalParser::arraySubrangeType() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST arraySubrangeType_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DOTDOT);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ arraySubrangeType_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_45);
+ } else {
+ throw;
+ }
+ }
+ returnAST = arraySubrangeType_AST;
+}
+
+void PascalParser::fieldList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST fieldList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ fixedField();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ fieldList_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CASE:
+ {
+ variantPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ fieldList_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_46);
+ } else {
+ throw;
+ }
+ }
+ returnAST = fieldList_AST;
+}
+
+void PascalParser::fixedField() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST fixedField_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ fixedField_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_46);
+ } else {
+ throw;
+ }
+ }
+ returnAST = fixedField_AST;
+}
+
+void PascalParser::variantPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST variantPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp180_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp180_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp180_AST));
+ }
+ match(CASE);
+ {
+ if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == OF)) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(OF);
+ variant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ variant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop174;
+ }
+
+ }
+ _loop174:;
+ } // ( ... )*
+ variantPart_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_46);
+ } else {
+ throw;
+ }
+ }
+ returnAST = variantPart_AST;
+}
+
+void PascalParser::variant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST variant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ { // ( ... )+
+ int _cnt177=0;
+ for (;;) {
+ if ((_tokenSet_33.member(LA(1)))) {
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COMMA);
+ }
+ else {
+ if ( _cnt177>=1 ) { goto _loop177; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt177++;
+ }
+ _loop177:;
+ } // ( ... )+
+ match(COLON);
+ match(LPAREN);
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == CASE || LA(1) == IDENT)) {
+ fieldList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop179;
+ }
+
+ }
+ _loop179:;
+ } // ( ... )*
+ match(RPAREN);
+ variant_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_47);
+ } else {
+ throw;
+ }
+ }
+ returnAST = variant_AST;
+}
+
+void PascalParser::proceduralTypePart1() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST proceduralTypePart1_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case FUNCTION:
+ {
+ functionHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ {
+ procedureHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case OF:
+ {
+ match(OF);
+ match(OBJECT);
+ break;
+ }
+ case SEMI:
+ case RPAREN:
+ case EQUAL:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ proceduralTypePart1_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_23);
+ } else {
+ throw;
+ }
+ }
+ returnAST = proceduralTypePart1_AST;
+}
+
+void PascalParser::heritage() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST heritage_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LPAREN);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ heritage_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_48);
+ } else {
+ throw;
+ }
+ }
+ returnAST = heritage_AST;
+}
+
+void PascalParser::componentList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST componentList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ { // ( ... )+
+ int _cnt196=0;
+ for (;;) {
+ if ((LA(1) == IDENT)) {
+ fieldDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt196>=1 ) { goto _loop196; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt196++;
+ }
+ _loop196:;
+ } // ( ... )+
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ { // ( ... )+
+ int _cnt199=0;
+ for (;;) {
+ if ((_tokenSet_49.member(LA(1)))) {
+ methodDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt199>=1 ) { goto _loop199; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt199++;
+ }
+ _loop199:;
+ } // ( ... )+
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ componentList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = componentList_AST;
+}
+
+void PascalParser::objectVisibilitySpecifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST objectVisibilitySpecifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ objectVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PROTECTED:
+ {
+ match(PROTECTED);
+ objectVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PUBLIC:
+ {
+ match(PUBLIC);
+ objectVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = objectVisibilitySpecifier_AST;
+}
+
+void PascalParser::fieldDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST fieldDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifierList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ fieldDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_50);
+ } else {
+ throw;
+ }
+ }
+ returnAST = fieldDefinition_AST;
+}
+
+void PascalParser::methodDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST methodDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case FUNCTION:
+ {
+ functionHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ {
+ procedureHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case CONSTRUCTOR:
+ {
+ constructorHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DESTRUCTOR:
+ {
+ destructorHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ methodDirectives();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ methodDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_51);
+ } else {
+ throw;
+ }
+ }
+ returnAST = methodDefinition_AST;
+}
+
+void PascalParser::constructorHeader() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constructorHeader_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp198_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp198_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp198_AST));
+ }
+ match(CONSTRUCTOR);
+ {
+ if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+ qualifiedMethodIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ constructorHeader_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constructorHeader_AST;
+}
+
+void PascalParser::destructorHeader() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST destructorHeader_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp199_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp199_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp199_AST));
+ }
+ match(DESTRUCTOR);
+ {
+ if ((LA(1) == IDENT) && (LA(2) == LPAREN)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+ qualifiedMethodIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ destructorHeader_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = destructorHeader_AST;
+}
+
+void PascalParser::methodDirectives() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST methodDirectives_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case VIRTUAL:
+ {
+ match(VIRTUAL);
+ match(SEMI);
+ {
+ switch ( LA(1)) {
+ case ABSTRACT:
+ {
+ match(ABSTRACT);
+ match(SEMI);
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case REGISTER:
+ case PASCAL:
+ case CDECL:
+ case STDCALL:
+ case POPSTACK:
+ case SAVEREGISTERS:
+ case INLINE:
+ case SAFECALL:
+ case NEAR:
+ case FAR:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case REGISTER:
+ case PASCAL:
+ case CDECL:
+ case STDCALL:
+ case POPSTACK:
+ case SAVEREGISTERS:
+ case INLINE:
+ case SAFECALL:
+ case NEAR:
+ case FAR:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case REGISTER:
+ case PASCAL:
+ case CDECL:
+ case STDCALL:
+ case POPSTACK:
+ case SAVEREGISTERS:
+ case INLINE:
+ case SAFECALL:
+ case NEAR:
+ case FAR:
+ {
+ callModifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ methodDirectives_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_51);
+ } else {
+ throw;
+ }
+ }
+ returnAST = methodDirectives_AST;
+}
+
+void PascalParser::classComponentList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST classComponentList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ { // ( ... )+
+ int _cnt220=0;
+ for (;;) {
+ if ((LA(1) == IDENT)) {
+ fieldDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ if ( _cnt220>=1 ) { goto _loop220; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt220++;
+ }
+ _loop220:;
+ } // ( ... )+
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ {
+ { // ( ... )+
+ int _cnt224=0;
+ for (;;) {
+ if ((_tokenSet_52.member(LA(1)))) {
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ {
+ classMethodDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROPERTY:
+ {
+ propertyDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ if ( _cnt224>=1 ) { goto _loop224; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());}
+ }
+
+ _cnt224++;
+ }
+ _loop224:;
+ } // ( ... )+
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ classComponentList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = classComponentList_AST;
+}
+
+void PascalParser::classVisibilitySpecifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST classVisibilitySpecifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PRIVATE:
+ {
+ match(PRIVATE);
+ classVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PROTECTED:
+ {
+ match(PROTECTED);
+ classVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PUBLIC:
+ {
+ match(PUBLIC);
+ classVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PUBLISHED:
+ {
+ match(PUBLISHED);
+ classVisibilitySpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = classVisibilitySpecifier_AST;
+}
+
+void PascalParser::classMethodDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST classMethodDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case PROCEDURE:
+ case FUNCTION:
+ case CLASS:
+ {
+ {
+ {
+ switch ( LA(1)) {
+ case CLASS:
+ {
+ match(CLASS);
+ break;
+ }
+ case PROCEDURE:
+ case FUNCTION:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case FUNCTION:
+ {
+ functionHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PROCEDURE:
+ {
+ procedureHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ break;
+ }
+ case CONSTRUCTOR:
+ {
+ constructorHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case DESTRUCTOR:
+ {
+ destructorHeader();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(SEMI);
+ classMethodDirectives();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ classMethodDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_53);
+ } else {
+ throw;
+ }
+ }
+ returnAST = classMethodDefinition_AST;
+}
+
+void PascalParser::propertyDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST propertyDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp211_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp211_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp211_AST));
+ }
+ match(PROPERTY);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case COLON:
+ case LBRACK:
+ {
+ propertyInterface();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ case LITERAL_read:
+ case LITERAL_write:
+ case DEFAULT:
+ case LITERAL_nodefault:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ propertySpecifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ propertyDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_53);
+ } else {
+ throw;
+ }
+ }
+ returnAST = propertyDefinition_AST;
+}
+
+void PascalParser::classMethodDirectives() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST classMethodDirectives_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case VIRTUAL:
+ case OVERRIDE:
+ case MESSAGE:
+ {
+ directiveVariants();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case REGISTER:
+ case PASCAL:
+ case CDECL:
+ case STDCALL:
+ case POPSTACK:
+ case SAVEREGISTERS:
+ case INLINE:
+ case SAFECALL:
+ case NEAR:
+ case FAR:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case REGISTER:
+ case PASCAL:
+ case CDECL:
+ case STDCALL:
+ case POPSTACK:
+ case SAVEREGISTERS:
+ case INLINE:
+ case SAFECALL:
+ case NEAR:
+ case FAR:
+ {
+ callModifiers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ classMethodDirectives_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_53);
+ } else {
+ throw;
+ }
+ }
+ returnAST = classMethodDirectives_AST;
+}
+
+void PascalParser::directiveVariants() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST directiveVariants_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case VIRTUAL:
+ {
+ {
+ match(VIRTUAL);
+ {
+ switch ( LA(1)) {
+ case ABSTRACT:
+ {
+ match(ABSTRACT);
+ match(SEMI);
+ break;
+ }
+ case SEMI:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ directiveVariants_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case OVERRIDE:
+ {
+ match(OVERRIDE);
+ directiveVariants_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case MESSAGE:
+ {
+ {
+ match(MESSAGE);
+ {
+ switch ( LA(1)) {
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ {
+ integerConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case STRING_LITERAL:
+ case CHR:
+ {
+ stringConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ directiveVariants_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_22);
+ } else {
+ throw;
+ }
+ }
+ returnAST = directiveVariants_AST;
+}
+
+void PascalParser::propertyInterface() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST propertyInterface_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ propertyParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case COLON:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(COLON);
+ typeIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_index:
+ {
+ RefPascalAST tmp220_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp220_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp220_AST));
+ }
+ match(LITERAL_index);
+ integerConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ case LITERAL_read:
+ case LITERAL_write:
+ case DEFAULT:
+ case LITERAL_nodefault:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ propertyInterface_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_54);
+ } else {
+ throw;
+ }
+ }
+ returnAST = propertyInterface_AST;
+}
+
+void PascalParser::propertySpecifiers() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST propertySpecifiers_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case LITERAL_read:
+ {
+ readSpecifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ case LITERAL_write:
+ case DEFAULT:
+ case LITERAL_nodefault:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case LITERAL_write:
+ {
+ writeSpecifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ case DEFAULT:
+ case LITERAL_nodefault:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ {
+ switch ( LA(1)) {
+ case DEFAULT:
+ case LITERAL_nodefault:
+ {
+ defaultSpecifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ propertySpecifiers_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_53);
+ } else {
+ throw;
+ }
+ }
+ returnAST = propertySpecifiers_AST;
+}
+
+void PascalParser::propertyParameterList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST propertyParameterList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LBRACK);
+ parameterDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ parameterDeclaration();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop246;
+ }
+
+ }
+ _loop246:;
+ } // ( ... )*
+ match(RBRACK);
+ propertyParameterList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_55);
+ } else {
+ throw;
+ }
+ }
+ returnAST = propertyParameterList_AST;
+}
+
+void PascalParser::readSpecifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST readSpecifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp224_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp224_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp224_AST));
+ }
+ match(LITERAL_read);
+ fieldOrMethod();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ readSpecifier_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_56);
+ } else {
+ throw;
+ }
+ }
+ returnAST = readSpecifier_AST;
+}
+
+void PascalParser::writeSpecifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST writeSpecifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp225_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp225_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp225_AST));
+ }
+ match(LITERAL_write);
+ fieldOrMethod();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ writeSpecifier_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_57);
+ } else {
+ throw;
+ }
+ }
+ returnAST = writeSpecifier_AST;
+}
+
+void PascalParser::defaultSpecifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST defaultSpecifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case DEFAULT:
+ {
+ {
+ RefPascalAST tmp226_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp226_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp226_AST));
+ }
+ match(DEFAULT);
+ {
+ switch ( LA(1)) {
+ case NUM_INT:
+ case PLUS:
+ case MINUS:
+ case STRING_LITERAL:
+ case CHR:
+ case NUM_REAL:
+ case IDENT:
+ {
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ case PROCEDURE:
+ case FUNCTION:
+ case CONSTRUCTOR:
+ case DESTRUCTOR:
+ case CLASS:
+ case PROPERTY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ defaultSpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LITERAL_nodefault:
+ {
+ RefPascalAST tmp227_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp227_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp227_AST));
+ }
+ match(LITERAL_nodefault);
+ defaultSpecifier_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_53);
+ } else {
+ throw;
+ }
+ }
+ returnAST = defaultSpecifier_AST;
+}
+
+void PascalParser::fieldOrMethod() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST fieldOrMethod_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ fieldOrMethod_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_56);
+ } else {
+ throw;
+ }
+ }
+ returnAST = fieldOrMethod_AST;
+}
+
+void PascalParser::simpleExpression() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST simpleExpression_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= PLUS && LA(1) <= XOR))) {
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ match(PLUS);
+ break;
+ }
+ case MINUS:
+ {
+ match(MINUS);
+ break;
+ }
+ case OR:
+ {
+ match(OR);
+ break;
+ }
+ case XOR:
+ {
+ match(XOR);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ term();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop263;
+ }
+
+ }
+ _loop263:;
+ } // ( ... )*
+ simpleExpression_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_58);
+ } else {
+ throw;
+ }
+ }
+ returnAST = simpleExpression_AST;
+}
+
+void PascalParser::expressionSign() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST expressionSign_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case LE:
+ {
+ match(LE);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case GE:
+ {
+ match(GE);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LTH:
+ {
+ match(LTH);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case GT:
+ {
+ match(GT);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NOT_EQUAL:
+ {
+ match(NOT_EQUAL);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case IN:
+ {
+ match(IN);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case IS:
+ {
+ match(IS);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case EQUAL:
+ {
+ match(EQUAL);
+ expressionSign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_36);
+ } else {
+ throw;
+ }
+ }
+ returnAST = expressionSign_AST;
+}
+
+void PascalParser::term() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST term_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if (((LA(1) >= STAR && LA(1) <= SHR))) {
+ {
+ switch ( LA(1)) {
+ case STAR:
+ {
+ match(STAR);
+ break;
+ }
+ case SLASH:
+ {
+ match(SLASH);
+ break;
+ }
+ case DIV:
+ {
+ match(DIV);
+ break;
+ }
+ case MOD:
+ {
+ match(MOD);
+ break;
+ }
+ case AND:
+ {
+ match(AND);
+ break;
+ }
+ case SHL:
+ {
+ match(SHL);
+ break;
+ }
+ case SHR:
+ {
+ match(SHR);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop267;
+ }
+
+ }
+ _loop267:;
+ } // ( ... )*
+ term_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_59);
+ } else {
+ throw;
+ }
+ }
+ returnAST = term_AST;
+}
+
+void PascalParser::factor() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST factor_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ {
+ match(LPAREN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NUM_INT:
+ case STRING_LITERAL:
+ case CHR:
+ case NIL:
+ case NUM_REAL:
+ {
+ unsignedConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NOT:
+ {
+ {
+ match(NOT);
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PLUS:
+ case MINUS:
+ {
+ {
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ match(PLUS);
+ break;
+ }
+ case MINUS:
+ {
+ match(MINUS);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ factor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case LBRACK:
+ {
+ setConstructor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case AT:
+ {
+ addressFactor();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case TRUE:
+ {
+ RefPascalAST tmp252_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp252_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp252_AST));
+ }
+ match(TRUE);
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case FALSE:
+ {
+ RefPascalAST tmp253_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp253_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp253_AST));
+ }
+ match(FALSE);
+ factor_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ if ((LA(1) == IDENT) && (_tokenSet_60.member(LA(2)))) {
+ identifierOrValueTypecastOrFunctionCall();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ factor_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == LBRACK)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(LBRACK);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop274;
+ }
+
+ }
+ _loop274:;
+ } // ( ... )*
+ match(RBRACK);
+ factor_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_61);
+ } else {
+ throw;
+ }
+ }
+ returnAST = factor_AST;
+}
+
+void PascalParser::identifierOrValueTypecastOrFunctionCall() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST identifierOrValueTypecastOrFunctionCall_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ bool synPredMatched277 = false;
+ if (((LA(1) == IDENT) && (LA(2) == LPAREN))) {
+ int _m277 = mark();
+ synPredMatched277 = true;
+ inputState->guessing++;
+ try {
+ {
+ identifier();
+ match(LPAREN);
+ expression();
+ match(COMMA);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched277 = false;
+ }
+ rewind(_m277);
+ inputState->guessing--;
+ }
+ if ( synPredMatched277 ) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(LPAREN);
+ expressions();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ identifierOrValueTypecastOrFunctionCall_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ bool synPredMatched279 = false;
+ if (((LA(1) == IDENT) && (LA(2) == LPAREN))) {
+ int _m279 = mark();
+ synPredMatched279 = true;
+ inputState->guessing++;
+ try {
+ {
+ identifier();
+ match(LPAREN);
+ expression();
+ match(RPAREN);
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& pe) {
+ synPredMatched279 = false;
+ }
+ rewind(_m279);
+ inputState->guessing--;
+ }
+ if ( synPredMatched279 ) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(LPAREN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ identifierOrValueTypecastOrFunctionCall_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENT) && (_tokenSet_61.member(LA(2)))) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ identifierOrValueTypecastOrFunctionCall_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_61);
+ } else {
+ throw;
+ }
+ }
+ returnAST = identifierOrValueTypecastOrFunctionCall_AST;
+}
+
+void PascalParser::unsignedConstant() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST unsignedConstant_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case NUM_INT:
+ case NUM_REAL:
+ {
+ unsignedNumber();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ unsignedConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CHR:
+ {
+ constantChr();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ unsignedConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case STRING_LITERAL:
+ {
+ string();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ unsignedConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NIL:
+ {
+ match(NIL);
+ unsignedConstant_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_61);
+ } else {
+ throw;
+ }
+ }
+ returnAST = unsignedConstant_AST;
+}
+
+void PascalParser::setConstructor() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST setConstructor_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LBRACK);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ case NUM_INT:
+ case LBRACK:
+ case PLUS:
+ case MINUS:
+ case NOT:
+ case TRUE:
+ case FALSE:
+ case AT:
+ case STRING_LITERAL:
+ case CHR:
+ case NIL:
+ case NUM_REAL:
+ case IDENT:
+ {
+ setGroup();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ setGroup();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop290;
+ }
+
+ }
+ _loop290:;
+ } // ( ... )*
+ break;
+ }
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(RBRACK);
+ setConstructor_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_61);
+ } else {
+ throw;
+ }
+ }
+ returnAST = setConstructor_AST;
+}
+
+void PascalParser::addressFactor() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST addressFactor_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(AT);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ addressFactor_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_61);
+ } else {
+ throw;
+ }
+ }
+ returnAST = addressFactor_AST;
+}
+
+void PascalParser::expressions() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST expressions_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop286;
+ }
+
+ }
+ _loop286:;
+ } // ( ... )*
+ expressions_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_42);
+ } else {
+ throw;
+ }
+ }
+ returnAST = expressions_AST;
+}
+
+void PascalParser::functionCall() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST functionCall_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ actualParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ case FINALIZATION:
+ case AT:
+ case ELSE:
+ case UNTIL:
+ case EXCEPT:
+ case FINALLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ functionCall_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_62);
+ } else {
+ throw;
+ }
+ }
+ returnAST = functionCall_AST;
+}
+
+void PascalParser::actualParameterList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST actualParameterList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(LPAREN);
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ case NUM_INT:
+ case LBRACK:
+ case PLUS:
+ case MINUS:
+ case NOT:
+ case TRUE:
+ case FALSE:
+ case AT:
+ case STRING_LITERAL:
+ case CHR:
+ case NIL:
+ case NUM_REAL:
+ case IDENT:
+ {
+ expressions();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case RPAREN:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(RPAREN);
+ actualParameterList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_62);
+ } else {
+ throw;
+ }
+ }
+ returnAST = actualParameterList_AST;
+}
+
+void PascalParser::setGroup() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST setGroup_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case DOT:
+ {
+ match(DOT);
+ match(DOT);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case COMMA:
+ case RBRACK:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ setGroup_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_45);
+ } else {
+ throw;
+ }
+ }
+ returnAST = setGroup_AST;
+}
+
+void PascalParser::valueTypecast() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST valueTypecast_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ typeIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(LPAREN);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ valueTypecast_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = valueTypecast_AST;
+}
+
+void PascalParser::simpleStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST simpleStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case GOTO:
+ {
+ gotoStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case RAISE:
+ {
+ raiseStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ if ((LA(1) == IDENT) && (_tokenSet_63.member(LA(2)))) {
+ assignmentStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleStatement_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENT) && (_tokenSet_64.member(LA(2)))) {
+ procedureStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ simpleStatement_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = simpleStatement_AST;
+}
+
+void PascalParser::structuredStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST structuredStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case BEGIN:
+ {
+ compoundStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ structuredStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ {
+ repetitiveStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ structuredStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CASE:
+ case IF:
+ {
+ conditionalStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ structuredStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case TRY:
+ {
+ exceptionStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ structuredStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case WITH:
+ {
+ withStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ structuredStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = structuredStatement_AST;
+}
+
+void PascalParser::assignmentStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST assignmentStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifierOrArrayIdentifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ assignmentOperator();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ assignmentStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = assignmentStatement_AST;
+}
+
+void PascalParser::procedureStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST procedureStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case LPAREN:
+ {
+ actualParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ case FINALIZATION:
+ case ELSE:
+ case UNTIL:
+ case EXCEPT:
+ case FINALLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ procedureStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = procedureStatement_AST;
+}
+
+void PascalParser::gotoStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST gotoStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(GOTO);
+ label();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ gotoStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = gotoStatement_AST;
+}
+
+void PascalParser::raiseStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST raiseStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp274_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp274_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp274_AST));
+ }
+ match(RAISE);
+ {
+ switch ( LA(1)) {
+ case IDENT:
+ {
+ functionCall();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case AT:
+ {
+ match(AT);
+ addressConstant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ case FINALIZATION:
+ case ELSE:
+ case UNTIL:
+ case EXCEPT:
+ case FINALLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ break;
+ }
+ case SEMI:
+ case END:
+ case FINALIZATION:
+ case ELSE:
+ case UNTIL:
+ case EXCEPT:
+ case FINALLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ raiseStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = raiseStatement_AST;
+}
+
+void PascalParser::identifierOrArrayIdentifier() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST identifierOrArrayIdentifier_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ if ((LA(1) == IDENT) && (_tokenSet_65.member(LA(2)))) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ identifierOrArrayIdentifier_AST = RefPascalAST(currentAST.root);
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == LBRACK)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(LBRACK);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop302;
+ }
+
+ }
+ _loop302:;
+ } // ( ... )*
+ match(RBRACK);
+ identifierOrArrayIdentifier_AST = RefPascalAST(currentAST.root);
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_65);
+ } else {
+ throw;
+ }
+ }
+ returnAST = identifierOrArrayIdentifier_AST;
+}
+
+void PascalParser::assignmentOperator() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST assignmentOperator_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ match(ASSIGN);
+ assignmentOperator_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case PLUSEQ:
+ {
+ RefPascalAST tmp280_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp280_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp280_AST));
+ }
+ match(PLUSEQ);
+ assignmentOperator_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case MINUSEQ:
+ {
+ RefPascalAST tmp281_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp281_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp281_AST));
+ }
+ match(MINUSEQ);
+ assignmentOperator_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case STAREQ:
+ {
+ RefPascalAST tmp282_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp282_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp282_AST));
+ }
+ match(STAREQ);
+ assignmentOperator_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case SLASHQE:
+ {
+ RefPascalAST tmp283_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp283_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp283_AST));
+ }
+ match(SLASHQE);
+ assignmentOperator_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_36);
+ } else {
+ throw;
+ }
+ }
+ returnAST = assignmentOperator_AST;
+}
+
+void PascalParser::repetitiveStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST repetitiveStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case FOR:
+ {
+ forStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ repetitiveStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case REPEAT:
+ {
+ repeatStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ repetitiveStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case WHILE:
+ {
+ whileStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ repetitiveStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = repetitiveStatement_AST;
+}
+
+void PascalParser::conditionalStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST conditionalStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case IF:
+ {
+ ifStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ conditionalStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case CASE:
+ {
+ caseStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ conditionalStatement_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = conditionalStatement_AST;
+}
+
+void PascalParser::exceptionStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exceptionStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ tryStatement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ exceptionStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exceptionStatement_AST;
+}
+
+void PascalParser::withStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST withStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp284_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp284_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp284_AST));
+ }
+ match(WITH);
+ recordVariableList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DO);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ withStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = withStatement_AST;
+}
+
+void PascalParser::ifStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST ifStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp286_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp286_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp286_AST));
+ }
+ match(IF);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(THEN);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ if ((LA(1) == ELSE) && (_tokenSet_24.member(LA(2)))) {
+ match(ELSE);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_66.member(LA(2)))) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ ifStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = ifStatement_AST;
+}
+
+void PascalParser::caseStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST caseStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp289_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp289_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp289_AST));
+ }
+ match(CASE);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(OF);
+ caseListElement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI) && (_tokenSet_33.member(LA(2)))) {
+ match(SEMI);
+ caseListElement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop320;
+ }
+
+ }
+ _loop320:;
+ } // ( ... )*
+ {
+ switch ( LA(1)) {
+ case SEMI:
+ {
+ match(SEMI);
+ match(ELSE);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop323;
+ }
+
+ }
+ _loop323:;
+ } // ( ... )*
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(END);
+ caseStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = caseStatement_AST;
+}
+
+void PascalParser::forStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST forStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp296_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp296_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp296_AST));
+ }
+ match(FOR);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(ASSIGN);
+ forList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DO);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ forStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = forStatement_AST;
+}
+
+void PascalParser::repeatStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST repeatStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp299_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp299_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp299_AST));
+ }
+ match(REPEAT);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ case NUM_INT:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case IDENT:
+ {
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case SEMI:
+ case UNTIL:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ }
+ else {
+ goto _loop332;
+ }
+
+ }
+ _loop332:;
+ } // ( ... )*
+ match(UNTIL);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ repeatStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = repeatStatement_AST;
+}
+
+void PascalParser::whileStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST whileStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp302_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp302_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp302_AST));
+ }
+ match(WHILE);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DO);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ whileStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = whileStatement_AST;
+}
+
+void PascalParser::caseListElement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST caseListElement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ constList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ RefPascalAST tmp304_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp304_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp304_AST));
+ }
+ match(COLON);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ caseListElement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_67);
+ } else {
+ throw;
+ }
+ }
+ returnAST = caseListElement_AST;
+}
+
+void PascalParser::constList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ constant();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop327;
+ }
+
+ }
+ _loop327:;
+ } // ( ... )*
+ if ( inputState->guessing==0 ) {
+ constList_AST = RefPascalAST(currentAST.root);
+#line 746 "pascal.g"
+ constList_AST = RefPascalAST(astFactory->make((new ANTLR_USE_NAMESPACE(antlr)ASTArray(2))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(astFactory->create(CONSTLIST)))->add(ANTLR_USE_NAMESPACE(antlr)RefAST(constList_AST))));
+#line 8219 "PascalParser.cpp"
+ currentAST.root = constList_AST;
+ if ( constList_AST!=RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) &&
+ constList_AST->getFirstChild() != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+ currentAST.child = constList_AST->getFirstChild();
+ else
+ currentAST.child = constList_AST;
+ currentAST.advanceChildToEnd();
+ }
+ constList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_55);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constList_AST;
+}
+
+void PascalParser::forList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST forList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ initialValue();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ {
+ switch ( LA(1)) {
+ case TO:
+ {
+ RefPascalAST tmp306_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp306_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp306_AST));
+ }
+ match(TO);
+ break;
+ }
+ case DOWNTO:
+ {
+ RefPascalAST tmp307_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp307_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp307_AST));
+ }
+ match(DOWNTO);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ finalValue();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ forList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_68);
+ } else {
+ throw;
+ }
+ }
+ returnAST = forList_AST;
+}
+
+void PascalParser::initialValue() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST initialValue_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ initialValue_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_69);
+ } else {
+ throw;
+ }
+ }
+ returnAST = initialValue_AST;
+}
+
+void PascalParser::finalValue() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST finalValue_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ finalValue_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_68);
+ } else {
+ throw;
+ }
+ }
+ returnAST = finalValue_AST;
+}
+
+void PascalParser::recordVariableList() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST recordVariableList_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ variable();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ variable();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop341;
+ }
+
+ }
+ _loop341:;
+ } // ( ... )*
+ recordVariableList_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_68);
+ } else {
+ throw;
+ }
+ }
+ returnAST = recordVariableList_AST;
+}
+
+/** A variable is an id with a suffix and can look like:
+ * id
+ * id[expr,...]
+ * id.id
+ * id.id[expr,...]
+ * id^
+ * id^.id
+ * id^.id[expr,...]
+ * ...
+ *
+ * LL has a really hard time with this construct as it's naturally
+ * left-recursive. We have to turn into a simple loop rather than
+ * recursive loop, hence, the suffixes. I keep in the same rule
+ * for easy tree construction.
+ */
+void PascalParser::variable() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST variable_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case AT:
+ {
+ RefPascalAST tmp309_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp309_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp309_AST));
+ }
+ match(AT);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case IDENT:
+ {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ { // ( ... )*
+ for (;;) {
+ switch ( LA(1)) {
+ case LBRACK:
+ {
+ RefPascalAST tmp310_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp310_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp310_AST));
+ }
+ match(LBRACK);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop346;
+ }
+
+ }
+ _loop346:;
+ } // ( ... )*
+ match(RBRACK);
+ break;
+ }
+ case LBRACK2:
+ {
+ RefPascalAST tmp313_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp313_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp313_AST));
+ }
+ match(LBRACK2);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == COMMA)) {
+ match(COMMA);
+ expression();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop348;
+ }
+
+ }
+ _loop348:;
+ } // ( ... )*
+ match(RBRACK2);
+ break;
+ }
+ case DOT:
+ {
+ RefPascalAST tmp316_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp316_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp316_AST));
+ }
+ match(DOT);
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case POINTER:
+ {
+ RefPascalAST tmp317_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp317_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp317_AST));
+ }
+ match(POINTER);
+ break;
+ }
+ default:
+ {
+ goto _loop349;
+ }
+ }
+ }
+ _loop349:;
+ } // ( ... )*
+ variable_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_70);
+ } else {
+ throw;
+ }
+ }
+ returnAST = variable_AST;
+}
+
+void PascalParser::operatorDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST operatorDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp318_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp318_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp318_AST));
+ }
+ match(OPERATOR);
+ {
+ switch ( LA(1)) {
+ case ASSIGN:
+ {
+ assignmentOperatorDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case PLUS:
+ case MINUS:
+ case STAR:
+ case SLASH:
+ {
+ arithmeticOperatorDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case EQUAL:
+ case LE:
+ case GE:
+ case LTH:
+ case GT:
+ {
+ comparisonOperatorDefinition();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ type();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(SEMI);
+ subroutineBlock();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ operatorDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_0);
+ } else {
+ throw;
+ }
+ }
+ returnAST = operatorDefinition_AST;
+}
+
+void PascalParser::assignmentOperatorDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST assignmentOperatorDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(ASSIGN);
+ match(LPAREN);
+ valueParameter();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ assignmentOperatorDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_71);
+ } else {
+ throw;
+ }
+ }
+ returnAST = assignmentOperatorDefinition_AST;
+}
+
+void PascalParser::arithmeticOperatorDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST arithmeticOperatorDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ match(PLUS);
+ break;
+ }
+ case MINUS:
+ {
+ match(MINUS);
+ break;
+ }
+ case SLASH:
+ {
+ match(SLASH);
+ break;
+ }
+ default:
+ if ((LA(1) == STAR) && (LA(2) == LPAREN)) {
+ match(STAR);
+ }
+ else if ((LA(1) == STAR) && (LA(2) == STAR)) {
+ {
+ match(STAR);
+ match(STAR);
+ }
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(LPAREN);
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ arithmeticOperatorDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_71);
+ } else {
+ throw;
+ }
+ }
+ returnAST = arithmeticOperatorDefinition_AST;
+}
+
+void PascalParser::comparisonOperatorDefinition() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST comparisonOperatorDefinition_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ {
+ switch ( LA(1)) {
+ case EQUAL:
+ {
+ match(EQUAL);
+ break;
+ }
+ case LE:
+ {
+ match(LE);
+ break;
+ }
+ case GE:
+ {
+ match(GE);
+ break;
+ }
+ case GT:
+ {
+ match(GT);
+ break;
+ }
+ case LTH:
+ {
+ match(LTH);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ match(LPAREN);
+ formalParameterList();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ comparisonOperatorDefinition_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_71);
+ } else {
+ throw;
+ }
+ }
+ returnAST = comparisonOperatorDefinition_AST;
+}
+
+void PascalParser::tryStatement() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST tryStatement_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp339_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp339_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp339_AST));
+ }
+ match(TRY);
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ case NUM_INT:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case IDENT:
+ {
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case EXCEPT:
+ case FINALLY:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ exceptOrFinallyPart();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(END);
+ tryStatement_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_16);
+ } else {
+ throw;
+ }
+ }
+ returnAST = tryStatement_AST;
+}
+
+void PascalParser::statements() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST statements_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop369;
+ }
+
+ }
+ _loop369:;
+ } // ( ... )*
+ statements_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_72);
+ } else {
+ throw;
+ }
+ }
+ returnAST = statements_AST;
+}
+
+void PascalParser::exceptOrFinallyPart() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exceptOrFinallyPart_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case EXCEPT:
+ {
+ match(EXCEPT);
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ case NUM_INT:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case ON:
+ case IDENT:
+ {
+ exceptionHandlers();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ exceptOrFinallyPart_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case FINALLY:
+ {
+ match(FINALLY);
+ {
+ switch ( LA(1)) {
+ case BEGIN:
+ case NUM_INT:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case IDENT:
+ {
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ exceptOrFinallyPart_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exceptOrFinallyPart_AST;
+}
+
+void PascalParser::exceptionHandlers() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exceptionHandlers_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case BEGIN:
+ case NUM_INT:
+ case CASE:
+ case GOTO:
+ case IF:
+ case WHILE:
+ case REPEAT:
+ case FOR:
+ case WITH:
+ case RAISE:
+ case TRY:
+ case IDENT:
+ {
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ exceptionHandlers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case ON:
+ {
+ exceptionHandler();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ { // ( ... )*
+ for (;;) {
+ if ((LA(1) == SEMI)) {
+ match(SEMI);
+ exceptionHandler();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ }
+ else {
+ goto _loop372;
+ }
+
+ }
+ _loop372:;
+ } // ( ... )*
+ {
+ switch ( LA(1)) {
+ case ELSE:
+ {
+ match(ELSE);
+ statements();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ break;
+ }
+ case END:
+ {
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ exceptionHandlers_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_6);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exceptionHandlers_AST;
+}
+
+void PascalParser::exceptionHandler() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST exceptionHandler_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ match(ON);
+ {
+ if ((LA(1) == IDENT) && (LA(2) == COLON)) {
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(COLON);
+ }
+ else if ((LA(1) == IDENT) && (LA(2) == DO)) {
+ }
+ else {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+
+ }
+ identifier();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(DO);
+ statement();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ exceptionHandler_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_73);
+ } else {
+ throw;
+ }
+ }
+ returnAST = exceptionHandler_AST;
+}
+
+void PascalParser::sign() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST sign_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case PLUS:
+ {
+ RefPascalAST tmp349_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp349_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp349_AST));
+ }
+ match(PLUS);
+ sign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case MINUS:
+ {
+ RefPascalAST tmp350_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp350_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp350_AST));
+ }
+ match(MINUS);
+ sign_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_74);
+ } else {
+ throw;
+ }
+ }
+ returnAST = sign_AST;
+}
+
+void PascalParser::constantChr() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST constantChr_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp351_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp351_AST = astFactory->create(LT(1));
+ astFactory->makeASTRoot(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp351_AST));
+ }
+ match(CHR);
+ match(LPAREN);
+ unsignedInteger();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ match(RPAREN);
+ constantChr_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_75);
+ } else {
+ throw;
+ }
+ }
+ returnAST = constantChr_AST;
+}
+
+void PascalParser::unsignedNumber() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST unsignedNumber_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ switch ( LA(1)) {
+ case NUM_INT:
+ {
+ unsignedInteger();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ unsignedNumber_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ case NUM_REAL:
+ {
+ unsignedReal();
+ if (inputState->guessing==0) {
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST));
+ }
+ unsignedNumber_AST = RefPascalAST(currentAST.root);
+ break;
+ }
+ default:
+ {
+ throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(LT(1), getFilename());
+ }
+ }
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_76);
+ } else {
+ throw;
+ }
+ }
+ returnAST = unsignedNumber_AST;
+}
+
+void PascalParser::unsignedReal() {
+ returnAST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ ANTLR_USE_NAMESPACE(antlr)ASTPair currentAST;
+ RefPascalAST unsignedReal_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+
+ try { // for error handling
+ RefPascalAST tmp354_AST = RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST);
+ if ( inputState->guessing == 0 ) {
+ tmp354_AST = astFactory->create(LT(1));
+ astFactory->addASTChild(currentAST, ANTLR_USE_NAMESPACE(antlr)RefAST(tmp354_AST));
+ }
+ match(NUM_REAL);
+ unsignedReal_AST = RefPascalAST(currentAST.root);
+ }
+ catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+ if( inputState->guessing == 0 ) {
+ reportError(ex);
+ recover(ex,_tokenSet_76);
+ } else {
+ throw;
+ }
+ }
+ returnAST = unsignedReal_AST;
+}
+
+void PascalParser::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory )
+{
+ factory.setMaxNodeType(189);
+}
+const char* PascalParser::tokenNames[] = {
+ "<0>",
+ "EOF",
+ "<2>",
+ "NULL_TREE_LOOKAHEAD",
+ "BLOCK",
+ "IDLIST",
+ "ELIST",
+ "FUNC_CALL",
+ "PROC_CALL",
+ "SCALARTYPE",
+ "TYPELIST",
+ "VARIANT_TAG",
+ "VARIANT_TAG_NO_ID",
+ "VARIANT_CASE",
+ "CONSTLIST",
+ "FIELDLIST",
+ "ARGDECLS",
+ "VARDECL",
+ "ARGDECL",
+ "ARGLIST",
+ "TYPEDECL",
+ "FIELD",
+ "DOT",
+ "\"library\"",
+ "SEMI",
+ "\"end\"",
+ "\"exports\"",
+ "COMMA",
+ "\"index\"",
+ "\"name\"",
+ "\"uses\"",
+ "\"unit\"",
+ "\"interface\"",
+ "\"implementation\"",
+ "\"begin\"",
+ "\"program\"",
+ "LPAREN",
+ "RPAREN",
+ "\"initialization\"",
+ "\"finalization\"",
+ "\"label\"",
+ "\"const\"",
+ "\"resourcestring\"",
+ "EQUAL",
+ "\"type\"",
+ "\"var\"",
+ "COLON",
+ "\"procedure\"",
+ "\"forward\"",
+ "\"function\"",
+ "\"array\"",
+ "\"of\"",
+ "\"external\"",
+ "\"public\"",
+ "\"alias\"",
+ "INTERRUPT",
+ "\"export\"",
+ "\"register\"",
+ "\"pascal\"",
+ "\"cdecl\"",
+ "\"stdcall\"",
+ "\"popstack\"",
+ "\"saveregisters\"",
+ "\"inline\"",
+ "\"safecall\"",
+ "\"near\"",
+ "\"far\"",
+ "NUM_INT",
+ "\"integer\"",
+ "\"shortint\"",
+ "\"smallint\"",
+ "\"longint\"",
+ "\"int64\"",
+ "\"byte\"",
+ "\"word\"",
+ "\"cardinal\"",
+ "\"qword\"",
+ "\"boolean\"",
+ "BYTEBOOL",
+ "LONGBOOL",
+ "\"char\"",
+ "DOTDOT",
+ "ASSIGN",
+ "\"real\"",
+ "\"single\"",
+ "\"double\"",
+ "\"extended\"",
+ "\"comp\"",
+ "\"string\"",
+ "LBRACK",
+ "RBRACK",
+ "\"packed\"",
+ "\"record\"",
+ "\"case\"",
+ "\"set\"",
+ "\"file\"",
+ "POINTER",
+ "\"object\"",
+ "\"virtual\"",
+ "\"abstract\"",
+ "\"private\"",
+ "\"protected\"",
+ "\"constructor\"",
+ "\"destructor\"",
+ "\"class\"",
+ "\"override\"",
+ "MESSAGE",
+ "\"published\"",
+ "\"property\"",
+ "\"read\"",
+ "\"write\"",
+ "\"default\"",
+ "\"nodefault\"",
+ "LE",
+ "GE",
+ "LTH",
+ "GT",
+ "NOT_EQUAL",
+ "\"in\"",
+ "\"is\"",
+ "PLUS",
+ "MINUS",
+ "\"or\"",
+ "\"xor\"",
+ "STAR",
+ "SLASH",
+ "\"div\"",
+ "\"mod\"",
+ "\"and\"",
+ "\"shl\"",
+ "\"shr\"",
+ "\"not\"",
+ "\"true\"",
+ "\"false\"",
+ "AT",
+ "PLUSEQ",
+ "MINUSEQ",
+ "STAREQ",
+ "SLASHQE",
+ "\"goto\"",
+ "\"if\"",
+ "\"then\"",
+ "\"else\"",
+ "\"while\"",
+ "\"do\"",
+ "\"repeat\"",
+ "\"until\"",
+ "\"for\"",
+ "\"to\"",
+ "\"downto\"",
+ "\"with\"",
+ "LBRACK2",
+ "RBRACK2",
+ "\"operator\"",
+ "\"raise\"",
+ "\"try\"",
+ "\"except\"",
+ "\"finally\"",
+ "\"on\"",
+ "STRING_LITERAL",
+ "\"chr\"",
+ "\"nil\"",
+ "NUM_REAL",
+ "IDENT",
+ "\"absolute\"",
+ "\"as\"",
+ "\"asm\"",
+ "\"assembler\"",
+ "\"break\"",
+ "\"continue\"",
+ "\"dispose\"",
+ "\"exit\"",
+ "\"inherited\"",
+ "\"new\"",
+ "\"self\"",
+ "METHOD",
+ "ADDSUBOR",
+ "ASSIGNEQUAL",
+ "SIGN",
+ "FUNC",
+ "NODE_NOT_EMIT",
+ "MYASTVAR",
+ "LF",
+ "LCURLY",
+ "RCURLY",
+ "WS",
+ "COMMENT_1",
+ "COMMENT_2",
+ "COMMENT_3",
+ "EXPONENT",
+ 0
+};
+
+const unsigned long PascalParser::_tokenSet_0_data_[] = { 2UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_0(_tokenSet_0_data_,6);
+const unsigned long PascalParser::_tokenSet_1_data_[] = { 1073741824UL, 177924UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// "uses" "begin" "label" "const" "resourcestring" "type" "var" "procedure"
+// "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_1(_tokenSet_1_data_,8);
+const unsigned long PascalParser::_tokenSet_2_data_[] = { 100663296UL, 177990UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "exports" "implementation" "begin" "initialization" "label" "const"
+// "resourcestring" "type" "var" "procedure" "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_2(_tokenSet_2_data_,8);
+const unsigned long PascalParser::_tokenSet_3_data_[] = { 121634818UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" "exports" "begin" "initialization" "label" "const"
+// "resourcestring" "type" "var" "procedure" "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_3(_tokenSet_3_data_,8);
+const unsigned long PascalParser::_tokenSet_4_data_[] = { 994050050UL, 706736UL, 101056512UL, 4294963649UL, 833972167UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" COMMA "index" "name" LPAREN RPAREN "finalization"
+// EQUAL COLON "procedure" "function" "of" DOTDOT ASSIGN LBRACK RBRACK
+// POINTER "constructor" "destructor" "class" "property" "read" "write"
+// "default" "nodefault" LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or"
+// "xor" STAR SLASH "div" "mod" "and" "shl" "shr" AT PLUSEQ MINUSEQ STAREQ
+// SLASHQE "then" "else" "do" "until" "to" "downto" LBRACK2 RBRACK2 "except"
+// "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_4(_tokenSet_4_data_,12);
+const unsigned long PascalParser::_tokenSet_5_data_[] = { 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "exports"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_5(_tokenSet_5_data_,6);
+const unsigned long PascalParser::_tokenSet_6_data_[] = { 33554432UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_6(_tokenSet_6_data_,6);
+const unsigned long PascalParser::_tokenSet_7_data_[] = { 100663296UL, 68UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "exports" "begin" "initialization"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_7(_tokenSet_7_data_,6);
+const unsigned long PascalParser::_tokenSet_8_data_[] = { 184549376UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" COMMA
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_8(_tokenSet_8_data_,6);
+const unsigned long PascalParser::_tokenSet_9_data_[] = { 788529154UL, 177988UL, 0UL, 127424UL, 0UL, 0UL, 0UL, 0UL };
+// EOF SEMI "end" "exports" COMMA "name" "begin" "initialization" "label"
+// "const" "resourcestring" "type" "var" "procedure" "function" "constructor"
+// "destructor" "class" "property" "read" "write" "default" "nodefault"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_9(_tokenSet_9_data_,8);
+const unsigned long PascalParser::_tokenSet_10_data_[] = { 1056964610UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// EOF SEMI "end" "exports" COMMA "index" "name" "begin" "initialization"
+// "label" "const" "resourcestring" "type" "var" "procedure" "function"
+// "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_10(_tokenSet_10_data_,8);
+const unsigned long PascalParser::_tokenSet_11_data_[] = { 16777216UL, 16416UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RPAREN COLON RBRACK
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_11(_tokenSet_11_data_,8);
+const unsigned long PascalParser::_tokenSet_12_data_[] = { 0UL, 2UL, 0UL, 0UL, 0UL, 0UL };
+// "implementation"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_12(_tokenSet_12_data_,6);
+const unsigned long PascalParser::_tokenSet_13_data_[] = { 33554432UL, 68UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "begin" "initialization"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_13(_tokenSet_13_data_,6);
+const unsigned long PascalParser::_tokenSet_14_data_[] = { 33554432UL, 128UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "finalization"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_14(_tokenSet_14_data_,6);
+const unsigned long PascalParser::_tokenSet_15_data_[] = { 0UL, 168450UL, 0UL, 0UL, 0UL, 0UL };
+// "implementation" "const" "type" "procedure" "function"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_15(_tokenSet_15_data_,6);
+const unsigned long PascalParser::_tokenSet_16_data_[] = { 50331648UL, 128UL, 0UL, 0UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" "finalization" "else" "until" "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_16(_tokenSet_16_data_,12);
+const unsigned long PascalParser::_tokenSet_17_data_[] = { 100663296UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "exports" "begin" "initialization" "label" "const" "resourcestring"
+// "type" "var" "procedure" "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_17(_tokenSet_17_data_,8);
+const unsigned long PascalParser::_tokenSet_18_data_[] = { 184549376UL, 16512UL, 0UL, 0UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" COMMA "finalization" COLON "else" "until" "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_18(_tokenSet_18_data_,12);
+const unsigned long PascalParser::_tokenSet_19_data_[] = { 100663296UL, 177990UL, 0UL, 192UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "exports" "implementation" "begin" "initialization" "label" "const"
+// "resourcestring" "type" "var" "procedure" "function" "constructor" "destructor"
+// IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_19(_tokenSet_19_data_,12);
+const unsigned long PascalParser::_tokenSet_20_data_[] = { 100663296UL, 177988UL, 0UL, 192UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "exports" "begin" "initialization" "label" "const" "resourcestring"
+// "type" "var" "procedure" "function" "constructor" "destructor" IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_20(_tokenSet_20_data_,12);
+const unsigned long PascalParser::_tokenSet_21_data_[] = { 1061158914UL, 720868UL, 67239936UL, 4294840768UL, 825581575UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" "exports" COMMA "index" "name" "begin" RPAREN "initialization"
+// "finalization" "label" "const" "resourcestring" EQUAL "type" "var" COLON
+// "procedure" "function" "of" DOTDOT RBRACK "constructor" "destructor"
+// "class" "property" LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or"
+// "xor" STAR SLASH "div" "mod" "and" "shl" "shr" "then" "else" "do" "until"
+// "to" "downto" RBRACK2 "except" "finally" IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_21(_tokenSet_21_data_,12);
+const unsigned long PascalParser::_tokenSet_22_data_[] = { 16777216UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_22(_tokenSet_22_data_,6);
+const unsigned long PascalParser::_tokenSet_23_data_[] = { 16777216UL, 2080UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RPAREN EQUAL RBRACK
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_23(_tokenSet_23_data_,8);
+const unsigned long PascalParser::_tokenSet_24_data_[] = { 0UL, 4UL, 536870920UL, 0UL, 206215168UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "begin" NUM_INT "case" "goto" "if" "while" "repeat" "for" "with" "raise"
+// "try" IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_24(_tokenSet_24_data_,12);
+const unsigned long PascalParser::_tokenSet_25_data_[] = { 121634818UL, 178116UL, 0UL, 192UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" "exports" "begin" "initialization" "finalization"
+// "label" "const" "resourcestring" "type" "var" "procedure" "function"
+// "constructor" "destructor" "else" "until" "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_25(_tokenSet_25_data_,12);
+const unsigned long PascalParser::_tokenSet_26_data_[] = { 16777216UL, 1818406UL, 67108864UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "implementation" "begin" RPAREN "label" "const" "resourcestring"
+// EQUAL "type" "var" "procedure" "forward" "function" "of" "external"
+// RBRACK "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_26(_tokenSet_26_data_,8);
+const unsigned long PascalParser::_tokenSet_27_data_[] = { 117440514UL, 177988UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// EOF SEMI "end" "exports" "begin" "initialization" "label" "const" "resourcestring"
+// "type" "var" "procedure" "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_27(_tokenSet_27_data_,8);
+const unsigned long PascalParser::_tokenSet_28_data_[] = { 16777216UL, 16400UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN COLON
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_28(_tokenSet_28_data_,6);
+const unsigned long PascalParser::_tokenSet_29_data_[] = { 16777216UL, 16416UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RPAREN COLON
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_29(_tokenSet_29_data_,6);
+const unsigned long PascalParser::_tokenSet_30_data_[] = { 16777216UL, 32UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI RPAREN RBRACK
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_30(_tokenSet_30_data_,8);
+const unsigned long PascalParser::_tokenSet_31_data_[] = { 0UL, 426000UL, 3657039864UL, 50331907UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN "procedure" "function" "array" NUM_INT "integer" "shortint" "smallint"
+// "longint" "int64" "byte" "word" "cardinal" "qword" "boolean" BYTEBOOL
+// LONGBOOL "char" "real" "single" "double" "extended" "comp" "string"
+// "packed" "record" "set" "file" POINTER "object" "class" PLUS MINUS STRING_LITERAL
+// "chr" NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_31(_tokenSet_31_data_,12);
+const unsigned long PascalParser::_tokenSet_32_data_[] = { 188743680UL, 524448UL, 67239936UL, 0UL, 825581568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// DOT SEMI "end" COMMA RPAREN "finalization" "of" DOTDOT RBRACK "then"
+// "else" "do" "until" "to" "downto" RBRACK2 "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_32(_tokenSet_32_data_,12);
+const unsigned long PascalParser::_tokenSet_33_data_[] = { 0UL, 0UL, 8UL, 50331648UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// NUM_INT PLUS MINUS STRING_LITERAL "chr" NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_33(_tokenSet_33_data_,12);
+const unsigned long PascalParser::_tokenSet_34_data_[] = { 16777216UL, 16UL, 8UL, 0UL, 0UL, 12UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN NUM_INT NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_34(_tokenSet_34_data_,12);
+const unsigned long PascalParser::_tokenSet_35_data_[] = { 0UL, 16UL, 8UL, 50331648UL, 2147483648UL, 13UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN NUM_INT PLUS MINUS STRING_LITERAL "chr" NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_35(_tokenSet_35_data_,12);
+const unsigned long PascalParser::_tokenSet_36_data_[] = { 0UL, 16UL, 33554440UL, 50331648UL, 2147483768UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN NUM_INT LBRACK PLUS MINUS "not" "true" "false" AT STRING_LITERAL
+// "chr" "nil" NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_36(_tokenSet_36_data_,12);
+const unsigned long PascalParser::_tokenSet_37_data_[] = { 16777216UL, 2064UL, 100663304UL, 4294836224UL, 2147483775UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI LPAREN EQUAL NUM_INT LBRACK RBRACK LE GE LTH GT NOT_EQUAL "in"
+// "is" PLUS MINUS "or" "xor" STAR SLASH "div" "mod" "and" "shl" "shr"
+// "not" "true" "false" AT STRING_LITERAL "chr" "nil" NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_37(_tokenSet_37_data_,12);
+const unsigned long PascalParser::_tokenSet_38_data_[] = { 184549378UL, 182304UL, 67239936UL, 4544UL, 0UL, 0UL, 0UL, 0UL };
+// EOF SEMI "end" COMMA RPAREN EQUAL COLON "procedure" "function" DOTDOT
+// RBRACK "constructor" "destructor" "class" "property"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_38(_tokenSet_38_data_,8);
+const unsigned long PascalParser::_tokenSet_39_data_[] = { 150994944UL, 32UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI COMMA RPAREN
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_39(_tokenSet_39_data_,6);
+const unsigned long PascalParser::_tokenSet_40_data_[] = { 150994944UL, 2080UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI COMMA RPAREN EQUAL RBRACK
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_40(_tokenSet_40_data_,8);
+const unsigned long PascalParser::_tokenSet_41_data_[] = { 318767104UL, 165936UL, 67108864UL, 127424UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" "index" LPAREN RPAREN EQUAL "procedure" "function" RBRACK
+// "constructor" "destructor" "class" "property" "read" "write" "default"
+// "nodefault"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_41(_tokenSet_41_data_,8);
+const unsigned long PascalParser::_tokenSet_42_data_[] = { 0UL, 32UL, 0UL, 0UL, 0UL, 0UL };
+// RPAREN
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_42(_tokenSet_42_data_,6);
+const unsigned long PascalParser::_tokenSet_43_data_[] = { 792723458UL, 720868UL, 67239936UL, 4294963648UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" "exports" COMMA "name" "begin" RPAREN "initialization"
+// "finalization" "label" "const" "resourcestring" EQUAL "type" "var" COLON
+// "procedure" "function" "of" DOTDOT RBRACK "constructor" "destructor"
+// "class" "property" "read" "write" "default" "nodefault" LE GE LTH GT
+// NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR SLASH "div" "mod" "and"
+// "shl" "shr" "then" "else" "do" "until" "to" "downto" RBRACK2 "except"
+// "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_43(_tokenSet_43_data_,12);
+const unsigned long PascalParser::_tokenSet_44_data_[] = { 0UL, 2064UL, 100794376UL, 4294836224UL, 2147483775UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// LPAREN EQUAL NUM_INT DOTDOT LBRACK RBRACK LE GE LTH GT NOT_EQUAL "in"
+// "is" PLUS MINUS "or" "xor" STAR SLASH "div" "mod" "and" "shl" "shr"
+// "not" "true" "false" AT STRING_LITERAL "chr" "nil" NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_44(_tokenSet_44_data_,12);
+const unsigned long PascalParser::_tokenSet_45_data_[] = { 134217728UL, 0UL, 67108864UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// COMMA RBRACK
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_45(_tokenSet_45_data_,8);
+const unsigned long PascalParser::_tokenSet_46_data_[] = { 33554432UL, 32UL, 536870912UL, 0UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end" RPAREN "case" IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_46(_tokenSet_46_data_,12);
+const unsigned long PascalParser::_tokenSet_47_data_[] = { 50331648UL, 32UL, 536870912UL, 0UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" RPAREN "case" IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_47(_tokenSet_47_data_,12);
+const unsigned long PascalParser::_tokenSet_48_data_[] = { 33554432UL, 2260992UL, 0UL, 6640UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "public" "private" "protected" "constructor"
+// "destructor" "class" "published" "property" IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_48(_tokenSet_48_data_,12);
+const unsigned long PascalParser::_tokenSet_49_data_[] = { 0UL, 163840UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// "procedure" "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_49(_tokenSet_49_data_,8);
+const unsigned long PascalParser::_tokenSet_50_data_[] = { 33554432UL, 163840UL, 0UL, 4544UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "constructor" "destructor" "class" "property"
+// IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_50(_tokenSet_50_data_,12);
+const unsigned long PascalParser::_tokenSet_51_data_[] = { 33554432UL, 163840UL, 0UL, 192UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "constructor" "destructor"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_51(_tokenSet_51_data_,8);
+const unsigned long PascalParser::_tokenSet_52_data_[] = { 0UL, 163840UL, 0UL, 4544UL, 0UL, 0UL, 0UL, 0UL };
+// "procedure" "function" "constructor" "destructor" "class" "property"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_52(_tokenSet_52_data_,8);
+const unsigned long PascalParser::_tokenSet_53_data_[] = { 33554432UL, 163840UL, 0UL, 4544UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "constructor" "destructor" "class" "property"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_53(_tokenSet_53_data_,8);
+const unsigned long PascalParser::_tokenSet_54_data_[] = { 33554432UL, 163840UL, 0UL, 127424UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "constructor" "destructor" "class" "property"
+// "read" "write" "default" "nodefault"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_54(_tokenSet_54_data_,8);
+const unsigned long PascalParser::_tokenSet_55_data_[] = { 0UL, 16384UL, 0UL, 0UL, 0UL, 0UL };
+// COLON
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_55(_tokenSet_55_data_,6);
+const unsigned long PascalParser::_tokenSet_56_data_[] = { 33554432UL, 163840UL, 0UL, 119232UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "constructor" "destructor" "class" "property"
+// "write" "default" "nodefault"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_56(_tokenSet_56_data_,8);
+const unsigned long PascalParser::_tokenSet_57_data_[] = { 33554432UL, 163840UL, 0UL, 102848UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "procedure" "function" "constructor" "destructor" "class" "property"
+// "default" "nodefault"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_57(_tokenSet_57_data_,8);
+const unsigned long PascalParser::_tokenSet_58_data_[] = { 188743680UL, 526496UL, 67239936UL, 16646144UL, 825581568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// DOT SEMI "end" COMMA RPAREN "finalization" EQUAL "of" DOTDOT RBRACK
+// LE GE LTH GT NOT_EQUAL "in" "is" "then" "else" "do" "until" "to" "downto"
+// RBRACK2 "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_58(_tokenSet_58_data_,12);
+const unsigned long PascalParser::_tokenSet_59_data_[] = { 188743680UL, 526496UL, 67239936UL, 268304384UL, 825581568UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// DOT SEMI "end" COMMA RPAREN "finalization" EQUAL "of" DOTDOT RBRACK
+// LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" "then" "else"
+// "do" "until" "to" "downto" RBRACK2 "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_59(_tokenSet_59_data_,12);
+const unsigned long PascalParser::_tokenSet_60_data_[] = { 188743680UL, 526512UL, 67239936UL, 4294836224UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// DOT SEMI "end" COMMA LPAREN RPAREN "finalization" EQUAL "of" DOTDOT
+// RBRACK LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR SLASH
+// "div" "mod" "and" "shl" "shr" "then" "else" "do" "until" "to" "downto"
+// RBRACK2 "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_60(_tokenSet_60_data_,12);
+const unsigned long PascalParser::_tokenSet_61_data_[] = { 188743680UL, 526496UL, 67239936UL, 4294836224UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// DOT SEMI "end" COMMA RPAREN "finalization" EQUAL "of" DOTDOT RBRACK
+// LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR SLASH "div"
+// "mod" "and" "shl" "shr" "then" "else" "do" "until" "to" "downto" RBRACK2
+// "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_61(_tokenSet_61_data_,12);
+const unsigned long PascalParser::_tokenSet_62_data_[] = { 50331648UL, 128UL, 0UL, 0UL, 805584960UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" "finalization" AT "else" "until" "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_62(_tokenSet_62_data_,12);
+const unsigned long PascalParser::_tokenSet_63_data_[] = { 0UL, 0UL, 33816576UL, 0UL, 1920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// ASSIGN LBRACK PLUSEQ MINUSEQ STAREQ SLASHQE
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_63(_tokenSet_63_data_,12);
+const unsigned long PascalParser::_tokenSet_64_data_[] = { 50331648UL, 144UL, 0UL, 0UL, 805584896UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" LPAREN "finalization" "else" "until" "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_64(_tokenSet_64_data_,12);
+const unsigned long PascalParser::_tokenSet_65_data_[] = { 0UL, 0UL, 262144UL, 0UL, 1920UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// ASSIGN PLUSEQ MINUSEQ STAREQ SLASHQE
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_65(_tokenSet_65_data_,12);
+const unsigned long PascalParser::_tokenSet_66_data_[] = { 121634818UL, 178132UL, 570425352UL, 50331840UL, 4233025656UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" "exports" "begin" LPAREN "initialization" "finalization"
+// "label" "const" "resourcestring" "type" "var" "procedure" "function"
+// NUM_INT LBRACK "case" "constructor" "destructor" PLUS MINUS "not" "true"
+// "false" AT "goto" "if" "else" "while" "repeat" "until" "for" "with"
+// "raise" "try" "except" "finally" "on" STRING_LITERAL "chr" "nil" NUM_REAL
+// IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_66(_tokenSet_66_data_,12);
+const unsigned long PascalParser::_tokenSet_67_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_67(_tokenSet_67_data_,6);
+const unsigned long PascalParser::_tokenSet_68_data_[] = { 0UL, 0UL, 0UL, 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "do"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_68(_tokenSet_68_data_,12);
+const unsigned long PascalParser::_tokenSet_69_data_[] = { 0UL, 0UL, 0UL, 0UL, 3145728UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "to" "downto"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_69(_tokenSet_69_data_,12);
+const unsigned long PascalParser::_tokenSet_70_data_[] = { 134217728UL, 0UL, 0UL, 0UL, 65536UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// COMMA "do"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_70(_tokenSet_70_data_,12);
+const unsigned long PascalParser::_tokenSet_71_data_[] = { 0UL, 0UL, 0UL, 0UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_71(_tokenSet_71_data_,12);
+const unsigned long PascalParser::_tokenSet_72_data_[] = { 33554432UL, 0UL, 0UL, 0UL, 805306368UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// "end" "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_72(_tokenSet_72_data_,12);
+const unsigned long PascalParser::_tokenSet_73_data_[] = { 50331648UL, 0UL, 0UL, 0UL, 16384UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SEMI "end" "else"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_73(_tokenSet_73_data_,12);
+const unsigned long PascalParser::_tokenSet_74_data_[] = { 0UL, 0UL, 8UL, 0UL, 0UL, 12UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// NUM_INT NUM_REAL IDENT
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_74(_tokenSet_74_data_,12);
+const unsigned long PascalParser::_tokenSet_75_data_[] = { 1061158914UL, 720868UL, 67239936UL, 4294840768UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" "exports" COMMA "index" "name" "begin" RPAREN "initialization"
+// "finalization" "label" "const" "resourcestring" EQUAL "type" "var" COLON
+// "procedure" "function" "of" DOTDOT RBRACK "constructor" "destructor"
+// "class" "property" LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or"
+// "xor" STAR SLASH "div" "mod" "and" "shl" "shr" "then" "else" "do" "until"
+// "to" "downto" RBRACK2 "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_75(_tokenSet_75_data_,12);
+const unsigned long PascalParser::_tokenSet_76_data_[] = { 188743682UL, 706720UL, 67239936UL, 4294840768UL, 825581575UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// EOF DOT SEMI "end" COMMA RPAREN "finalization" EQUAL COLON "procedure"
+// "function" "of" DOTDOT RBRACK "constructor" "destructor" "class" "property"
+// LE GE LTH GT NOT_EQUAL "in" "is" PLUS MINUS "or" "xor" STAR SLASH "div"
+// "mod" "and" "shl" "shr" "then" "else" "do" "until" "to" "downto" RBRACK2
+// "except" "finally"
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalParser::_tokenSet_76(_tokenSet_76_data_,12);
+
+