Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

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);
+
+