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

76 files changed, 21786 insertions, 0 deletions

diff --git a/languages/pascal/Makefile.am b/languages/pascal/Makefile.am
new file mode 100644
index 00000000..5abaa01b
--- /dev/null
+++ b/languages/pascal/Makefile.am
@@ -0,0 +1,33 @@
+KDE_CXXFLAGS = $(USE_EXCEPTIONS)
+
+INCLUDES = -I$(top_srcdir)/lib/antlr -I$(top_srcdir)/lib/catalog \
+	-I$(top_srcdir)/lib/interfaces -I$(top_srcdir)/lib/interfaces/external -I$(top_srcdir)/lib/util \
+	$(all_includes)
+SUBDIRS = file_templates app_templates compiler doc
+
+kde_module_LTLIBRARIES = libkdevpascalsupport.la
+libkdevpascalsupport_la_LDFLAGS = $(LEXLIB) $(all_libraries) $(KDE_PLUGIN)
+libkdevpascalsupport_la_LIBADD = $(top_builddir)/lib/libkdevelop.la $(top_builddir)/lib/antlr/src/libantlr.la $(top_builddir)/lib/catalog/libkdevcatalog.la
+
+libkdevpascalsupport_la_SOURCES = pascalsupport_part.cpp PascalLexer.cpp PascalParser.cpp PascalStoreWalker.cpp backgroundparser.cpp configproblemreporter.ui problemreporter.cpp
+
+METASOURCES = AUTO
+
+servicedir = $(kde_servicesdir)
+service_DATA = kdevpascalsupport.desktop
+
+rcdir = $(kde_datadir)/kdevpascalsupport
+rc_DATA = kdevpascalsupport.rc
+
+genparser:
+	antlr   pascal.g && antlr pascal.tree.g
+
+## The following rules assume that you have Java and ANTLR installed,
+#PascalLexer.hpp PascalLexer.cpp PascalParser.hpp PascalParser.cpp: pascal.g
+#	antlr pascal.g
+
+#PascalStoreWalker.hpp PascalStoreWalker.cpp: pascal.tree.g
+#	antlr pascal.tree.g
+
+templatedir = ${kde_datadir}/kdevabbrev/templates
+template_DATA = pascaltemplates
diff --git a/languages/pascal/PascalAST.hpp b/languages/pascal/PascalAST.hpp
new file mode 100644
index 00000000..3df4ea50
--- /dev/null
+++ b/languages/pascal/PascalAST.hpp
@@ -0,0 +1,51 @@
+#ifndef PASCALAST_HPP
+#define PASCALAST_HPP
+
+#include <antlr/CommonAST.hpp>
+
+class PascalAST;
+typedef antlr::ASTRefCount<PascalAST> RefPascalAST;
+
+class PascalAST : public antlr::CommonAST {
+public:
+    PascalAST()
+        : m_line(0), m_column(0) {}
+
+    ~PascalAST() {}
+
+    int getLine() const { return m_line; }
+    void setLine( int line ) { m_line = line; }
+
+    int getColumn() const { return m_column; }
+    void setColumn( int column ) { m_column = column; }
+
+    void initialize( antlr::RefToken t ) {
+            antlr::CommonAST::initialize(t);
+            m_line = t->getLine() - 1;
+            m_column = t->getColumn() - 1;
+    }
+
+    void initialize(int t,const ANTLR_USE_NAMESPACE(std)string& txt) {
+            setType(t);
+            setText(txt);
+            m_line = 0;
+            m_column = 0;
+        }
+
+    void addChild( RefPascalAST c ) {
+        antlr::RefAST n( c.get() );
+        antlr::BaseAST::addChild( n );
+    }
+
+    static antlr::RefAST factory( void ) {
+        RefPascalAST n(new PascalAST);
+        return n.get();
+    }
+
+private:
+    int m_line;
+    int m_column;
+};
+
+
+#endif
diff --git a/languages/pascal/PascalLexer.cpp b/languages/pascal/PascalLexer.cpp
new file mode 100644
index 00000000..28f532f8
--- /dev/null
+++ b/languages/pascal/PascalLexer.cpp
@@ -0,0 +1,1309 @@
+/* $ANTLR 2.7.7 (20061129): "pascal.g" -> "PascalLexer.cpp"$ */
+#include "PascalLexer.hpp"
+#include <antlr/CharBuffer.hpp>
+#include <antlr/TokenStreamException.hpp>
+#include <antlr/TokenStreamIOException.hpp>
+#include <antlr/TokenStreamRecognitionException.hpp>
+#include <antlr/CharStreamException.hpp>
+#include <antlr/CharStreamIOException.hpp>
+#include <antlr/NoViableAltForCharException.hpp>
+
+#line 1 "pascal.g"
+#line 13 "PascalLexer.cpp"
+PascalLexer::PascalLexer(ANTLR_USE_NAMESPACE(std)istream& in)
+	: ANTLR_USE_NAMESPACE(antlr)CharScanner(new ANTLR_USE_NAMESPACE(antlr)CharBuffer(in),false)
+{
+	initLiterals();
+}
+
+PascalLexer::PascalLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib)
+	: ANTLR_USE_NAMESPACE(antlr)CharScanner(ib,false)
+{
+	initLiterals();
+}
+
+PascalLexer::PascalLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state)
+	: ANTLR_USE_NAMESPACE(antlr)CharScanner(state,false)
+{
+	initLiterals();
+}
+
+void PascalLexer::initLiterals()
+{
+	literals["until"] = 146;
+	literals["xor"] = 123;
+	literals["abstract"] = 99;
+	literals["shortint"] = 69;
+	literals["with"] = 150;
+	literals["packed"] = 91;
+	literals["inherited"] = 172;
+	literals["break"] = 168;
+	literals["smallint"] = 70;
+	literals["safecall"] = 64;
+	literals["constructor"] = 102;
+	literals["continue"] = 169;
+	literals["uses"] = 30;
+	literals["for"] = 147;
+	literals["else"] = 142;
+	literals["is"] = 119;
+	literals["of"] = 51;
+	literals["and"] = 128;
+	literals["integer"] = 68;
+	literals["byte"] = 73;
+	literals["nil"] = 161;
+	literals["begin"] = 34;
+	literals["interface"] = 32;
+	literals["as"] = 165;
+	literals["div"] = 126;
+	literals["write"] = 110;
+	literals["qword"] = 76;
+	literals["procedure"] = 47;
+	literals["shl"] = 129;
+	literals["var"] = 45;
+	literals["private"] = 100;
+	literals["function"] = 49;
+	literals["unit"] = 31;
+	literals["downto"] = 149;
+	literals["name"] = 29;
+	literals["resourcestring"] = 42;
+	literals["register"] = 57;
+	literals["popstack"] = 61;
+	literals["label"] = 40;
+	literals["try"] = 155;
+	literals["raise"] = 154;
+	literals["not"] = 131;
+	literals["record"] = 92;
+	literals["forward"] = 48;
+	literals["in"] = 118;
+	literals["except"] = 156;
+	literals["file"] = 95;
+	literals["operator"] = 153;
+	literals["pascal"] = 58;
+	literals["finalization"] = 39;
+	literals["cdecl"] = 59;
+	literals["extended"] = 86;
+	literals["external"] = 52;
+	literals["destructor"] = 103;
+	literals["real"] = 83;
+	literals["virtual"] = 98;
+	literals["chr"] = 160;
+	literals["near"] = 65;
+	literals["object"] = 97;
+	literals["public"] = 53;
+	literals["repeat"] = 145;
+	literals["library"] = 23;
+	literals["false"] = 133;
+	literals["longint"] = 71;
+	literals["saveregisters"] = 62;
+	literals["to"] = 148;
+	literals["asm"] = 166;
+	literals["case"] = 93;
+	literals["export"] = 56;
+	literals["true"] = 132;
+	literals["do"] = 144;
+	literals["stdcall"] = 60;
+	literals["program"] = 35;
+	literals["absolute"] = 164;
+	literals["override"] = 105;
+	literals["then"] = 141;
+	literals["set"] = 94;
+	literals["protected"] = 101;
+	literals["or"] = 122;
+	literals["word"] = 74;
+	literals["finally"] = 157;
+	literals["char"] = 80;
+	literals["if"] = 140;
+	literals["far"] = 66;
+	literals["const"] = 41;
+	literals["index"] = 28;
+	literals["assembler"] = 167;
+	literals["cardinal"] = 75;
+	literals["string"] = 88;
+	literals["dispose"] = 170;
+	literals["read"] = 109;
+	literals["default"] = 111;
+	literals["new"] = 173;
+	literals["array"] = 50;
+	literals["self"] = 174;
+	literals["end"] = 25;
+	literals["single"] = 84;
+	literals["property"] = 108;
+	literals["mod"] = 127;
+	literals["goto"] = 139;
+	literals["on"] = 158;
+	literals["comp"] = 87;
+	literals["initialization"] = 38;
+	literals["class"] = 104;
+	literals["int64"] = 72;
+	literals["published"] = 107;
+	literals["nodefault"] = 112;
+	literals["inline"] = 63;
+	literals["while"] = 143;
+	literals["boolean"] = 77;
+	literals["type"] = 44;
+	literals["double"] = 85;
+	literals["implementation"] = 33;
+	literals["exports"] = 26;
+	literals["alias"] = 54;
+	literals["exit"] = 171;
+	literals["shr"] = 130;
+}
+
+ANTLR_USE_NAMESPACE(antlr)RefToken PascalLexer::nextToken()
+{
+	ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
+	for (;;) {
+		ANTLR_USE_NAMESPACE(antlr)RefToken theRetToken;
+		int _ttype = ANTLR_USE_NAMESPACE(antlr)Token::INVALID_TYPE;
+		resetText();
+		try {   // for lexical and char stream error handling
+			switch ( LA(1)) {
+			case 0x2c /* ',' */ :
+			{
+				mCOMMA(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x3b /* ';' */ :
+			{
+				mSEMI(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x3d /* '=' */ :
+			{
+				mEQUAL(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x29 /* ')' */ :
+			{
+				mRPAREN(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x5b /* '[' */ :
+			{
+				mLBRACK(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x5d /* ']' */ :
+			{
+				mRBRACK(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x5e /* '^' */ :
+			{
+				mPOINTER(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x40 /* '@' */ :
+			{
+				mAT(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x7d /* '}' */ :
+			{
+				mRCURLY(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x9 /* '\t' */ :
+			case 0xa /* '\n' */ :
+			case 0xc /* '\14' */ :
+			case 0xd /* '\r' */ :
+			case 0x20 /* ' ' */ :
+			{
+				mWS(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x61 /* 'a' */ :
+			case 0x62 /* 'b' */ :
+			case 0x63 /* 'c' */ :
+			case 0x64 /* 'd' */ :
+			case 0x65 /* 'e' */ :
+			case 0x66 /* 'f' */ :
+			case 0x67 /* 'g' */ :
+			case 0x68 /* 'h' */ :
+			case 0x69 /* 'i' */ :
+			case 0x6a /* 'j' */ :
+			case 0x6b /* 'k' */ :
+			case 0x6c /* 'l' */ :
+			case 0x6d /* 'm' */ :
+			case 0x6e /* 'n' */ :
+			case 0x6f /* 'o' */ :
+			case 0x70 /* 'p' */ :
+			case 0x71 /* 'q' */ :
+			case 0x72 /* 'r' */ :
+			case 0x73 /* 's' */ :
+			case 0x74 /* 't' */ :
+			case 0x75 /* 'u' */ :
+			case 0x76 /* 'v' */ :
+			case 0x77 /* 'w' */ :
+			case 0x78 /* 'x' */ :
+			case 0x79 /* 'y' */ :
+			case 0x7a /* 'z' */ :
+			{
+				mIDENT(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x27 /* '\'' */ :
+			{
+				mSTRING_LITERAL(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			case 0x30 /* '0' */ :
+			case 0x31 /* '1' */ :
+			case 0x32 /* '2' */ :
+			case 0x33 /* '3' */ :
+			case 0x34 /* '4' */ :
+			case 0x35 /* '5' */ :
+			case 0x36 /* '6' */ :
+			case 0x37 /* '7' */ :
+			case 0x38 /* '8' */ :
+			case 0x39 /* '9' */ :
+			{
+				mNUM_INT(true);
+				theRetToken=_returnToken;
+				break;
+			}
+			default:
+				if ((LA(1) == 0x3a /* ':' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mASSIGN(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3e /* '>' */ )) {
+					mNOT_EQUAL(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x3c /* '<' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mLE(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x3e /* '>' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mGE(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x28 /* '(' */ ) && (LA(2) == 0x2e /* '.' */ )) {
+					mLBRACK2(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2e /* '.' */ ) && (LA(2) == 0x29 /* ')' */ )) {
+					mRBRACK2(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2b /* '+' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mPLUSEQ(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2d /* '-' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mMINUSEQ(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2a /* '*' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mSTAREQ(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x3d /* '=' */ )) {
+					mSLASHQE(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x28 /* '(' */ ) && (LA(2) == 0x2a /* '*' */ )) {
+					mCOMMENT_1(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x7b /* '{' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff))) {
+					mCOMMENT_2(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2f /* '/' */ ) && (LA(2) == 0x2f /* '/' */ )) {
+					mCOMMENT_3(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2b /* '+' */ ) && (true)) {
+					mPLUS(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2d /* '-' */ ) && (true)) {
+					mMINUS(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2a /* '*' */ ) && (true)) {
+					mSTAR(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2f /* '/' */ ) && (true)) {
+					mSLASH(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x3a /* ':' */ ) && (true)) {
+					mCOLON(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x3c /* '<' */ ) && (true)) {
+					mLTH(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x3e /* '>' */ ) && (true)) {
+					mGT(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x28 /* '(' */ ) && (true)) {
+					mLPAREN(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x2e /* '.' */ ) && (true)) {
+					mDOT(true);
+					theRetToken=_returnToken;
+				}
+				else if ((LA(1) == 0x7b /* '{' */ ) && (true)) {
+					mLCURLY(true);
+					theRetToken=_returnToken;
+				}
+			else {
+				if (LA(1)==EOF_CHAR)
+				{
+					uponEOF();
+					_returnToken = makeToken(ANTLR_USE_NAMESPACE(antlr)Token::EOF_TYPE);
+				}
+				else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+			}
+			}
+			if ( !_returnToken )
+				goto tryAgain; // found SKIP token
+
+			_ttype = _returnToken->getType();
+			_returnToken->setType(_ttype);
+			return _returnToken;
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& e) {
+				throw ANTLR_USE_NAMESPACE(antlr)TokenStreamRecognitionException(e);
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)CharStreamIOException& csie) {
+			throw ANTLR_USE_NAMESPACE(antlr)TokenStreamIOException(csie.io);
+		}
+		catch (ANTLR_USE_NAMESPACE(antlr)CharStreamException& cse) {
+			throw ANTLR_USE_NAMESPACE(antlr)TokenStreamException(cse.getMessage());
+		}
+tryAgain:;
+	}
+}
+
+void PascalLexer::mPLUS(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = PLUS;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('+' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mMINUS(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = MINUS;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('-' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mSTAR(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = STAR;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('*' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mSLASH(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = SLASH;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('/' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mASSIGN(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = ASSIGN;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(":=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mCOMMA(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = COMMA;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(',' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mSEMI(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = SEMI;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(';' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mCOLON(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = COLON;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(':' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mEQUAL(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = EQUAL;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('=' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mNOT_EQUAL(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = NOT_EQUAL;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("<>");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mLTH(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = LTH;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('<' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mLE(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = LE;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("<=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mGE(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = GE;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(">=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mGT(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = GT;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('>' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mLPAREN(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = LPAREN;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('(' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mRPAREN(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = RPAREN;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(')' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mLBRACK(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = LBRACK;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('[' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mLBRACK2(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = LBRACK2;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("(.");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mRBRACK(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = RBRACK;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(']' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mRBRACK2(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = RBRACK2;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match(".)");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mPOINTER(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = POINTER;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('^' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mAT(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = AT;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('@' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mDOT(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = DOT;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('.' /* charlit */ );
+	{
+	if ((LA(1) == 0x2e /* '.' */ )) {
+		match('.' /* charlit */ );
+#line 1124 "pascal.g"
+		_ttype = DOTDOT;
+#line 719 "PascalLexer.cpp"
+	}
+	else {
+	}
+	
+	}
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mLCURLY(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = LCURLY;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("{");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mRCURLY(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = RCURLY;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("}");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mPLUSEQ(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = PLUSEQ;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("+=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mMINUSEQ(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = MINUSEQ;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("-=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mSTAREQ(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = STAREQ;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("*=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mSLASHQE(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = SLASHQE;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("/=");
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mWS(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = WS;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	{
+	switch ( LA(1)) {
+	case 0x20 /* ' ' */ :
+	{
+		match(' ' /* charlit */ );
+		break;
+	}
+	case 0x9 /* '\t' */ :
+	{
+		match('\t' /* charlit */ );
+		break;
+	}
+	case 0xc /* '\14' */ :
+	{
+		match('\14' /* charlit */ );
+		break;
+	}
+	case 0xa /* '\n' */ :
+	case 0xd /* '\r' */ :
+	{
+		{
+		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ )) {
+			match("\r\n");
+		}
+		else if ((LA(1) == 0xd /* '\r' */ ) && (true)) {
+			match('\r' /* charlit */ );
+		}
+		else if ((LA(1) == 0xa /* '\n' */ )) {
+			match('\n' /* charlit */ );
+		}
+		else {
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+		}
+		
+		}
+#line 1142 "pascal.g"
+		newline();
+#line 859 "PascalLexer.cpp"
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+	}
+	}
+	}
+#line 1144 "pascal.g"
+	_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+#line 870 "PascalLexer.cpp"
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mCOMMENT_1(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = COMMENT_1;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("(*");
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)) && ((LA(4) >= 0x0 /* '\0' */  && LA(4) <= 0xff))) {
+			match('\r' /* charlit */ );
+			match('\n' /* charlit */ );
+#line 1152 "pascal.g"
+			newline();
+#line 892 "PascalLexer.cpp"
+		}
+		else if (((LA(1) == 0x2a /* '*' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)))&&( LA(2) != ')' )) {
+			match('*' /* charlit */ );
+		}
+		else if ((LA(1) == 0xd /* '\r' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)) && (true)) {
+			match('\r' /* charlit */ );
+#line 1153 "pascal.g"
+			newline();
+#line 901 "PascalLexer.cpp"
+		}
+		else if ((LA(1) == 0xa /* '\n' */ )) {
+			match('\n' /* charlit */ );
+#line 1154 "pascal.g"
+			newline();
+#line 907 "PascalLexer.cpp"
+		}
+		else if ((_tokenSet_0.member(LA(1)))) {
+			{
+			match(_tokenSet_0);
+			}
+		}
+		else {
+			goto _loop427;
+		}
+		
+	}
+	_loop427:;
+	} // ( ... )*
+	match("*)");
+#line 1158 "pascal.g"
+	_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+#line 924 "PascalLexer.cpp"
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mCOMMENT_2(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = COMMENT_2;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('{' /* charlit */ );
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == 0xd /* '\r' */ ) && (LA(2) == 0xa /* '\n' */ ) && ((LA(3) >= 0x0 /* '\0' */  && LA(3) <= 0xff)) && (true)) {
+			match('\r' /* charlit */ );
+			match('\n' /* charlit */ );
+#line 1164 "pascal.g"
+			newline();
+#line 946 "PascalLexer.cpp"
+		}
+		else if ((LA(1) == 0xd /* '\r' */ ) && ((LA(2) >= 0x0 /* '\0' */  && LA(2) <= 0xff)) && (true) && (true)) {
+			match('\r' /* charlit */ );
+#line 1165 "pascal.g"
+			newline();
+#line 952 "PascalLexer.cpp"
+		}
+		else if ((LA(1) == 0xa /* '\n' */ )) {
+			match('\n' /* charlit */ );
+#line 1166 "pascal.g"
+			newline();
+#line 958 "PascalLexer.cpp"
+		}
+		else if ((_tokenSet_1.member(LA(1)))) {
+			{
+			match(_tokenSet_1);
+			}
+		}
+		else {
+			goto _loop431;
+		}
+		
+	}
+	_loop431:;
+	} // ( ... )*
+	match('}' /* charlit */ );
+#line 1170 "pascal.g"
+	_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+#line 975 "PascalLexer.cpp"
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mCOMMENT_3(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = COMMENT_3;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match("//");
+	{ // ( ... )*
+	for (;;) {
+		if ((_tokenSet_2.member(LA(1)))) {
+			matchNot('\n' /* charlit */ );
+		}
+		else {
+			goto _loop434;
+		}
+		
+	}
+	_loop434:;
+	} // ( ... )*
+	match('\n' /* charlit */ );
+#line 1175 "pascal.g"
+	_ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP;
+#line 1005 "PascalLexer.cpp"
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mIDENT(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = IDENT;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	{
+	matchRange('a','z');
+	}
+	{ // ( ... )*
+	for (;;) {
+		switch ( LA(1)) {
+		case 0x61 /* 'a' */ :
+		case 0x62 /* 'b' */ :
+		case 0x63 /* 'c' */ :
+		case 0x64 /* 'd' */ :
+		case 0x65 /* 'e' */ :
+		case 0x66 /* 'f' */ :
+		case 0x67 /* 'g' */ :
+		case 0x68 /* 'h' */ :
+		case 0x69 /* 'i' */ :
+		case 0x6a /* 'j' */ :
+		case 0x6b /* 'k' */ :
+		case 0x6c /* 'l' */ :
+		case 0x6d /* 'm' */ :
+		case 0x6e /* 'n' */ :
+		case 0x6f /* 'o' */ :
+		case 0x70 /* 'p' */ :
+		case 0x71 /* 'q' */ :
+		case 0x72 /* 'r' */ :
+		case 0x73 /* 's' */ :
+		case 0x74 /* 't' */ :
+		case 0x75 /* 'u' */ :
+		case 0x76 /* 'v' */ :
+		case 0x77 /* 'w' */ :
+		case 0x78 /* 'x' */ :
+		case 0x79 /* 'y' */ :
+		case 0x7a /* 'z' */ :
+		{
+			matchRange('a','z');
+			break;
+		}
+		case 0x30 /* '0' */ :
+		case 0x31 /* '1' */ :
+		case 0x32 /* '2' */ :
+		case 0x33 /* '3' */ :
+		case 0x34 /* '4' */ :
+		case 0x35 /* '5' */ :
+		case 0x36 /* '6' */ :
+		case 0x37 /* '7' */ :
+		case 0x38 /* '8' */ :
+		case 0x39 /* '9' */ :
+		{
+			matchRange('0','9');
+			break;
+		}
+		case 0x5f /* '_' */ :
+		{
+			match('_' /* charlit */ );
+			break;
+		}
+		default:
+		{
+			goto _loop438;
+		}
+		}
+	}
+	_loop438:;
+	} // ( ... )*
+	_ttype = testLiteralsTable(_ttype);
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mSTRING_LITERAL(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = STRING_LITERAL;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	match('\'' /* charlit */ );
+	{ // ( ... )*
+	for (;;) {
+		if ((LA(1) == 0x27 /* '\'' */ ) && (LA(2) == 0x27 /* '\'' */ )) {
+			match("\'\'");
+		}
+		else if ((_tokenSet_3.member(LA(1)))) {
+			{
+			match(_tokenSet_3);
+			}
+		}
+		else {
+			goto _loop442;
+		}
+		
+	}
+	_loop442:;
+	} // ( ... )*
+	match('\'' /* charlit */ );
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+/** a numeric literal.  Form is (from Wirth)
+ *  digits
+ *  digits . digits
+ *  digits . digits exponent
+ *  digits exponent
+ */
+void PascalLexer::mNUM_INT(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = NUM_INT;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	{ // ( ... )+
+	int _cnt445=0;
+	for (;;) {
+		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
+			matchRange('0','9');
+		}
+		else {
+			if ( _cnt445>=1 ) { goto _loop445; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+		}
+		
+		_cnt445++;
+	}
+	_loop445:;
+	}  // ( ... )+
+	{
+	if ((LA(1) == 0x65 /* 'e' */ )) {
+		mEXPONENT(false);
+#line 1204 "pascal.g"
+		_ttype = NUM_REAL;
+#line 1153 "PascalLexer.cpp"
+	}
+	else {
+		{
+		if (((LA(1) == 0x2e /* '.' */ ))&&((LA(2)!='.')&&(LA(2)!=')'))) {
+			match('.' /* charlit */ );
+#line 1201 "pascal.g"
+			_ttype = NUM_REAL;
+#line 1161 "PascalLexer.cpp"
+			{ // ( ... )+
+			int _cnt449=0;
+			for (;;) {
+				if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
+					matchRange('0','9');
+				}
+				else {
+					if ( _cnt449>=1 ) { goto _loop449; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+				}
+				
+				_cnt449++;
+			}
+			_loop449:;
+			}  // ( ... )+
+			{
+			if ((LA(1) == 0x65 /* 'e' */ )) {
+				mEXPONENT(false);
+			}
+			else {
+			}
+			
+			}
+		}
+		else {
+		}
+		
+		}
+	}
+	
+	}
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+void PascalLexer::mEXPONENT(bool _createToken) {
+	int _ttype; ANTLR_USE_NAMESPACE(antlr)RefToken _token; ANTLR_USE_NAMESPACE(std)string::size_type _begin = text.length();
+	_ttype = EXPONENT;
+	ANTLR_USE_NAMESPACE(std)string::size_type _saveIndex;
+	
+	{
+	match('e' /* charlit */ );
+	}
+	{
+	switch ( LA(1)) {
+	case 0x2b /* '+' */ :
+	{
+		match('+' /* charlit */ );
+		break;
+	}
+	case 0x2d /* '-' */ :
+	{
+		match('-' /* charlit */ );
+		break;
+	}
+	case 0x30 /* '0' */ :
+	case 0x31 /* '1' */ :
+	case 0x32 /* '2' */ :
+	case 0x33 /* '3' */ :
+	case 0x34 /* '4' */ :
+	case 0x35 /* '5' */ :
+	case 0x36 /* '6' */ :
+	case 0x37 /* '7' */ :
+	case 0x38 /* '8' */ :
+	case 0x39 /* '9' */ :
+	{
+		break;
+	}
+	default:
+	{
+		throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());
+	}
+	}
+	}
+	{ // ( ... )+
+	int _cnt455=0;
+	for (;;) {
+		if (((LA(1) >= 0x30 /* '0' */  && LA(1) <= 0x39 /* '9' */ ))) {
+			matchRange('0','9');
+		}
+		else {
+			if ( _cnt455>=1 ) { goto _loop455; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltForCharException(LA(1), getFilename(), getLine(), getColumn());}
+		}
+		
+		_cnt455++;
+	}
+	_loop455:;
+	}  // ( ... )+
+	if ( _createToken && _token==ANTLR_USE_NAMESPACE(antlr)nullToken && _ttype!=ANTLR_USE_NAMESPACE(antlr)Token::SKIP ) {
+	   _token = makeToken(_ttype);
+	   _token->setText(text.substr(_begin, text.length()-_begin));
+	}
+	_returnToken = _token;
+	_saveIndex=0;
+}
+
+
+const unsigned long PascalLexer::_tokenSet_0_data_[] = { 4294958079UL, 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
+// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
+// \" # $ % & \' ( ) + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C 
+// D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c d 
+// e f g h i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 0x81 0x82 
+// 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 
+// 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 0x9d 0x9e 
+// 0x9f 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 0xab 0xac 
+// 0xad 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 0xb9 0xba 
+// 0xbb 0xbc 0xbd 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_0(_tokenSet_0_data_,16);
+const unsigned long PascalLexer::_tokenSet_1_data_[] = { 4294958079UL, 4294967295UL, 4294967295UL, 3758096383UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xe 0xf 0x10 0x11 0x12 
+// 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f   ! 
+// \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B 
+// C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a b c 
+// d e f g h i j k l m n o p q r s t u v w x y z { | ~ 0x7f 0x80 0x81 0x82 
+// 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 0x8f 0x90 
+// 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 0x9d 0x9e 
+// 0x9f 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 0xab 0xac 
+// 0xad 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 0xb9 0xba 
+// 0xbb 0xbc 0xbd 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_1(_tokenSet_1_data_,16);
+const unsigned long PascalLexer::_tokenSet_2_data_[] = { 4294966271UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xb 0xc 0xd 0xe 0xf 0x10 0x11 
+// 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 
+//   ! \" # $ % & \' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 
+// A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` a 
+// b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 
+// 0x81 0x82 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 
+// 0x8f 0x90 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 
+// 0x9d 0x9e 0x9f 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 
+// 0xab 0xac 0xad 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 
+// 0xb9 0xba 0xbb 0xbc 0xbd 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_2(_tokenSet_2_data_,16);
+const unsigned long PascalLexer::_tokenSet_3_data_[] = { 4294967295UL, 4294967167UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 4294967295UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0xa 0xb 0xc 0xd 0xe 0xf 0x10 
+// 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 
+// 0x1f   ! \" # $ % & ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? 
+// @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ 0x5c ] ^ _ ` 
+// a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~ 0x7f 0x80 
+// 0x81 0x82 0x83 0x84 0x85 0x86 0x87 0x88 0x89 0x8a 0x8b 0x8c 0x8d 0x8e 
+// 0x8f 0x90 0x91 0x92 0x93 0x94 0x95 0x96 0x97 0x98 0x99 0x9a 0x9b 0x9c 
+// 0x9d 0x9e 0x9f 0xa0 0xa1 0xa2 0xa3 0xa4 0xa5 0xa6 0xa7 0xa8 0xa9 0xaa 
+// 0xab 0xac 0xad 0xae 0xaf 0xb0 0xb1 0xb2 0xb3 0xb4 0xb5 0xb6 0xb7 0xb8 
+// 0xb9 0xba 0xbb 0xbc 0xbd 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalLexer::_tokenSet_3(_tokenSet_3_data_,16);
+
diff --git a/languages/pascal/PascalLexer.hpp b/languages/pascal/PascalLexer.hpp
new file mode 100644
index 00000000..f63ac84d
--- /dev/null
+++ b/languages/pascal/PascalLexer.hpp
@@ -0,0 +1,121 @@
+#ifndef INC_PascalLexer_hpp_
+#define INC_PascalLexer_hpp_
+
+#line 29 "pascal.g"
+
+        #include "problemreporter.h"
+        #include "PascalAST.hpp"
+
+        #include <qlistview.h>
+        #include <kdebug.h>
+
+        #define SET_POSITION(ast,t)\
+        { \
+                RefPascalAST(ast)->setLine( t->getLine() );\
+                RefPascalAST(ast)->setColumn( t->getColumn() ); \
+        }
+
+#line 19 "PascalLexer.hpp"
+#include <antlr/config.hpp>
+/* $ANTLR 2.7.7 (20061129): "pascal.g" -> "PascalLexer.hpp"$ */
+#include <antlr/CommonToken.hpp>
+#include <antlr/InputBuffer.hpp>
+#include <antlr/BitSet.hpp>
+#include "PascalTokenTypes.hpp"
+#include <antlr/CharScanner.hpp>
+class CUSTOM_API PascalLexer : public ANTLR_USE_NAMESPACE(antlr)CharScanner, public PascalTokenTypes
+{
+#line 1067 "pascal.g"
+
+private:
+        ProblemReporter* m_problemReporter;
+        unsigned int m_numberOfErrors;
+
+public:
+        void resetErrors()                              { m_numberOfErrors = 0; }
+        unsigned int numberOfErrors() const             { return m_numberOfErrors; }
+        void setProblemReporter( ProblemReporter* r )   { m_problemReporter = r; }
+
+        virtual void reportError( const ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex ){
+                m_problemReporter->reportError( ex.getMessage().c_str(),
+                                                ex.getFilename().c_str(),
+                                                ex.getLine(),
+                                                ex.getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        virtual void reportError( const ANTLR_USE_NAMESPACE(std)string& errorMessage ){
+                m_problemReporter->reportError( errorMessage.c_str(),
+                                                getFilename().c_str(),
+                                                getLine(), getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        virtual void reportWarning( const ANTLR_USE_NAMESPACE(std)string& warnMessage ){
+                m_problemReporter->reportWarning( warnMessage.c_str(),
+                                                getFilename().c_str(),
+                                                getLine(), getColumn() );
+        }
+#line 30 "PascalLexer.hpp"
+private:
+	void initLiterals();
+public:
+	bool getCaseSensitiveLiterals() const
+	{
+		return false;
+	}
+public:
+	PascalLexer(ANTLR_USE_NAMESPACE(std)istream& in);
+	PascalLexer(ANTLR_USE_NAMESPACE(antlr)InputBuffer& ib);
+	PascalLexer(const ANTLR_USE_NAMESPACE(antlr)LexerSharedInputState& state);
+	ANTLR_USE_NAMESPACE(antlr)RefToken nextToken();
+	public: void mPLUS(bool _createToken);
+	public: void mMINUS(bool _createToken);
+	public: void mSTAR(bool _createToken);
+	public: void mSLASH(bool _createToken);
+	public: void mASSIGN(bool _createToken);
+	public: void mCOMMA(bool _createToken);
+	public: void mSEMI(bool _createToken);
+	public: void mCOLON(bool _createToken);
+	public: void mEQUAL(bool _createToken);
+	public: void mNOT_EQUAL(bool _createToken);
+	public: void mLTH(bool _createToken);
+	public: void mLE(bool _createToken);
+	public: void mGE(bool _createToken);
+	public: void mGT(bool _createToken);
+	public: void mLPAREN(bool _createToken);
+	public: void mRPAREN(bool _createToken);
+	public: void mLBRACK(bool _createToken);
+	public: void mLBRACK2(bool _createToken);
+	public: void mRBRACK(bool _createToken);
+	public: void mRBRACK2(bool _createToken);
+	public: void mPOINTER(bool _createToken);
+	public: void mAT(bool _createToken);
+	public: void mDOT(bool _createToken);
+	public: void mLCURLY(bool _createToken);
+	public: void mRCURLY(bool _createToken);
+	public: void mPLUSEQ(bool _createToken);
+	public: void mMINUSEQ(bool _createToken);
+	public: void mSTAREQ(bool _createToken);
+	public: void mSLASHQE(bool _createToken);
+	public: void mWS(bool _createToken);
+	public: void mCOMMENT_1(bool _createToken);
+	public: void mCOMMENT_2(bool _createToken);
+	public: void mCOMMENT_3(bool _createToken);
+	public: void mIDENT(bool _createToken);
+	public: void mSTRING_LITERAL(bool _createToken);
+	public: void mNUM_INT(bool _createToken);
+	protected: void mEXPONENT(bool _createToken);
+private:
+	
+	static const unsigned long _tokenSet_0_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0;
+	static const unsigned long _tokenSet_1_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1;
+	static const unsigned long _tokenSet_2_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2;
+	static const unsigned long _tokenSet_3_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3;
+};
+
+#endif /*INC_PascalLexer_hpp_*/
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);
+
+
diff --git a/languages/pascal/PascalParser.hpp b/languages/pascal/PascalParser.hpp
new file mode 100644
index 00000000..d37d76c5
--- /dev/null
+++ b/languages/pascal/PascalParser.hpp
@@ -0,0 +1,422 @@
+#ifndef INC_PascalParser_hpp_
+#define INC_PascalParser_hpp_
+
+#line 29 "pascal.g"
+
+        #include "problemreporter.h"
+        #include "PascalAST.hpp"
+
+        #include <qlistview.h>
+        #include <kdebug.h>
+
+        #define SET_POSITION(ast,t)\
+        { \
+                RefPascalAST(ast)->setLine( t->getLine() );\
+                RefPascalAST(ast)->setColumn( t->getColumn() ); \
+        }
+
+#line 19 "PascalParser.hpp"
+#include <antlr/config.hpp>
+/* $ANTLR 2.7.7 (20061129): "pascal.g" -> "PascalParser.hpp"$ */
+#include <antlr/TokenStream.hpp>
+#include <antlr/TokenBuffer.hpp>
+#include "PascalTokenTypes.hpp"
+#include <antlr/LLkParser.hpp>
+
+class CUSTOM_API PascalParser : public ANTLR_USE_NAMESPACE(antlr)LLkParser, public PascalTokenTypes
+{
+#line 90 "pascal.g"
+
+private:
+        unsigned int m_numberOfErrors;
+        ProblemReporter* m_problemReporter;
+
+public:
+        void resetErrors()                              { m_numberOfErrors = 0; }
+        unsigned int numberOfErrors() const             { return m_numberOfErrors; }
+        void setProblemReporter( ProblemReporter* r )   { m_problemReporter = r; }
+
+        void reportError( const ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex ){
+                m_problemReporter->reportError( ex.getMessage().c_str(),
+                                                ex.getFilename().c_str(),
+                                                ex.getLine(),
+                                                ex.getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        void reportError( const ANTLR_USE_NAMESPACE(std)string& errorMessage ){
+                m_problemReporter->reportError( errorMessage.c_str(),
+                                                getFilename().c_str(),
+                                                LT(1)->getLine(),
+                                                LT(1)->getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        void reportMessage( const ANTLR_USE_NAMESPACE(std)string& message ){
+                m_problemReporter->reportMessage( message.c_str(),
+                                                getFilename().c_str(),
+                                                LT(1)->getLine(),
+                                                LT(1)->getColumn() );
+        }
+#line 30 "PascalParser.hpp"
+public:
+	void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
+protected:
+	PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf, int k);
+public:
+	PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenBuffer& tokenBuf);
+protected:
+	PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer, int k);
+public:
+	PascalParser(ANTLR_USE_NAMESPACE(antlr)TokenStream& lexer);
+	PascalParser(const ANTLR_USE_NAMESPACE(antlr)ParserSharedInputState& state);
+	int getNumTokens() const
+	{
+		return PascalParser::NUM_TOKENS;
+	}
+	const char* getTokenName( int type ) const
+	{
+		if( type > getNumTokens() ) return 0;
+		return PascalParser::tokenNames[type];
+	}
+	const char* const* getTokenNames() const
+	{
+		return PascalParser::tokenNames;
+	}
+	public: void compilationUnit();
+	public: void program();
+	public: void library();
+	public: void unit();
+	public: void programHeading();
+	public: void usesClause();
+	public: void block();
+	public: void identifier();
+	public: void libraryBlock();
+	public: void exportsClause();
+	public: void declarationPart();
+	public: void statementPart();
+	public: void exportsList();
+	public: void exportsEntry();
+	public: void integerConstant();
+	public: void stringConstant();
+	public: void identifierList();
+	public: void interfacePart();
+	public: void implementationPart();
+	public: void initializationPart();
+	public: void finalizationPart();
+	public: void realizationPart();
+	public: void constantDeclarationPart();
+	public: void typeDeclarationPart();
+	public: void procedureHeadersPart();
+	public: void statement();
+	public: void labelDeclarationPart();
+	public: void resourcestringDeclarationPart();
+	public: void variableDeclarationPart();
+	public: void procedureAndFunctionDeclarationPart();
+	public: void label();
+	public: void constantDeclaration();
+	public: void typedConstantDeclaration();
+	public: void stringConstantDeclaration();
+	public: void string();
+	public: void typeDeclaration();
+	public: void variableDeclaration();
+	public: void type();
+	public: void procedureAndFunctionDeclaration();
+	public: void procedureDeclaration();
+	public: void functionDeclaration();
+	public: void constructorDeclaration();
+	public: void destructorDeclaration();
+	public: void compoundStatement();
+	public: void procedureHeader();
+	public: void subroutineBlock();
+	public: void functionHeader();
+	public: void qualifiedMethodIdentifier();
+	public: void formalParameterList();
+	public: void modifiers();
+	public: void externalDirective();
+	public: void functionHeaderEnding();
+	public: void parameterDeclaration();
+	public: void valueParameter();
+	public: void variableParameter();
+	public: void constantParameter();
+	public: void untypedParameterPart();
+	public: void callModifiers();
+	public: void expression();
+	public: void typedConstant();
+	public: void constant();
+	public: void recordConstant();
+	public: void arrayConstant();
+	public: void proceduralConstant();
+	public: void addressConstant();
+	public: void simpleType();
+	public: void subrangeTypeOrTypeIdentifier();
+	public: void enumeratedType();
+	public: void stringType();
+	public: void structuredType();
+	public: void pointerType();
+	public: void proceduralType();
+	public: void ordinalType();
+	public: void realType();
+	public: void typeIdentifier();
+	public: void subrangeType();
+	public: void assignedEnumList();
+	public: void unsignedInteger();
+	public: void arrayType();
+	public: void recordType();
+	public: void objectType();
+	public: void classType();
+	public: void setType();
+	public: void fileType();
+	public: void arrayIndexType();
+	public: void arraySubrangeType();
+	public: void fieldList();
+	public: void fixedField();
+	public: void variantPart();
+	public: void variant();
+	public: void proceduralTypePart1();
+	public: void heritage();
+	public: void componentList();
+	public: void objectVisibilitySpecifier();
+	public: void fieldDefinition();
+	public: void methodDefinition();
+	public: void constructorHeader();
+	public: void destructorHeader();
+	public: void methodDirectives();
+	public: void classComponentList();
+	public: void classVisibilitySpecifier();
+	public: void classMethodDefinition();
+	public: void propertyDefinition();
+	public: void classMethodDirectives();
+	public: void directiveVariants();
+	public: void propertyInterface();
+	public: void propertySpecifiers();
+	public: void propertyParameterList();
+	public: void readSpecifier();
+	public: void writeSpecifier();
+	public: void defaultSpecifier();
+	public: void fieldOrMethod();
+	public: void simpleExpression();
+	public: void expressionSign();
+	public: void term();
+	public: void factor();
+	public: void identifierOrValueTypecastOrFunctionCall();
+	public: void unsignedConstant();
+	public: void setConstructor();
+	public: void addressFactor();
+	public: void expressions();
+	public: void functionCall();
+	public: void actualParameterList();
+	public: void setGroup();
+	public: void valueTypecast();
+	public: void simpleStatement();
+	public: void structuredStatement();
+	public: void assignmentStatement();
+	public: void procedureStatement();
+	public: void gotoStatement();
+	public: void raiseStatement();
+	public: void identifierOrArrayIdentifier();
+	public: void assignmentOperator();
+	public: void repetitiveStatement();
+	public: void conditionalStatement();
+	public: void exceptionStatement();
+	public: void withStatement();
+	public: void ifStatement();
+	public: void caseStatement();
+	public: void forStatement();
+	public: void repeatStatement();
+	public: void whileStatement();
+	public: void caseListElement();
+	public: void constList();
+	public: void forList();
+	public: void initialValue();
+	public: void finalValue();
+	public: void recordVariableList();
+	public: void variable();
+	public: void operatorDefinition();
+	public: void assignmentOperatorDefinition();
+	public: void arithmeticOperatorDefinition();
+	public: void comparisonOperatorDefinition();
+	public: void tryStatement();
+	public: void statements();
+	public: void exceptOrFinallyPart();
+	public: void exceptionHandlers();
+	public: void exceptionHandler();
+	public: void sign();
+	public: void constantChr();
+	public: void unsignedNumber();
+	public: void unsignedReal();
+public:
+	ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
+	{
+		return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST);
+	}
+	
+protected:
+	RefPascalAST returnAST;
+private:
+	static const char* tokenNames[];
+#ifndef NO_STATIC_CONSTS
+	static const int NUM_TOKENS = 190;
+#else
+	enum {
+		NUM_TOKENS = 190
+	};
+#endif
+	
+	static const unsigned long _tokenSet_0_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0;
+	static const unsigned long _tokenSet_1_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1;
+	static const unsigned long _tokenSet_2_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2;
+	static const unsigned long _tokenSet_3_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3;
+	static const unsigned long _tokenSet_4_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4;
+	static const unsigned long _tokenSet_5_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5;
+	static const unsigned long _tokenSet_6_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6;
+	static const unsigned long _tokenSet_7_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_7;
+	static const unsigned long _tokenSet_8_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_8;
+	static const unsigned long _tokenSet_9_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_9;
+	static const unsigned long _tokenSet_10_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_10;
+	static const unsigned long _tokenSet_11_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_11;
+	static const unsigned long _tokenSet_12_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_12;
+	static const unsigned long _tokenSet_13_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_13;
+	static const unsigned long _tokenSet_14_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_14;
+	static const unsigned long _tokenSet_15_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_15;
+	static const unsigned long _tokenSet_16_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_16;
+	static const unsigned long _tokenSet_17_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_17;
+	static const unsigned long _tokenSet_18_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_18;
+	static const unsigned long _tokenSet_19_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_19;
+	static const unsigned long _tokenSet_20_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_20;
+	static const unsigned long _tokenSet_21_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_21;
+	static const unsigned long _tokenSet_22_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_22;
+	static const unsigned long _tokenSet_23_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_23;
+	static const unsigned long _tokenSet_24_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_24;
+	static const unsigned long _tokenSet_25_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_25;
+	static const unsigned long _tokenSet_26_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_26;
+	static const unsigned long _tokenSet_27_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_27;
+	static const unsigned long _tokenSet_28_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_28;
+	static const unsigned long _tokenSet_29_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_29;
+	static const unsigned long _tokenSet_30_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_30;
+	static const unsigned long _tokenSet_31_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_31;
+	static const unsigned long _tokenSet_32_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_32;
+	static const unsigned long _tokenSet_33_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_33;
+	static const unsigned long _tokenSet_34_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_34;
+	static const unsigned long _tokenSet_35_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_35;
+	static const unsigned long _tokenSet_36_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_36;
+	static const unsigned long _tokenSet_37_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_37;
+	static const unsigned long _tokenSet_38_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_38;
+	static const unsigned long _tokenSet_39_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_39;
+	static const unsigned long _tokenSet_40_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_40;
+	static const unsigned long _tokenSet_41_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_41;
+	static const unsigned long _tokenSet_42_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_42;
+	static const unsigned long _tokenSet_43_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_43;
+	static const unsigned long _tokenSet_44_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_44;
+	static const unsigned long _tokenSet_45_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_45;
+	static const unsigned long _tokenSet_46_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_46;
+	static const unsigned long _tokenSet_47_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_47;
+	static const unsigned long _tokenSet_48_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_48;
+	static const unsigned long _tokenSet_49_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_49;
+	static const unsigned long _tokenSet_50_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_50;
+	static const unsigned long _tokenSet_51_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_51;
+	static const unsigned long _tokenSet_52_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_52;
+	static const unsigned long _tokenSet_53_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_53;
+	static const unsigned long _tokenSet_54_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_54;
+	static const unsigned long _tokenSet_55_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_55;
+	static const unsigned long _tokenSet_56_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_56;
+	static const unsigned long _tokenSet_57_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_57;
+	static const unsigned long _tokenSet_58_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_58;
+	static const unsigned long _tokenSet_59_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_59;
+	static const unsigned long _tokenSet_60_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_60;
+	static const unsigned long _tokenSet_61_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_61;
+	static const unsigned long _tokenSet_62_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_62;
+	static const unsigned long _tokenSet_63_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_63;
+	static const unsigned long _tokenSet_64_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_64;
+	static const unsigned long _tokenSet_65_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_65;
+	static const unsigned long _tokenSet_66_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_66;
+	static const unsigned long _tokenSet_67_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_67;
+	static const unsigned long _tokenSet_68_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_68;
+	static const unsigned long _tokenSet_69_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_69;
+	static const unsigned long _tokenSet_70_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_70;
+	static const unsigned long _tokenSet_71_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_71;
+	static const unsigned long _tokenSet_72_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_72;
+	static const unsigned long _tokenSet_73_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_73;
+	static const unsigned long _tokenSet_74_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_74;
+	static const unsigned long _tokenSet_75_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_75;
+	static const unsigned long _tokenSet_76_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_76;
+};
+
+#endif /*INC_PascalParser_hpp_*/
diff --git a/languages/pascal/PascalStoreWalker.cpp b/languages/pascal/PascalStoreWalker.cpp
new file mode 100644
index 00000000..96c69fe4
--- /dev/null
+++ b/languages/pascal/PascalStoreWalker.cpp
@@ -0,0 +1,3409 @@
+/* $ANTLR 2.7.7 (20061129): "pascal.tree.g" -> "PascalStoreWalker.cpp"$ */
+#include "PascalStoreWalker.hpp"
+#include <antlr/Token.hpp>
+#include <antlr/AST.hpp>
+#include <antlr/NoViableAltException.hpp>
+#include <antlr/MismatchedTokenException.hpp>
+#include <antlr/SemanticException.hpp>
+#include <antlr/BitSet.hpp>
+#line 1 "pascal.tree.g"
+#line 11 "PascalStoreWalker.cpp"
+PascalStoreWalker::PascalStoreWalker()
+	: ANTLR_USE_NAMESPACE(antlr)TreeParser() {
+}
+
+void PascalStoreWalker::program(RefPascalAST _t) {
+	RefPascalAST program_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		programHeading(_t);
+		_t = _retTree;
+		block(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::programHeading(RefPascalAST _t) {
+	RefPascalAST programHeading_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case PROGRAM:
+		{
+			RefPascalAST __t3 = _t;
+			RefPascalAST tmp1_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROGRAM);
+			_t = _t->getFirstChild();
+			RefPascalAST tmp2_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			identifierList(_t);
+			_t = _retTree;
+			_t = __t3;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case UNIT:
+		{
+			RefPascalAST __t4 = _t;
+			RefPascalAST tmp3_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),UNIT);
+			_t = _t->getFirstChild();
+			RefPascalAST tmp4_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			_t = __t4;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::block(RefPascalAST _t) {
+	RefPascalAST block_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		{ // ( ... )*
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case LABEL:
+			{
+				labelDeclarationPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case CONST:
+			{
+				constantDefinitionPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case TYPE:
+			{
+				typeDefinitionPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case VAR:
+			{
+				variableDeclarationPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case PROCEDURE:
+			case FUNCTION:
+			{
+				procedureAndFunctionDeclarationPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case USES:
+			{
+				usesUnitsPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case IMPLEMENTATION:
+			{
+				RefPascalAST tmp5_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IMPLEMENTATION);
+				_t = _t->getNextSibling();
+				break;
+			}
+			default:
+			{
+				goto _loop8;
+			}
+			}
+		}
+		_loop8:;
+		} // ( ... )*
+		compoundStatement(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::identifierList(RefPascalAST _t) {
+	RefPascalAST identifierList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t104 = _t;
+		RefPascalAST tmp6_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDLIST);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt106=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == IDENT)) {
+				RefPascalAST tmp7_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+				_t = _t->getNextSibling();
+			}
+			else {
+				if ( _cnt106>=1 ) { goto _loop106; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt106++;
+		}
+		_loop106:;
+		}  // ( ... )+
+		_t = __t104;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::identifier(RefPascalAST _t) {
+	RefPascalAST identifier_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST tmp8_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::labelDeclarationPart(RefPascalAST _t) {
+	RefPascalAST labelDeclarationPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t12 = _t;
+		RefPascalAST tmp9_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LABEL);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt14=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == NUM_INT)) {
+				label(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt14>=1 ) { goto _loop14; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt14++;
+		}
+		_loop14:;
+		}  // ( ... )+
+		_t = __t12;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::constantDefinitionPart(RefPascalAST _t) {
+	RefPascalAST constantDefinitionPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t17 = _t;
+		RefPascalAST tmp10_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONST);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt19=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == EQUAL)) {
+				constantDefinition(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt19>=1 ) { goto _loop19; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt19++;
+		}
+		_loop19:;
+		}  // ( ... )+
+		_t = __t17;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::typeDefinitionPart(RefPascalAST _t) {
+	RefPascalAST typeDefinitionPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t31 = _t;
+		RefPascalAST tmp11_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TYPE);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt33=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == TYPEDECL)) {
+				typeDefinition(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt33>=1 ) { goto _loop33; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt33++;
+		}
+		_loop33:;
+		}  // ( ... )+
+		_t = __t31;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+/** Yields a list of VARDECL-rooted subtrees with VAR at the overall root */
+void PascalStoreWalker::variableDeclarationPart(RefPascalAST _t) {
+	RefPascalAST variableDeclarationPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t83 = _t;
+		RefPascalAST tmp12_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VAR);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt85=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == VARDECL)) {
+				variableDeclaration(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt85>=1 ) { goto _loop85; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt85++;
+		}
+		_loop85:;
+		}  // ( ... )+
+		_t = __t83;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::procedureAndFunctionDeclarationPart(RefPascalAST _t) {
+	RefPascalAST procedureAndFunctionDeclarationPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		procedureOrFunctionDeclaration(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::usesUnitsPart(RefPascalAST _t) {
+	RefPascalAST usesUnitsPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t10 = _t;
+		RefPascalAST tmp13_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),USES);
+		_t = _t->getFirstChild();
+		identifierList(_t);
+		_t = _retTree;
+		_t = __t10;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::compoundStatement(RefPascalAST _t) {
+	RefPascalAST compoundStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		statements(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::label(RefPascalAST _t) {
+	RefPascalAST label_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST tmp14_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::constantDefinition(RefPascalAST _t) {
+	RefPascalAST constantDefinition_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t21 = _t;
+		RefPascalAST tmp15_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUAL);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp16_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		constant(_t);
+		_t = _retTree;
+		_t = __t21;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::constant(RefPascalAST _t) {
+	RefPascalAST constant_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case NUM_INT:
+		{
+			RefPascalAST tmp17_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case NUM_REAL:
+		{
+			RefPascalAST tmp18_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case PLUS:
+		{
+			RefPascalAST __t23 = _t;
+			RefPascalAST tmp19_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case NUM_INT:
+			{
+				RefPascalAST tmp20_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case NUM_REAL:
+			{
+				RefPascalAST tmp21_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case IDENT:
+			{
+				RefPascalAST tmp22_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t23;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case MINUS:
+		{
+			RefPascalAST __t25 = _t;
+			RefPascalAST tmp23_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MINUS);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case NUM_INT:
+			{
+				RefPascalAST tmp24_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case NUM_REAL:
+			{
+				RefPascalAST tmp25_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case IDENT:
+			{
+				RefPascalAST tmp26_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t25;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case IDENT:
+		{
+			RefPascalAST tmp27_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case STRING_LITERAL:
+		{
+			RefPascalAST tmp28_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING_LITERAL);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case CHR:
+		{
+			RefPascalAST __t27 = _t;
+			RefPascalAST tmp29_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHR);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case NUM_INT:
+			{
+				RefPascalAST tmp30_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case NUM_REAL:
+			{
+				RefPascalAST tmp31_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+				_t = _t->getNextSibling();
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t27;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::string(RefPascalAST _t) {
+	RefPascalAST string_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST tmp32_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING_LITERAL);
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::typeDefinition(RefPascalAST _t) {
+	RefPascalAST typeDefinition_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t35 = _t;
+		RefPascalAST tmp33_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TYPEDECL);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp34_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case SCALARTYPE:
+		case ARRAY:
+		case INTEGER:
+		case BOOLEAN:
+		case CHAR:
+		case DOTDOT:
+		case REAL:
+		case STRING:
+		case PACKED:
+		case RECORD:
+		case SET:
+		case FILE:
+		case POINTER:
+		case IDENT:
+		{
+			type(_t);
+			_t = _retTree;
+			break;
+		}
+		case FUNCTION:
+		{
+			RefPascalAST __t37 = _t;
+			RefPascalAST tmp35_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case ARGDECLS:
+			{
+				formalParameterList(_t);
+				_t = _retTree;
+				break;
+			}
+			case INTEGER:
+			case BOOLEAN:
+			case CHAR:
+			case REAL:
+			case STRING:
+			case IDENT:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			resultType(_t);
+			_t = _retTree;
+			_t = __t37;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case PROCEDURE:
+		{
+			RefPascalAST __t39 = _t;
+			RefPascalAST tmp36_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case ARGDECLS:
+			{
+				formalParameterList(_t);
+				_t = _retTree;
+				break;
+			}
+			case 3:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t39;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t35;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::type(RefPascalAST _t) {
+	RefPascalAST type_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case SCALARTYPE:
+		{
+			RefPascalAST __t42 = _t;
+			RefPascalAST tmp37_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SCALARTYPE);
+			_t = _t->getFirstChild();
+			identifierList(_t);
+			_t = _retTree;
+			_t = __t42;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case DOTDOT:
+		{
+			RefPascalAST __t43 = _t;
+			RefPascalAST tmp38_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOTDOT);
+			_t = _t->getFirstChild();
+			constant(_t);
+			_t = _retTree;
+			constant(_t);
+			_t = _retTree;
+			_t = __t43;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case INTEGER:
+		case BOOLEAN:
+		case CHAR:
+		case REAL:
+		case STRING:
+		case IDENT:
+		{
+			typeIdentifier(_t);
+			_t = _retTree;
+			break;
+		}
+		case ARRAY:
+		case PACKED:
+		case RECORD:
+		case SET:
+		case FILE:
+		{
+			structuredType(_t);
+			_t = _retTree;
+			break;
+		}
+		case POINTER:
+		{
+			RefPascalAST __t44 = _t;
+			RefPascalAST tmp39_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),POINTER);
+			_t = _t->getFirstChild();
+			typeIdentifier(_t);
+			_t = _retTree;
+			_t = __t44;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::formalParameterList(RefPascalAST _t) {
+	RefPascalAST formalParameterList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t94 = _t;
+		RefPascalAST tmp40_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARGDECLS);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt96=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_0.member(_t->getType()))) {
+				formalParameterSection(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt96>=1 ) { goto _loop96; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt96++;
+		}
+		_loop96:;
+		}  // ( ... )+
+		_t = __t94;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::resultType(RefPascalAST _t) {
+	RefPascalAST resultType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		typeIdentifier(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::typeIdentifier(RefPascalAST _t) {
+	RefPascalAST typeIdentifier_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case IDENT:
+		{
+			RefPascalAST tmp41_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case CHAR:
+		{
+			RefPascalAST tmp42_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHAR);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case BOOLEAN:
+		{
+			RefPascalAST tmp43_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BOOLEAN);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case INTEGER:
+		{
+			RefPascalAST tmp44_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),INTEGER);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case REAL:
+		{
+			RefPascalAST tmp45_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REAL);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case STRING:
+		{
+			RefPascalAST __t46 = _t;
+			RefPascalAST tmp46_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STRING);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case IDENT:
+			{
+				RefPascalAST tmp47_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case NUM_INT:
+			{
+				RefPascalAST tmp48_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case NUM_REAL:
+			{
+				RefPascalAST tmp49_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case 3:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t46;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::structuredType(RefPascalAST _t) {
+	RefPascalAST structuredType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case PACKED:
+		{
+			RefPascalAST __t49 = _t;
+			RefPascalAST tmp50_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PACKED);
+			_t = _t->getFirstChild();
+			unpackedStructuredType(_t);
+			_t = _retTree;
+			_t = __t49;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case ARRAY:
+		case RECORD:
+		case SET:
+		case FILE:
+		{
+			unpackedStructuredType(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::unpackedStructuredType(RefPascalAST _t) {
+	RefPascalAST unpackedStructuredType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ARRAY:
+		{
+			arrayType(_t);
+			_t = _retTree;
+			break;
+		}
+		case RECORD:
+		{
+			recordType(_t);
+			_t = _retTree;
+			break;
+		}
+		case SET:
+		{
+			setType(_t);
+			_t = _retTree;
+			break;
+		}
+		case FILE:
+		{
+			fileType(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+/** Note here that the syntactic diff between brackets disappears.
+ *  If the brackets mean different things semantically, we need
+ *  two different alternatives here.
+ */
+void PascalStoreWalker::arrayType(RefPascalAST _t) {
+	RefPascalAST arrayType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t52 = _t;
+		RefPascalAST tmp51_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARRAY);
+		_t = _t->getFirstChild();
+		typeList(_t);
+		_t = _retTree;
+		type(_t);
+		_t = _retTree;
+		_t = __t52;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::recordType(RefPascalAST _t) {
+	RefPascalAST recordType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t58 = _t;
+		RefPascalAST tmp52_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),RECORD);
+		_t = _t->getFirstChild();
+		fieldList(_t);
+		_t = _retTree;
+		_t = __t58;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::setType(RefPascalAST _t) {
+	RefPascalAST setType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t78 = _t;
+		RefPascalAST tmp53_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SET);
+		_t = _t->getFirstChild();
+		type(_t);
+		_t = _retTree;
+		_t = __t78;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::fileType(RefPascalAST _t) {
+	RefPascalAST fileType_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t80 = _t;
+		RefPascalAST tmp54_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FILE);
+		_t = _t->getFirstChild();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case SCALARTYPE:
+		case ARRAY:
+		case INTEGER:
+		case BOOLEAN:
+		case CHAR:
+		case DOTDOT:
+		case REAL:
+		case STRING:
+		case PACKED:
+		case RECORD:
+		case SET:
+		case FILE:
+		case POINTER:
+		case IDENT:
+		{
+			type(_t);
+			_t = _retTree;
+			break;
+		}
+		case 3:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t80;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::typeList(RefPascalAST _t) {
+	RefPascalAST typeList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t54 = _t;
+		RefPascalAST tmp55_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TYPELIST);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt56=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_1.member(_t->getType()))) {
+				type(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt56>=1 ) { goto _loop56; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt56++;
+		}
+		_loop56:;
+		}  // ( ... )+
+		_t = __t54;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::fieldList(RefPascalAST _t) {
+	RefPascalAST fieldList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t60 = _t;
+		RefPascalAST tmp56_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FIELDLIST);
+		_t = _t->getFirstChild();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case FIELD:
+		{
+			fixedPart(_t);
+			_t = _retTree;
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case CASE:
+			{
+				variantPart(_t);
+				_t = _retTree;
+				break;
+			}
+			case 3:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			break;
+		}
+		case CASE:
+		{
+			variantPart(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t60;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::fixedPart(RefPascalAST _t) {
+	RefPascalAST fixedPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		{ // ( ... )+
+		int _cnt65=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == FIELD)) {
+				recordSection(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt65>=1 ) { goto _loop65; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt65++;
+		}
+		_loop65:;
+		}  // ( ... )+
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::variantPart(RefPascalAST _t) {
+	RefPascalAST variantPart_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t69 = _t;
+		RefPascalAST tmp57_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CASE);
+		_t = _t->getFirstChild();
+		tag(_t);
+		_t = _retTree;
+		{ // ( ... )+
+		int _cnt71=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == VARIANT_CASE)) {
+				variant(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt71>=1 ) { goto _loop71; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt71++;
+		}
+		_loop71:;
+		}  // ( ... )+
+		_t = __t69;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::recordSection(RefPascalAST _t) {
+	RefPascalAST recordSection_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t67 = _t;
+		RefPascalAST tmp58_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FIELD);
+		_t = _t->getFirstChild();
+		identifierList(_t);
+		_t = _retTree;
+		type(_t);
+		_t = _retTree;
+		_t = __t67;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::tag(RefPascalAST _t) {
+	RefPascalAST tag_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case VARIANT_TAG:
+		{
+			RefPascalAST __t73 = _t;
+			RefPascalAST tmp59_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT_TAG);
+			_t = _t->getFirstChild();
+			identifier(_t);
+			_t = _retTree;
+			typeIdentifier(_t);
+			_t = _retTree;
+			_t = __t73;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case VARIANT_TAG_NO_ID:
+		{
+			RefPascalAST __t74 = _t;
+			RefPascalAST tmp60_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT_TAG_NO_ID);
+			_t = _t->getFirstChild();
+			typeIdentifier(_t);
+			_t = _retTree;
+			_t = __t74;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::variant(RefPascalAST _t) {
+	RefPascalAST variant_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t76 = _t;
+		RefPascalAST tmp61_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARIANT_CASE);
+		_t = _t->getFirstChild();
+		constList(_t);
+		_t = _retTree;
+		fieldList(_t);
+		_t = _retTree;
+		_t = __t76;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::constList(RefPascalAST _t) {
+	RefPascalAST constList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t108 = _t;
+		RefPascalAST tmp62_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CONSTLIST);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt110=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_2.member(_t->getType()))) {
+				constant(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt110>=1 ) { goto _loop110; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt110++;
+		}
+		_loop110:;
+		}  // ( ... )+
+		_t = __t108;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::variableDeclaration(RefPascalAST _t) {
+	RefPascalAST variableDeclaration_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t87 = _t;
+		RefPascalAST tmp63_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VARDECL);
+		_t = _t->getFirstChild();
+		identifierList(_t);
+		_t = _retTree;
+		type(_t);
+		_t = _retTree;
+		_t = __t87;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::procedureOrFunctionDeclaration(RefPascalAST _t) {
+	RefPascalAST procedureOrFunctionDeclaration_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case PROCEDURE:
+		{
+			procedureDeclaration(_t);
+			_t = _retTree;
+			break;
+		}
+		case FUNCTION:
+		{
+			functionDeclaration(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::procedureDeclaration(RefPascalAST _t) {
+	RefPascalAST procedureDeclaration_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t91 = _t;
+		RefPascalAST tmp64_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp65_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ARGDECLS:
+		{
+			formalParameterList(_t);
+			_t = _retTree;
+			break;
+		}
+		case BLOCK:
+		case USES:
+		case IMPLEMENTATION:
+		case LABEL:
+		case CONST:
+		case TYPE:
+		case VAR:
+		case PROCEDURE:
+		case FUNCTION:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		block(_t);
+		_t = _retTree;
+		_t = __t91;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::functionDeclaration(RefPascalAST _t) {
+	RefPascalAST functionDeclaration_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t112 = _t;
+		RefPascalAST tmp66_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp67_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ARGDECLS:
+		{
+			formalParameterList(_t);
+			_t = _retTree;
+			break;
+		}
+		case INTEGER:
+		case BOOLEAN:
+		case CHAR:
+		case REAL:
+		case STRING:
+		case IDENT:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		resultType(_t);
+		_t = _retTree;
+		block(_t);
+		_t = _retTree;
+		_t = __t112;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::formalParameterSection(RefPascalAST _t) {
+	RefPascalAST formalParameterSection_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ARGDECL:
+		{
+			parameterGroup(_t);
+			_t = _retTree;
+			break;
+		}
+		case VAR:
+		{
+			RefPascalAST __t98 = _t;
+			RefPascalAST tmp68_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),VAR);
+			_t = _t->getFirstChild();
+			parameterGroup(_t);
+			_t = _retTree;
+			_t = __t98;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case FUNCTION:
+		{
+			RefPascalAST __t99 = _t;
+			RefPascalAST tmp69_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNCTION);
+			_t = _t->getFirstChild();
+			parameterGroup(_t);
+			_t = _retTree;
+			_t = __t99;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case PROCEDURE:
+		{
+			RefPascalAST __t100 = _t;
+			RefPascalAST tmp70_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROCEDURE);
+			_t = _t->getFirstChild();
+			parameterGroup(_t);
+			_t = _retTree;
+			_t = __t100;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::parameterGroup(RefPascalAST _t) {
+	RefPascalAST parameterGroup_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t102 = _t;
+		RefPascalAST tmp71_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARGDECL);
+		_t = _t->getFirstChild();
+		identifierList(_t);
+		_t = _retTree;
+		typeIdentifier(_t);
+		_t = _retTree;
+		_t = __t102;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::statement(RefPascalAST _t) {
+	RefPascalAST statement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case COLON:
+		{
+			RefPascalAST __t116 = _t;
+			RefPascalAST tmp72_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COLON);
+			_t = _t->getFirstChild();
+			label(_t);
+			_t = _retTree;
+			unlabelledStatement(_t);
+			_t = _retTree;
+			_t = __t116;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case BLOCK:
+		case PROC_CALL:
+		case ASSIGN:
+		case CASE:
+		case GOTO:
+		case IF:
+		case WHILE:
+		case REPEAT:
+		case FOR:
+		case WITH:
+		{
+			unlabelledStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::unlabelledStatement(RefPascalAST _t) {
+	RefPascalAST unlabelledStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case PROC_CALL:
+		case ASSIGN:
+		case GOTO:
+		{
+			simpleStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case BLOCK:
+		case CASE:
+		case IF:
+		case WHILE:
+		case REPEAT:
+		case FOR:
+		case WITH:
+		{
+			structuredStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::simpleStatement(RefPascalAST _t) {
+	RefPascalAST simpleStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ASSIGN:
+		{
+			assignmentStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case PROC_CALL:
+		{
+			procedureStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case GOTO:
+		{
+			gotoStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::structuredStatement(RefPascalAST _t) {
+	RefPascalAST structuredStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case BLOCK:
+		{
+			compoundStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case CASE:
+		case IF:
+		{
+			conditionalStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case WHILE:
+		case REPEAT:
+		case FOR:
+		{
+			repetetiveStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case WITH:
+		{
+			withStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::assignmentStatement(RefPascalAST _t) {
+	RefPascalAST assignmentStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t120 = _t;
+		RefPascalAST tmp73_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ASSIGN);
+		_t = _t->getFirstChild();
+		variable(_t);
+		_t = _retTree;
+		expression(_t);
+		_t = _retTree;
+		_t = __t120;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::procedureStatement(RefPascalAST _t) {
+	RefPascalAST procedureStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t166 = _t;
+		RefPascalAST tmp74_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PROC_CALL);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp75_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ARGLIST:
+		{
+			parameterList(_t);
+			_t = _retTree;
+			break;
+		}
+		case 3:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t166;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::gotoStatement(RefPascalAST _t) {
+	RefPascalAST gotoStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t170 = _t;
+		RefPascalAST tmp76_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GOTO);
+		_t = _t->getFirstChild();
+		label(_t);
+		_t = _retTree;
+		_t = __t170;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+/** 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 PascalStoreWalker::variable(RefPascalAST _t) {
+	RefPascalAST variable_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case LBRACK:
+		{
+			RefPascalAST __t122 = _t;
+			RefPascalAST tmp77_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACK);
+			_t = _t->getFirstChild();
+			variable(_t);
+			_t = _retTree;
+			{ // ( ... )+
+			int _cnt124=0;
+			for (;;) {
+				if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+					_t = ASTNULL;
+				if ((_tokenSet_3.member(_t->getType()))) {
+					expression(_t);
+					_t = _retTree;
+				}
+				else {
+					if ( _cnt124>=1 ) { goto _loop124; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+				}
+				
+				_cnt124++;
+			}
+			_loop124:;
+			}  // ( ... )+
+			_t = __t122;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case LBRACK2:
+		{
+			RefPascalAST __t125 = _t;
+			RefPascalAST tmp78_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LBRACK2);
+			_t = _t->getFirstChild();
+			variable(_t);
+			_t = _retTree;
+			{ // ( ... )+
+			int _cnt127=0;
+			for (;;) {
+				if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+					_t = ASTNULL;
+				if ((_tokenSet_3.member(_t->getType()))) {
+					expression(_t);
+					_t = _retTree;
+				}
+				else {
+					if ( _cnt127>=1 ) { goto _loop127; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+				}
+				
+				_cnt127++;
+			}
+			_loop127:;
+			}  // ( ... )+
+			_t = __t125;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case DOT:
+		{
+			RefPascalAST __t128 = _t;
+			RefPascalAST tmp79_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOT);
+			_t = _t->getFirstChild();
+			variable(_t);
+			_t = _retTree;
+			RefPascalAST tmp80_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			_t = __t128;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case POINTER:
+		{
+			RefPascalAST __t129 = _t;
+			RefPascalAST tmp81_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),POINTER);
+			_t = _t->getFirstChild();
+			variable(_t);
+			_t = _retTree;
+			_t = __t129;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case AT:
+		{
+			RefPascalAST __t130 = _t;
+			RefPascalAST tmp82_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AT);
+			_t = _t->getFirstChild();
+			RefPascalAST tmp83_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			_t = __t130;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case IDENT:
+		{
+			RefPascalAST tmp84_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::expression(RefPascalAST _t) {
+	RefPascalAST expression_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case EQUAL:
+		{
+			RefPascalAST __t132 = _t;
+			RefPascalAST tmp85_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),EQUAL);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t132;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case NOT_EQUAL:
+		{
+			RefPascalAST __t133 = _t;
+			RefPascalAST tmp86_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT_EQUAL);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t133;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case LTH:
+		{
+			RefPascalAST __t134 = _t;
+			RefPascalAST tmp87_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LTH);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t134;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case LE:
+		{
+			RefPascalAST __t135 = _t;
+			RefPascalAST tmp88_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),LE);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t135;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case GE:
+		{
+			RefPascalAST __t136 = _t;
+			RefPascalAST tmp89_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GE);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t136;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case GT:
+		{
+			RefPascalAST __t137 = _t;
+			RefPascalAST tmp90_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),GT);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t137;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case IN:
+		{
+			RefPascalAST __t138 = _t;
+			RefPascalAST tmp91_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IN);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t138;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case PLUS:
+		{
+			RefPascalAST __t139 = _t;
+			RefPascalAST tmp92_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),PLUS);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case FUNC_CALL:
+			case DOT:
+			case EQUAL:
+			case NUM_INT:
+			case LBRACK:
+			case SET:
+			case POINTER:
+			case LE:
+			case GE:
+			case LTH:
+			case GT:
+			case NOT_EQUAL:
+			case IN:
+			case PLUS:
+			case MINUS:
+			case OR:
+			case STAR:
+			case SLASH:
+			case DIV:
+			case MOD:
+			case AND:
+			case NOT:
+			case AT:
+			case LBRACK2:
+			case STRING_LITERAL:
+			case CHR:
+			case NIL:
+			case NUM_REAL:
+			case IDENT:
+			{
+				expression(_t);
+				_t = _retTree;
+				break;
+			}
+			case 3:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t139;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case MINUS:
+		{
+			RefPascalAST __t141 = _t;
+			RefPascalAST tmp93_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MINUS);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case FUNC_CALL:
+			case DOT:
+			case EQUAL:
+			case NUM_INT:
+			case LBRACK:
+			case SET:
+			case POINTER:
+			case LE:
+			case GE:
+			case LTH:
+			case GT:
+			case NOT_EQUAL:
+			case IN:
+			case PLUS:
+			case MINUS:
+			case OR:
+			case STAR:
+			case SLASH:
+			case DIV:
+			case MOD:
+			case AND:
+			case NOT:
+			case AT:
+			case LBRACK2:
+			case STRING_LITERAL:
+			case CHR:
+			case NIL:
+			case NUM_REAL:
+			case IDENT:
+			{
+				expression(_t);
+				_t = _retTree;
+				break;
+			}
+			case 3:
+			{
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t141;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case OR:
+		{
+			RefPascalAST __t143 = _t;
+			RefPascalAST tmp94_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),OR);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t143;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case STAR:
+		{
+			RefPascalAST __t144 = _t;
+			RefPascalAST tmp95_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),STAR);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t144;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case SLASH:
+		{
+			RefPascalAST __t145 = _t;
+			RefPascalAST tmp96_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SLASH);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t145;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case DIV:
+		{
+			RefPascalAST __t146 = _t;
+			RefPascalAST tmp97_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DIV);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t146;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case MOD:
+		{
+			RefPascalAST __t147 = _t;
+			RefPascalAST tmp98_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),MOD);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t147;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case AND:
+		{
+			RefPascalAST __t148 = _t;
+			RefPascalAST tmp99_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),AND);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t148;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case NOT:
+		{
+			RefPascalAST __t149 = _t;
+			RefPascalAST tmp100_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NOT);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			_t = __t149;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case DOT:
+		case LBRACK:
+		case POINTER:
+		case AT:
+		case LBRACK2:
+		case IDENT:
+		{
+			variable(_t);
+			_t = _retTree;
+			break;
+		}
+		case FUNC_CALL:
+		{
+			functionDesignator(_t);
+			_t = _retTree;
+			break;
+		}
+		case SET:
+		{
+			set(_t);
+			_t = _retTree;
+			break;
+		}
+		case NUM_INT:
+		{
+			RefPascalAST tmp101_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case NUM_REAL:
+		{
+			RefPascalAST tmp102_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+			_t = _t->getNextSibling();
+			break;
+		}
+		case CHR:
+		{
+			RefPascalAST __t150 = _t;
+			RefPascalAST tmp103_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CHR);
+			_t = _t->getFirstChild();
+			{
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			switch ( _t->getType()) {
+			case NUM_INT:
+			{
+				RefPascalAST tmp104_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_INT);
+				_t = _t->getNextSibling();
+				break;
+			}
+			case NUM_REAL:
+			{
+				RefPascalAST tmp105_AST_in = _t;
+				match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NUM_REAL);
+				_t = _t->getNextSibling();
+				break;
+			}
+			default:
+			{
+				throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+			}
+			}
+			}
+			_t = __t150;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case STRING_LITERAL:
+		{
+			string(_t);
+			_t = _retTree;
+			break;
+		}
+		case NIL:
+		{
+			RefPascalAST tmp106_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),NIL);
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::functionDesignator(RefPascalAST _t) {
+	RefPascalAST functionDesignator_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t153 = _t;
+		RefPascalAST tmp107_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FUNC_CALL);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp108_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case ARGLIST:
+		{
+			parameterList(_t);
+			_t = _retTree;
+			break;
+		}
+		case 3:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t153;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::set(RefPascalAST _t) {
+	RefPascalAST set_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t160 = _t;
+		RefPascalAST tmp109_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),SET);
+		_t = _t->getFirstChild();
+		{ // ( ... )*
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_4.member(_t->getType()))) {
+				element(_t);
+				_t = _retTree;
+			}
+			else {
+				goto _loop162;
+			}
+			
+		}
+		_loop162:;
+		} // ( ... )*
+		_t = __t160;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::parameterList(RefPascalAST _t) {
+	RefPascalAST parameterList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t156 = _t;
+		RefPascalAST tmp110_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),ARGLIST);
+		_t = _t->getFirstChild();
+		{ // ( ... )+
+		int _cnt158=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_3.member(_t->getType()))) {
+				actualParameter(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt158>=1 ) { goto _loop158; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt158++;
+		}
+		_loop158:;
+		}  // ( ... )+
+		_t = __t156;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::actualParameter(RefPascalAST _t) {
+	RefPascalAST actualParameter_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		expression(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::element(RefPascalAST _t) {
+	RefPascalAST element_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case DOTDOT:
+		{
+			RefPascalAST __t164 = _t;
+			RefPascalAST tmp111_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOTDOT);
+			_t = _t->getFirstChild();
+			expression(_t);
+			_t = _retTree;
+			expression(_t);
+			_t = _retTree;
+			_t = __t164;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case FUNC_CALL:
+		case DOT:
+		case EQUAL:
+		case NUM_INT:
+		case LBRACK:
+		case SET:
+		case POINTER:
+		case LE:
+		case GE:
+		case LTH:
+		case GT:
+		case NOT_EQUAL:
+		case IN:
+		case PLUS:
+		case MINUS:
+		case OR:
+		case STAR:
+		case SLASH:
+		case DIV:
+		case MOD:
+		case AND:
+		case NOT:
+		case AT:
+		case LBRACK2:
+		case STRING_LITERAL:
+		case CHR:
+		case NIL:
+		case NUM_REAL:
+		case IDENT:
+		{
+			expression(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::conditionalStatement(RefPascalAST _t) {
+	RefPascalAST conditionalStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case IF:
+		{
+			ifStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case CASE:
+		{
+			caseStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::repetetiveStatement(RefPascalAST _t) {
+	RefPascalAST repetetiveStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case WHILE:
+		{
+			whileStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case REPEAT:
+		{
+			repeatStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		case FOR:
+		{
+			forStatement(_t);
+			_t = _retTree;
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::withStatement(RefPascalAST _t) {
+	RefPascalAST withStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t201 = _t;
+		RefPascalAST tmp112_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WITH);
+		_t = _t->getFirstChild();
+		recordVariableList(_t);
+		_t = _retTree;
+		statement(_t);
+		_t = _retTree;
+		_t = __t201;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::statements(RefPascalAST _t) {
+	RefPascalAST statements_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t174 = _t;
+		RefPascalAST tmp113_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),BLOCK);
+		_t = _t->getFirstChild();
+		{ // ( ... )*
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_5.member(_t->getType()))) {
+				statement(_t);
+				_t = _retTree;
+			}
+			else {
+				goto _loop176;
+			}
+			
+		}
+		_loop176:;
+		} // ( ... )*
+		_t = __t174;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::ifStatement(RefPascalAST _t) {
+	RefPascalAST ifStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t179 = _t;
+		RefPascalAST tmp114_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IF);
+		_t = _t->getFirstChild();
+		expression(_t);
+		_t = _retTree;
+		statement(_t);
+		_t = _retTree;
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case BLOCK:
+		case PROC_CALL:
+		case COLON:
+		case ASSIGN:
+		case CASE:
+		case GOTO:
+		case IF:
+		case WHILE:
+		case REPEAT:
+		case FOR:
+		case WITH:
+		{
+			statement(_t);
+			_t = _retTree;
+			break;
+		}
+		case 3:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t179;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::caseStatement(RefPascalAST _t) {
+	RefPascalAST caseStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t182 = _t;
+		RefPascalAST tmp115_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),CASE);
+		_t = _t->getFirstChild();
+		expression(_t);
+		_t = _retTree;
+		{ // ( ... )+
+		int _cnt184=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_t->getType() == COLON)) {
+				caseListElement(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt184>=1 ) { goto _loop184; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt184++;
+		}
+		_loop184:;
+		}  // ( ... )+
+		{
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case BLOCK:
+		{
+			statements(_t);
+			_t = _retTree;
+			break;
+		}
+		case 3:
+		{
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+		}
+		_t = __t182;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::caseListElement(RefPascalAST _t) {
+	RefPascalAST caseListElement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t187 = _t;
+		RefPascalAST tmp116_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),COLON);
+		_t = _t->getFirstChild();
+		constList(_t);
+		_t = _retTree;
+		statement(_t);
+		_t = _retTree;
+		_t = __t187;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::whileStatement(RefPascalAST _t) {
+	RefPascalAST whileStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t190 = _t;
+		RefPascalAST tmp117_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),WHILE);
+		_t = _t->getFirstChild();
+		expression(_t);
+		_t = _retTree;
+		statement(_t);
+		_t = _retTree;
+		_t = __t190;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::repeatStatement(RefPascalAST _t) {
+	RefPascalAST repeatStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t192 = _t;
+		RefPascalAST tmp118_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),REPEAT);
+		_t = _t->getFirstChild();
+		statements(_t);
+		_t = _retTree;
+		expression(_t);
+		_t = _retTree;
+		_t = __t192;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::forStatement(RefPascalAST _t) {
+	RefPascalAST forStatement_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		RefPascalAST __t194 = _t;
+		RefPascalAST tmp119_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),FOR);
+		_t = _t->getFirstChild();
+		RefPascalAST tmp120_AST_in = _t;
+		match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),IDENT);
+		_t = _t->getNextSibling();
+		forList(_t);
+		_t = _retTree;
+		statement(_t);
+		_t = _retTree;
+		_t = __t194;
+		_t = _t->getNextSibling();
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::forList(RefPascalAST _t) {
+	RefPascalAST forList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = ASTNULL;
+		switch ( _t->getType()) {
+		case TO:
+		{
+			RefPascalAST __t196 = _t;
+			RefPascalAST tmp121_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),TO);
+			_t = _t->getFirstChild();
+			initialValue(_t);
+			_t = _retTree;
+			finalValue(_t);
+			_t = _retTree;
+			_t = __t196;
+			_t = _t->getNextSibling();
+			break;
+		}
+		case DOWNTO:
+		{
+			RefPascalAST __t197 = _t;
+			RefPascalAST tmp122_AST_in = _t;
+			match(ANTLR_USE_NAMESPACE(antlr)RefAST(_t),DOWNTO);
+			_t = _t->getFirstChild();
+			initialValue(_t);
+			_t = _retTree;
+			finalValue(_t);
+			_t = _retTree;
+			_t = __t197;
+			_t = _t->getNextSibling();
+			break;
+		}
+		default:
+		{
+			throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));
+		}
+		}
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::initialValue(RefPascalAST _t) {
+	RefPascalAST initialValue_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		expression(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::finalValue(RefPascalAST _t) {
+	RefPascalAST finalValue_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		expression(_t);
+		_t = _retTree;
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::recordVariableList(RefPascalAST _t) {
+	RefPascalAST recordVariableList_AST_in = (_t == RefPascalAST(ASTNULL)) ? RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) : _t;
+	
+	try {      // for error handling
+		{ // ( ... )+
+		int _cnt204=0;
+		for (;;) {
+			if (_t == RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+				_t = ASTNULL;
+			if ((_tokenSet_6.member(_t->getType()))) {
+				variable(_t);
+				_t = _retTree;
+			}
+			else {
+				if ( _cnt204>=1 ) { goto _loop204; } else {throw ANTLR_USE_NAMESPACE(antlr)NoViableAltException(ANTLR_USE_NAMESPACE(antlr)RefAST(_t));}
+			}
+			
+			_cnt204++;
+		}
+		_loop204:;
+		}  // ( ... )+
+	}
+	catch (ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex) {
+		reportError(ex);
+		if ( _t != RefPascalAST(ANTLR_USE_NAMESPACE(antlr)nullAST) )
+			_t = _t->getNextSibling();
+	}
+	_retTree = _t;
+}
+
+void PascalStoreWalker::initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& )
+{
+}
+const char* PascalStoreWalker::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 PascalStoreWalker::_tokenSet_0_data_[] = { 262144UL, 172032UL, 0UL, 0UL, 0UL, 0UL };
+// ARGDECL "var" "procedure" "function" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_0(_tokenSet_0_data_,6);
+const unsigned long PascalStoreWalker::_tokenSet_1_data_[] = { 512UL, 262144UL, 3641384976UL, 1UL, 0UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// SCALARTYPE "array" "integer" "boolean" "char" DOTDOT "real" "string" 
+// "packed" "record" "set" "file" POINTER IDENT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_1(_tokenSet_1_data_,12);
+const unsigned long PascalStoreWalker::_tokenSet_2_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 PascalStoreWalker::_tokenSet_2(_tokenSet_2_data_,12);
+const unsigned long PascalStoreWalker::_tokenSet_3_data_[] = { 4194432UL, 2048UL, 1107296264UL, 4152229889UL, 2155872329UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// FUNC_CALL DOT EQUAL NUM_INT LBRACK "set" POINTER LE GE LTH GT NOT_EQUAL 
+// "in" PLUS MINUS "or" STAR SLASH "div" "mod" "and" "not" AT LBRACK2 STRING_LITERAL 
+// "chr" "nil" NUM_REAL IDENT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_3(_tokenSet_3_data_,12);
+const unsigned long PascalStoreWalker::_tokenSet_4_data_[] = { 4194432UL, 2048UL, 1107427336UL, 4152229889UL, 2155872329UL, 15UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// FUNC_CALL DOT EQUAL NUM_INT DOTDOT LBRACK "set" POINTER LE GE LTH GT 
+// NOT_EQUAL "in" PLUS MINUS "or" STAR SLASH "div" "mod" "and" "not" AT 
+// LBRACK2 STRING_LITERAL "chr" "nil" NUM_REAL IDENT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_4(_tokenSet_4_data_,12);
+const unsigned long PascalStoreWalker::_tokenSet_5_data_[] = { 272UL, 16384UL, 537133056UL, 0UL, 4888576UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// BLOCK PROC_CALL COLON ASSIGN "case" "goto" "if" "while" "repeat" "for" 
+// "with" 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_5(_tokenSet_5_data_,12);
+const unsigned long PascalStoreWalker::_tokenSet_6_data_[] = { 4194304UL, 0UL, 33554432UL, 1UL, 8388672UL, 8UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL };
+// DOT LBRACK POINTER AT LBRACK2 IDENT 
+const ANTLR_USE_NAMESPACE(antlr)BitSet PascalStoreWalker::_tokenSet_6(_tokenSet_6_data_,12);
+
+
diff --git a/languages/pascal/PascalStoreWalker.hpp b/languages/pascal/PascalStoreWalker.hpp
new file mode 100644
index 00000000..bc354743
--- /dev/null
+++ b/languages/pascal/PascalStoreWalker.hpp
@@ -0,0 +1,172 @@
+#ifndef INC_PascalStoreWalker_hpp_
+#define INC_PascalStoreWalker_hpp_
+
+#line 20 "pascal.tree.g"
+
+	#include <codemodel.h>
+        #include "PascalAST.hpp"
+
+        #include <qstring.h>
+        #include <qstringlist.h>
+        #include <qfileinfo.h>
+
+#line 14 "PascalStoreWalker.hpp"
+#include <antlr/config.hpp>
+#include "PascalStoreWalkerTokenTypes.hpp"
+/* $ANTLR 2.7.7 (20061129): "pascal.tree.g" -> "PascalStoreWalker.hpp"$ */
+#include <antlr/TreeParser.hpp>
+
+#line 29 "pascal.tree.g"
+
+	#include <codemodel.h>
+        #include <kdebug.h>
+
+#line 25 "PascalStoreWalker.hpp"
+class CUSTOM_API PascalStoreWalker : public ANTLR_USE_NAMESPACE(antlr)TreeParser, public PascalStoreWalkerTokenTypes
+{
+#line 47 "pascal.tree.g"
+
+private:
+        QString m_fileName;
+        QStringList m_currentScope;
+        int m_currentAccess;
+        int m_anon;
+	CodeModel* m_model;
+
+public:
+        void setCodeModel( CodeModel* model )			{ m_model = model; }
+        CodeModel* codeModel()					{ return m_model; }
+        const CodeModel* codeModel() const			{ return m_model; }
+
+        QString fileName() const				{ return m_fileName; }
+        void setFileName( const QString& fileName )		{ m_fileName = fileName; }
+
+        void init(){
+                m_currentScope.clear();
+                m_currentAccess = CodeModelItem::Public;
+                m_anon = 0;
+        }
+
+        void wipeout()						{ m_model->wipeout(); }
+#line 29 "PascalStoreWalker.hpp"
+public:
+	PascalStoreWalker();
+	static void initializeASTFactory( ANTLR_USE_NAMESPACE(antlr)ASTFactory& factory );
+	int getNumTokens() const
+	{
+		return PascalStoreWalker::NUM_TOKENS;
+	}
+	const char* getTokenName( int type ) const
+	{
+		if( type > getNumTokens() ) return 0;
+		return PascalStoreWalker::tokenNames[type];
+	}
+	const char* const* getTokenNames() const
+	{
+		return PascalStoreWalker::tokenNames;
+	}
+	public: void program(RefPascalAST _t);
+	public: void programHeading(RefPascalAST _t);
+	public: void block(RefPascalAST _t);
+	public: void identifierList(RefPascalAST _t);
+	public: void identifier(RefPascalAST _t);
+	public: void labelDeclarationPart(RefPascalAST _t);
+	public: void constantDefinitionPart(RefPascalAST _t);
+	public: void typeDefinitionPart(RefPascalAST _t);
+	public: void variableDeclarationPart(RefPascalAST _t);
+	public: void procedureAndFunctionDeclarationPart(RefPascalAST _t);
+	public: void usesUnitsPart(RefPascalAST _t);
+	public: void compoundStatement(RefPascalAST _t);
+	public: void label(RefPascalAST _t);
+	public: void constantDefinition(RefPascalAST _t);
+	public: void constant(RefPascalAST _t);
+	public: void string(RefPascalAST _t);
+	public: void typeDefinition(RefPascalAST _t);
+	public: void type(RefPascalAST _t);
+	public: void formalParameterList(RefPascalAST _t);
+	public: void resultType(RefPascalAST _t);
+	public: void typeIdentifier(RefPascalAST _t);
+	public: void structuredType(RefPascalAST _t);
+	public: void unpackedStructuredType(RefPascalAST _t);
+	public: void arrayType(RefPascalAST _t);
+	public: void recordType(RefPascalAST _t);
+	public: void setType(RefPascalAST _t);
+	public: void fileType(RefPascalAST _t);
+	public: void typeList(RefPascalAST _t);
+	public: void fieldList(RefPascalAST _t);
+	public: void fixedPart(RefPascalAST _t);
+	public: void variantPart(RefPascalAST _t);
+	public: void recordSection(RefPascalAST _t);
+	public: void tag(RefPascalAST _t);
+	public: void variant(RefPascalAST _t);
+	public: void constList(RefPascalAST _t);
+	public: void variableDeclaration(RefPascalAST _t);
+	public: void procedureOrFunctionDeclaration(RefPascalAST _t);
+	public: void procedureDeclaration(RefPascalAST _t);
+	public: void functionDeclaration(RefPascalAST _t);
+	public: void formalParameterSection(RefPascalAST _t);
+	public: void parameterGroup(RefPascalAST _t);
+	public: void statement(RefPascalAST _t);
+	public: void unlabelledStatement(RefPascalAST _t);
+	public: void simpleStatement(RefPascalAST _t);
+	public: void structuredStatement(RefPascalAST _t);
+	public: void assignmentStatement(RefPascalAST _t);
+	public: void procedureStatement(RefPascalAST _t);
+	public: void gotoStatement(RefPascalAST _t);
+	public: void variable(RefPascalAST _t);
+	public: void expression(RefPascalAST _t);
+	public: void functionDesignator(RefPascalAST _t);
+	public: void set(RefPascalAST _t);
+	public: void parameterList(RefPascalAST _t);
+	public: void actualParameter(RefPascalAST _t);
+	public: void element(RefPascalAST _t);
+	public: void conditionalStatement(RefPascalAST _t);
+	public: void repetetiveStatement(RefPascalAST _t);
+	public: void withStatement(RefPascalAST _t);
+	public: void statements(RefPascalAST _t);
+	public: void ifStatement(RefPascalAST _t);
+	public: void caseStatement(RefPascalAST _t);
+	public: void caseListElement(RefPascalAST _t);
+	public: void whileStatement(RefPascalAST _t);
+	public: void repeatStatement(RefPascalAST _t);
+	public: void forStatement(RefPascalAST _t);
+	public: void forList(RefPascalAST _t);
+	public: void initialValue(RefPascalAST _t);
+	public: void finalValue(RefPascalAST _t);
+	public: void recordVariableList(RefPascalAST _t);
+public:
+	ANTLR_USE_NAMESPACE(antlr)RefAST getAST()
+	{
+		return ANTLR_USE_NAMESPACE(antlr)RefAST(returnAST);
+	}
+	
+protected:
+	RefPascalAST returnAST;
+	RefPascalAST _retTree;
+private:
+	static const char* tokenNames[];
+#ifndef NO_STATIC_CONSTS
+	static const int NUM_TOKENS = 190;
+#else
+	enum {
+		NUM_TOKENS = 190
+	};
+#endif
+	
+	static const unsigned long _tokenSet_0_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_0;
+	static const unsigned long _tokenSet_1_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_1;
+	static const unsigned long _tokenSet_2_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_2;
+	static const unsigned long _tokenSet_3_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_3;
+	static const unsigned long _tokenSet_4_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_4;
+	static const unsigned long _tokenSet_5_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_5;
+	static const unsigned long _tokenSet_6_data_[];
+	static const ANTLR_USE_NAMESPACE(antlr)BitSet _tokenSet_6;
+};
+
+#endif /*INC_PascalStoreWalker_hpp_*/
diff --git a/languages/pascal/PascalStoreWalkerTokenTypes.hpp b/languages/pascal/PascalStoreWalkerTokenTypes.hpp
new file mode 100644
index 00000000..0f4142f5
--- /dev/null
+++ b/languages/pascal/PascalStoreWalkerTokenTypes.hpp
@@ -0,0 +1,206 @@
+#ifndef INC_PascalStoreWalkerTokenTypes_hpp_
+#define INC_PascalStoreWalkerTokenTypes_hpp_
+
+/* $ANTLR 2.7.7 (20061129): "pascal.tree.g" -> "PascalStoreWalkerTokenTypes.hpp"$ */
+
+#ifndef CUSTOM_API
+# define CUSTOM_API
+#endif
+
+#ifdef __cplusplus
+struct CUSTOM_API PascalStoreWalkerTokenTypes {
+#endif
+	enum {
+		EOF_ = 1,
+		BLOCK = 4,
+		IDLIST = 5,
+		ELIST = 6,
+		FUNC_CALL = 7,
+		PROC_CALL = 8,
+		SCALARTYPE = 9,
+		TYPELIST = 10,
+		VARIANT_TAG = 11,
+		VARIANT_TAG_NO_ID = 12,
+		VARIANT_CASE = 13,
+		CONSTLIST = 14,
+		FIELDLIST = 15,
+		ARGDECLS = 16,
+		VARDECL = 17,
+		ARGDECL = 18,
+		ARGLIST = 19,
+		TYPEDECL = 20,
+		FIELD = 21,
+		DOT = 22,
+		LIBRARY = 23,
+		SEMI = 24,
+		END = 25,
+		EXPORTS = 26,
+		COMMA = 27,
+		LITERAL_index = 28,
+		LITERAL_name = 29,
+		USES = 30,
+		UNIT = 31,
+		INTERFACE = 32,
+		IMPLEMENTATION = 33,
+		BEGIN = 34,
+		PROGRAM = 35,
+		LPAREN = 36,
+		RPAREN = 37,
+		INITIALIZATION = 38,
+		FINALIZATION = 39,
+		LABEL = 40,
+		CONST = 41,
+		RESOURCESTRING = 42,
+		EQUAL = 43,
+		TYPE = 44,
+		VAR = 45,
+		COLON = 46,
+		PROCEDURE = 47,
+		FORWARD = 48,
+		FUNCTION = 49,
+		ARRAY = 50,
+		OF = 51,
+		EXTERNAL = 52,
+		PUBLIC = 53,
+		ALIAS = 54,
+		INTERRUPT = 55,
+		EXPORT = 56,
+		REGISTER = 57,
+		PASCAL = 58,
+		CDECL = 59,
+		STDCALL = 60,
+		POPSTACK = 61,
+		SAVEREGISTERS = 62,
+		INLINE = 63,
+		SAFECALL = 64,
+		NEAR = 65,
+		FAR = 66,
+		NUM_INT = 67,
+		INTEGER = 68,
+		SHORTINT = 69,
+		SMALLINT = 70,
+		LONGINT = 71,
+		INT64 = 72,
+		BYTE = 73,
+		WORD = 74,
+		CARDINAL = 75,
+		QWORD = 76,
+		BOOLEAN = 77,
+		BYTEBOOL = 78,
+		LONGBOOL = 79,
+		CHAR = 80,
+		DOTDOT = 81,
+		ASSIGN = 82,
+		REAL = 83,
+		SINGLE = 84,
+		DOUBLE = 85,
+		EXTENDED = 86,
+		COMP = 87,
+		STRING = 88,
+		LBRACK = 89,
+		RBRACK = 90,
+		PACKED = 91,
+		RECORD = 92,
+		CASE = 93,
+		SET = 94,
+		FILE = 95,
+		POINTER = 96,
+		OBJECT = 97,
+		VIRTUAL = 98,
+		ABSTRACT = 99,
+		PRIVATE = 100,
+		PROTECTED = 101,
+		CONSTRUCTOR = 102,
+		DESTRUCTOR = 103,
+		CLASS = 104,
+		OVERRIDE = 105,
+		MESSAGE = 106,
+		PUBLISHED = 107,
+		PROPERTY = 108,
+		LITERAL_read = 109,
+		LITERAL_write = 110,
+		DEFAULT = 111,
+		LITERAL_nodefault = 112,
+		LE = 113,
+		GE = 114,
+		LTH = 115,
+		GT = 116,
+		NOT_EQUAL = 117,
+		IN = 118,
+		IS = 119,
+		PLUS = 120,
+		MINUS = 121,
+		OR = 122,
+		XOR = 123,
+		STAR = 124,
+		SLASH = 125,
+		DIV = 126,
+		MOD = 127,
+		AND = 128,
+		SHL = 129,
+		SHR = 130,
+		NOT = 131,
+		TRUE = 132,
+		FALSE = 133,
+		AT = 134,
+		PLUSEQ = 135,
+		MINUSEQ = 136,
+		STAREQ = 137,
+		SLASHQE = 138,
+		GOTO = 139,
+		IF = 140,
+		THEN = 141,
+		ELSE = 142,
+		WHILE = 143,
+		DO = 144,
+		REPEAT = 145,
+		UNTIL = 146,
+		FOR = 147,
+		TO = 148,
+		DOWNTO = 149,
+		WITH = 150,
+		LBRACK2 = 151,
+		RBRACK2 = 152,
+		OPERATOR = 153,
+		RAISE = 154,
+		TRY = 155,
+		EXCEPT = 156,
+		FINALLY = 157,
+		ON = 158,
+		STRING_LITERAL = 159,
+		CHR = 160,
+		NIL = 161,
+		NUM_REAL = 162,
+		IDENT = 163,
+		ABSOLUTE = 164,
+		AS = 165,
+		ASM = 166,
+		ASSEMBLER = 167,
+		BREAK = 168,
+		CONTINUE = 169,
+		DISPOSE = 170,
+		EXIT = 171,
+		INHERITED = 172,
+		NEW = 173,
+		SELF = 174,
+		METHOD = 175,
+		ADDSUBOR = 176,
+		ASSIGNEQUAL = 177,
+		SIGN = 178,
+		FUNC = 179,
+		NODE_NOT_EMIT = 180,
+		MYASTVAR = 181,
+		LF = 182,
+		LCURLY = 183,
+		RCURLY = 184,
+		WS = 185,
+		COMMENT_1 = 186,
+		COMMENT_2 = 187,
+		COMMENT_3 = 188,
+		EXPONENT = 189,
+		NULL_TREE_LOOKAHEAD = 3
+	};
+#ifdef __cplusplus
+};
+#endif
+#endif /*INC_PascalStoreWalkerTokenTypes_hpp_*/
diff --git a/languages/pascal/PascalStoreWalkerTokenTypes.txt b/languages/pascal/PascalStoreWalkerTokenTypes.txt
new file mode 100644
index 00000000..8d347fc1
--- /dev/null
+++ b/languages/pascal/PascalStoreWalkerTokenTypes.txt
@@ -0,0 +1,188 @@
+// $ANTLR 2.7.7 (20061129): pascal.tree.g -> PascalStoreWalkerTokenTypes.txt$
+PascalStoreWalker    // output token vocab name
+BLOCK=4
+IDLIST=5
+ELIST=6
+FUNC_CALL=7
+PROC_CALL=8
+SCALARTYPE=9
+TYPELIST=10
+VARIANT_TAG=11
+VARIANT_TAG_NO_ID=12
+VARIANT_CASE=13
+CONSTLIST=14
+FIELDLIST=15
+ARGDECLS=16
+VARDECL=17
+ARGDECL=18
+ARGLIST=19
+TYPEDECL=20
+FIELD=21
+DOT=22
+LIBRARY="library"=23
+SEMI=24
+END="end"=25
+EXPORTS="exports"=26
+COMMA=27
+LITERAL_index="index"=28
+LITERAL_name="name"=29
+USES="uses"=30
+UNIT="unit"=31
+INTERFACE="interface"=32
+IMPLEMENTATION="implementation"=33
+BEGIN="begin"=34
+PROGRAM="program"=35
+LPAREN=36
+RPAREN=37
+INITIALIZATION="initialization"=38
+FINALIZATION="finalization"=39
+LABEL="label"=40
+CONST="const"=41
+RESOURCESTRING="resourcestring"=42
+EQUAL=43
+TYPE="type"=44
+VAR="var"=45
+COLON=46
+PROCEDURE="procedure"=47
+FORWARD="forward"=48
+FUNCTION="function"=49
+ARRAY="array"=50
+OF="of"=51
+EXTERNAL="external"=52
+PUBLIC="public"=53
+ALIAS="alias"=54
+INTERRUPT=55
+EXPORT="export"=56
+REGISTER="register"=57
+PASCAL="pascal"=58
+CDECL="cdecl"=59
+STDCALL="stdcall"=60
+POPSTACK="popstack"=61
+SAVEREGISTERS="saveregisters"=62
+INLINE="inline"=63
+SAFECALL="safecall"=64
+NEAR="near"=65
+FAR="far"=66
+NUM_INT=67
+INTEGER="integer"=68
+SHORTINT="shortint"=69
+SMALLINT="smallint"=70
+LONGINT="longint"=71
+INT64="int64"=72
+BYTE="byte"=73
+WORD="word"=74
+CARDINAL="cardinal"=75
+QWORD="qword"=76
+BOOLEAN="boolean"=77
+BYTEBOOL=78
+LONGBOOL=79
+CHAR="char"=80
+DOTDOT=81
+ASSIGN=82
+REAL="real"=83
+SINGLE="single"=84
+DOUBLE="double"=85
+EXTENDED="extended"=86
+COMP="comp"=87
+STRING="string"=88
+LBRACK=89
+RBRACK=90
+PACKED="packed"=91
+RECORD="record"=92
+CASE="case"=93
+SET="set"=94
+FILE="file"=95
+POINTER=96
+OBJECT="object"=97
+VIRTUAL="virtual"=98
+ABSTRACT="abstract"=99
+PRIVATE="private"=100
+PROTECTED="protected"=101
+CONSTRUCTOR="constructor"=102
+DESTRUCTOR="destructor"=103
+CLASS="class"=104
+OVERRIDE="override"=105
+MESSAGE=106
+PUBLISHED="published"=107
+PROPERTY="property"=108
+LITERAL_read="read"=109
+LITERAL_write="write"=110
+DEFAULT="default"=111
+LITERAL_nodefault="nodefault"=112
+LE=113
+GE=114
+LTH=115
+GT=116
+NOT_EQUAL=117
+IN="in"=118
+IS="is"=119
+PLUS=120
+MINUS=121
+OR="or"=122
+XOR="xor"=123
+STAR=124
+SLASH=125
+DIV="div"=126
+MOD="mod"=127
+AND="and"=128
+SHL="shl"=129
+SHR="shr"=130
+NOT="not"=131
+TRUE="true"=132
+FALSE="false"=133
+AT=134
+PLUSEQ=135
+MINUSEQ=136
+STAREQ=137
+SLASHQE=138
+GOTO="goto"=139
+IF="if"=140
+THEN="then"=141
+ELSE="else"=142
+WHILE="while"=143
+DO="do"=144
+REPEAT="repeat"=145
+UNTIL="until"=146
+FOR="for"=147
+TO="to"=148
+DOWNTO="downto"=149
+WITH="with"=150
+LBRACK2=151
+RBRACK2=152
+OPERATOR="operator"=153
+RAISE="raise"=154
+TRY="try"=155
+EXCEPT="except"=156
+FINALLY="finally"=157
+ON="on"=158
+STRING_LITERAL=159
+CHR="chr"=160
+NIL="nil"=161
+NUM_REAL=162
+IDENT=163
+ABSOLUTE="absolute"=164
+AS="as"=165
+ASM="asm"=166
+ASSEMBLER="assembler"=167
+BREAK="break"=168
+CONTINUE="continue"=169
+DISPOSE="dispose"=170
+EXIT="exit"=171
+INHERITED="inherited"=172
+NEW="new"=173
+SELF="self"=174
+METHOD=175
+ADDSUBOR=176
+ASSIGNEQUAL=177
+SIGN=178
+FUNC=179
+NODE_NOT_EMIT=180
+MYASTVAR=181
+LF=182
+LCURLY=183
+RCURLY=184
+WS=185
+COMMENT_1=186
+COMMENT_2=187
+COMMENT_3=188
+EXPONENT=189
diff --git a/languages/pascal/PascalTokenTypes.hpp b/languages/pascal/PascalTokenTypes.hpp
new file mode 100644
index 00000000..3e613221
--- /dev/null
+++ b/languages/pascal/PascalTokenTypes.hpp
@@ -0,0 +1,206 @@
+#ifndef INC_PascalTokenTypes_hpp_
+#define INC_PascalTokenTypes_hpp_
+
+/* $ANTLR 2.7.7 (20061129): "pascal.g" -> "PascalTokenTypes.hpp"$ */
+
+#ifndef CUSTOM_API
+# define CUSTOM_API
+#endif
+
+#ifdef __cplusplus
+struct CUSTOM_API PascalTokenTypes {
+#endif
+	enum {
+		EOF_ = 1,
+		BLOCK = 4,
+		IDLIST = 5,
+		ELIST = 6,
+		FUNC_CALL = 7,
+		PROC_CALL = 8,
+		SCALARTYPE = 9,
+		TYPELIST = 10,
+		VARIANT_TAG = 11,
+		VARIANT_TAG_NO_ID = 12,
+		VARIANT_CASE = 13,
+		CONSTLIST = 14,
+		FIELDLIST = 15,
+		ARGDECLS = 16,
+		VARDECL = 17,
+		ARGDECL = 18,
+		ARGLIST = 19,
+		TYPEDECL = 20,
+		FIELD = 21,
+		DOT = 22,
+		LIBRARY = 23,
+		SEMI = 24,
+		END = 25,
+		EXPORTS = 26,
+		COMMA = 27,
+		LITERAL_index = 28,
+		LITERAL_name = 29,
+		USES = 30,
+		UNIT = 31,
+		INTERFACE = 32,
+		IMPLEMENTATION = 33,
+		BEGIN = 34,
+		PROGRAM = 35,
+		LPAREN = 36,
+		RPAREN = 37,
+		INITIALIZATION = 38,
+		FINALIZATION = 39,
+		LABEL = 40,
+		CONST = 41,
+		RESOURCESTRING = 42,
+		EQUAL = 43,
+		TYPE = 44,
+		VAR = 45,
+		COLON = 46,
+		PROCEDURE = 47,
+		FORWARD = 48,
+		FUNCTION = 49,
+		ARRAY = 50,
+		OF = 51,
+		EXTERNAL = 52,
+		PUBLIC = 53,
+		ALIAS = 54,
+		INTERRUPT = 55,
+		EXPORT = 56,
+		REGISTER = 57,
+		PASCAL = 58,
+		CDECL = 59,
+		STDCALL = 60,
+		POPSTACK = 61,
+		SAVEREGISTERS = 62,
+		INLINE = 63,
+		SAFECALL = 64,
+		NEAR = 65,
+		FAR = 66,
+		NUM_INT = 67,
+		INTEGER = 68,
+		SHORTINT = 69,
+		SMALLINT = 70,
+		LONGINT = 71,
+		INT64 = 72,
+		BYTE = 73,
+		WORD = 74,
+		CARDINAL = 75,
+		QWORD = 76,
+		BOOLEAN = 77,
+		BYTEBOOL = 78,
+		LONGBOOL = 79,
+		CHAR = 80,
+		DOTDOT = 81,
+		ASSIGN = 82,
+		REAL = 83,
+		SINGLE = 84,
+		DOUBLE = 85,
+		EXTENDED = 86,
+		COMP = 87,
+		STRING = 88,
+		LBRACK = 89,
+		RBRACK = 90,
+		PACKED = 91,
+		RECORD = 92,
+		CASE = 93,
+		SET = 94,
+		FILE = 95,
+		POINTER = 96,
+		OBJECT = 97,
+		VIRTUAL = 98,
+		ABSTRACT = 99,
+		PRIVATE = 100,
+		PROTECTED = 101,
+		CONSTRUCTOR = 102,
+		DESTRUCTOR = 103,
+		CLASS = 104,
+		OVERRIDE = 105,
+		MESSAGE = 106,
+		PUBLISHED = 107,
+		PROPERTY = 108,
+		LITERAL_read = 109,
+		LITERAL_write = 110,
+		DEFAULT = 111,
+		LITERAL_nodefault = 112,
+		LE = 113,
+		GE = 114,
+		LTH = 115,
+		GT = 116,
+		NOT_EQUAL = 117,
+		IN = 118,
+		IS = 119,
+		PLUS = 120,
+		MINUS = 121,
+		OR = 122,
+		XOR = 123,
+		STAR = 124,
+		SLASH = 125,
+		DIV = 126,
+		MOD = 127,
+		AND = 128,
+		SHL = 129,
+		SHR = 130,
+		NOT = 131,
+		TRUE = 132,
+		FALSE = 133,
+		AT = 134,
+		PLUSEQ = 135,
+		MINUSEQ = 136,
+		STAREQ = 137,
+		SLASHQE = 138,
+		GOTO = 139,
+		IF = 140,
+		THEN = 141,
+		ELSE = 142,
+		WHILE = 143,
+		DO = 144,
+		REPEAT = 145,
+		UNTIL = 146,
+		FOR = 147,
+		TO = 148,
+		DOWNTO = 149,
+		WITH = 150,
+		LBRACK2 = 151,
+		RBRACK2 = 152,
+		OPERATOR = 153,
+		RAISE = 154,
+		TRY = 155,
+		EXCEPT = 156,
+		FINALLY = 157,
+		ON = 158,
+		STRING_LITERAL = 159,
+		CHR = 160,
+		NIL = 161,
+		NUM_REAL = 162,
+		IDENT = 163,
+		ABSOLUTE = 164,
+		AS = 165,
+		ASM = 166,
+		ASSEMBLER = 167,
+		BREAK = 168,
+		CONTINUE = 169,
+		DISPOSE = 170,
+		EXIT = 171,
+		INHERITED = 172,
+		NEW = 173,
+		SELF = 174,
+		METHOD = 175,
+		ADDSUBOR = 176,
+		ASSIGNEQUAL = 177,
+		SIGN = 178,
+		FUNC = 179,
+		NODE_NOT_EMIT = 180,
+		MYASTVAR = 181,
+		LF = 182,
+		LCURLY = 183,
+		RCURLY = 184,
+		WS = 185,
+		COMMENT_1 = 186,
+		COMMENT_2 = 187,
+		COMMENT_3 = 188,
+		EXPONENT = 189,
+		NULL_TREE_LOOKAHEAD = 3
+	};
+#ifdef __cplusplus
+};
+#endif
+#endif /*INC_PascalTokenTypes_hpp_*/
diff --git a/languages/pascal/PascalTokenTypes.txt b/languages/pascal/PascalTokenTypes.txt
new file mode 100644
index 00000000..063a729a
--- /dev/null
+++ b/languages/pascal/PascalTokenTypes.txt
@@ -0,0 +1,188 @@
+// $ANTLR 2.7.7 (20061129): pascal.g -> PascalTokenTypes.txt$
+Pascal    // output token vocab name
+BLOCK=4
+IDLIST=5
+ELIST=6
+FUNC_CALL=7
+PROC_CALL=8
+SCALARTYPE=9
+TYPELIST=10
+VARIANT_TAG=11
+VARIANT_TAG_NO_ID=12
+VARIANT_CASE=13
+CONSTLIST=14
+FIELDLIST=15
+ARGDECLS=16
+VARDECL=17
+ARGDECL=18
+ARGLIST=19
+TYPEDECL=20
+FIELD=21
+DOT=22
+LIBRARY="library"=23
+SEMI=24
+END="end"=25
+EXPORTS="exports"=26
+COMMA=27
+LITERAL_index="index"=28
+LITERAL_name="name"=29
+USES="uses"=30
+UNIT="unit"=31
+INTERFACE="interface"=32
+IMPLEMENTATION="implementation"=33
+BEGIN="begin"=34
+PROGRAM="program"=35
+LPAREN=36
+RPAREN=37
+INITIALIZATION="initialization"=38
+FINALIZATION="finalization"=39
+LABEL="label"=40
+CONST="const"=41
+RESOURCESTRING="resourcestring"=42
+EQUAL=43
+TYPE="type"=44
+VAR="var"=45
+COLON=46
+PROCEDURE="procedure"=47
+FORWARD="forward"=48
+FUNCTION="function"=49
+ARRAY="array"=50
+OF="of"=51
+EXTERNAL="external"=52
+PUBLIC="public"=53
+ALIAS="alias"=54
+INTERRUPT=55
+EXPORT="export"=56
+REGISTER="register"=57
+PASCAL="pascal"=58
+CDECL="cdecl"=59
+STDCALL="stdcall"=60
+POPSTACK="popstack"=61
+SAVEREGISTERS="saveregisters"=62
+INLINE="inline"=63
+SAFECALL="safecall"=64
+NEAR="near"=65
+FAR="far"=66
+NUM_INT=67
+INTEGER="integer"=68
+SHORTINT="shortint"=69
+SMALLINT="smallint"=70
+LONGINT="longint"=71
+INT64="int64"=72
+BYTE="byte"=73
+WORD="word"=74
+CARDINAL="cardinal"=75
+QWORD="qword"=76
+BOOLEAN="boolean"=77
+BYTEBOOL=78
+LONGBOOL=79
+CHAR="char"=80
+DOTDOT=81
+ASSIGN=82
+REAL="real"=83
+SINGLE="single"=84
+DOUBLE="double"=85
+EXTENDED="extended"=86
+COMP="comp"=87
+STRING="string"=88
+LBRACK=89
+RBRACK=90
+PACKED="packed"=91
+RECORD="record"=92
+CASE="case"=93
+SET="set"=94
+FILE="file"=95
+POINTER=96
+OBJECT="object"=97
+VIRTUAL="virtual"=98
+ABSTRACT="abstract"=99
+PRIVATE="private"=100
+PROTECTED="protected"=101
+CONSTRUCTOR="constructor"=102
+DESTRUCTOR="destructor"=103
+CLASS="class"=104
+OVERRIDE="override"=105
+MESSAGE=106
+PUBLISHED="published"=107
+PROPERTY="property"=108
+LITERAL_read="read"=109
+LITERAL_write="write"=110
+DEFAULT="default"=111
+LITERAL_nodefault="nodefault"=112
+LE=113
+GE=114
+LTH=115
+GT=116
+NOT_EQUAL=117
+IN="in"=118
+IS="is"=119
+PLUS=120
+MINUS=121
+OR="or"=122
+XOR="xor"=123
+STAR=124
+SLASH=125
+DIV="div"=126
+MOD="mod"=127
+AND="and"=128
+SHL="shl"=129
+SHR="shr"=130
+NOT="not"=131
+TRUE="true"=132
+FALSE="false"=133
+AT=134
+PLUSEQ=135
+MINUSEQ=136
+STAREQ=137
+SLASHQE=138
+GOTO="goto"=139
+IF="if"=140
+THEN="then"=141
+ELSE="else"=142
+WHILE="while"=143
+DO="do"=144
+REPEAT="repeat"=145
+UNTIL="until"=146
+FOR="for"=147
+TO="to"=148
+DOWNTO="downto"=149
+WITH="with"=150
+LBRACK2=151
+RBRACK2=152
+OPERATOR="operator"=153
+RAISE="raise"=154
+TRY="try"=155
+EXCEPT="except"=156
+FINALLY="finally"=157
+ON="on"=158
+STRING_LITERAL=159
+CHR="chr"=160
+NIL="nil"=161
+NUM_REAL=162
+IDENT=163
+ABSOLUTE="absolute"=164
+AS="as"=165
+ASM="asm"=166
+ASSEMBLER="assembler"=167
+BREAK="break"=168
+CONTINUE="continue"=169
+DISPOSE="dispose"=170
+EXIT="exit"=171
+INHERITED="inherited"=172
+NEW="new"=173
+SELF="self"=174
+METHOD=175
+ADDSUBOR=176
+ASSIGNEQUAL=177
+SIGN=178
+FUNC=179
+NODE_NOT_EMIT=180
+MYASTVAR=181
+LF=182
+LCURLY=183
+RCURLY=184
+WS=185
+COMMENT_1=186
+COMMENT_2=187
+COMMENT_3=188
+EXPONENT=189
diff --git a/languages/pascal/README.dox b/languages/pascal/README.dox
new file mode 100644
index 00000000..52ef50b1
--- /dev/null
+++ b/languages/pascal/README.dox
@@ -0,0 +1,26 @@
+/** \class PascalSupportPart
+This is Pascal language support plugin.
+
+Pascal support provides good fpc and dcc compiler support by compiler plugins.
+Nearly all command line switches for those compilers can be configured in Project Options.
+Language parser exists but it isn't perfect yet.
+
+In order to generate the parser by hand, antlr v2.7.2 is required.
+There are parser compilation errors with some gcc versions. To avoid
+them, replace file antlr/CppCodeGenerator.java in the antlr source code tree
+with the one from <a href="ftp://fara.cs.uni-potsdam.de/incoming/CppCodeGenerator.java.gz">ftp://fara.cs.uni-potsdam.de/incoming/CppCodeGenerar.java.gz</a>.
+
+\authors <a href="mailto:cloudtemple AT mksat.net">Alexander Dymo</a>
+
+\maintainer <a href="mailto:cloudtemple AT mksat.net">Alexander Dymo</a>
+
+\feature Pascal language support
+\feature Consult \ref LangSupportStatus for a up to date features/status of this programming language support part.
+
+\bug Language parser can sometimes treat correct lines as errors. Please send sample code to maintainer if you have this problem.
+
+\faq <b>Why KDevelop does not provide GNU pascal compiler plugin?</b> If you need GNU pascal compiler plugin, please write about it to maintainer and prepare to help testing it.
+\faq <b>Compiler plugin lacks option X.</b> Write about it to maintaner or send a patch. Adding compiler options is easy task. Just look at languages/pascal/compiler directory.
+
+
+*/
diff --git a/languages/pascal/app_templates/Makefile.am b/languages/pascal/app_templates/Makefile.am
new file mode 100644
index 00000000..9fd47804
--- /dev/null
+++ b/languages/pascal/app_templates/Makefile.am
@@ -0,0 +1,3 @@
+SUBDIRS = pascalhello fpcgtk fpchello fpcsharedlib
+profilesdir = $(kde_datadir)/kdevelop/profiles/IDE/CompiledLanguageIDE/PascalIDE
+profiles_DATA = pascal.appwizard
diff --git a/languages/pascal/app_templates/fpcgtk/.kdev_ignore b/languages/pascal/app_templates/fpcgtk/.kdev_ignore
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/.kdev_ignore
diff --git a/languages/pascal/app_templates/fpcgtk/Makefile.am b/languages/pascal/app_templates/fpcgtk/Makefile.am
new file mode 100644
index 00000000..252cbf27
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/Makefile.am
@@ -0,0 +1,16 @@
+dataFiles = main.pp app.kdevelop
+templateName = fpcgtk
+
+### no need to change below:
+template_DATA = $(templateName).kdevtemplate
+templatedir = ${appwizarddatadir}/templates
+
+appwizarddatadir = ${kde_datadir}/kdevappwizard
+$(templateName).tar.gz: ${dataFiles}
+	$(TAR) -cf $(templateName).tar -C $(srcdir) ${dataFiles}
+	$(GZIP_COMMAND) -f9 $(templateName).tar
+
+archivedir = ${appwizarddatadir}
+archive_DATA = $(templateName).tar.gz ${templateName}.png
+
+CLEANFILES = *.tar.gz
\ No newline at end of file
diff --git a/languages/pascal/app_templates/fpcgtk/app.kdevelop b/languages/pascal/app_templates/fpcgtk/app.kdevelop
new file mode 100644
index 00000000..995d340b
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/app.kdevelop
@@ -0,0 +1,86 @@
+<?xml version="1.0"?>
+<kdevelop>
+ <general>
+  <author>%{AUTHOR}</author>
+  <email>%{EMAIL}</email>
+  <version>%{VERSION}</version>
+  <projectmanagement>KDevPascalProject</projectmanagement>
+  <primarylanguage>Pascal</primarylanguage>
+  <keywords>
+   <keyword>Pascal</keyword>
+   <keyword>Code</keyword>
+  </keywords>
+ </general>
+ <kdevpascalproject>
+  <general>
+    <useconfiguration>default</useconfiguration>
+  </general>
+  <configurations>
+   <default>
+    <mainsource>src/%{APPNAMELC}.pp</mainsource>
+    <compiler>kdevfpcoptions</compiler>
+    <compileroptions>-vr</compileroptions>
+    <compilerexec>fpc</compilerexec>
+   </default>
+  </configurations>
+  <run>
+   <terminal>false</terminal>
+  </run>
+ </kdevpascalproject>
+ <kdevdoctreeview>
+    <ignoretocs>
+      <toc>ada</toc>
+      <toc>ada_bugs_gcc</toc>
+      <toc>bash</toc>
+      <toc>bash_bugs</toc>
+      <toc>c++_bugs_gcc</toc>
+      <toc>clanlib</toc>
+      <toc>w3c-dom-level2-html</toc>
+      <toc>fortran_bugs_gcc</toc>
+      <toc>gnome1</toc>
+      <toc>gnustep</toc>
+      <toc>gtk</toc>
+      <toc>gtk_bugs</toc>
+      <toc>haskell</toc>
+      <toc>haskell_bugs_ghc</toc>
+      <toc>java_bugs_gcc</toc>
+      <toc>java_bugs_sun</toc>
+      <toc>kde2book</toc>
+      <toc>libc</toc>
+      <toc>libstdc++</toc>
+      <toc>opengl</toc>
+      <toc>php</toc>
+      <toc>php_bugs</toc>
+      <toc>perl</toc>
+      <toc>perl_bugs</toc>
+      <toc>python</toc>
+      <toc>python_bugs</toc>
+      <toc>qt-kdev3</toc>
+      <toc>ruby</toc>
+      <toc>ruby_bugs</toc>
+      <toc>sdl</toc>
+      <toc>stl</toc>
+      <toc>w3c-svg</toc>
+      <toc>sw</toc>
+      <toc>w3c-uaag10</toc>
+      <toc>wxwidgets_bugs</toc>
+    </ignoretocs>
+    <ignoreqt_xml>
+      <toc>Guide to the Qt Translation Tools</toc>
+      <toc>Qt Assistant Manual</toc>
+      <toc>Qt Designer Manual</toc>
+      <toc>Qt Reference Documentation</toc>
+      <toc>qmake User Guide</toc>
+    </ignoreqt_xml>
+    <ignoredoxygen>
+      <toc>KDE Libraries (Doxygen)</toc>
+    </ignoredoxygen>
+ </kdevdoctreeview>
+ <kdevfilecreate>
+  <useglobaltypes>
+   <type ext="pp"/>
+   <type ext="pas"/>
+   <type ext="dpr"/>
+  </useglobaltypes>
+ </kdevfilecreate>
+</kdevelop>
diff --git a/languages/pascal/app_templates/fpcgtk/fpcgtk b/languages/pascal/app_templates/fpcgtk/fpcgtk
new file mode 100644
index 00000000..374f1bc9
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/fpcgtk
@@ -0,0 +1,9 @@
+# KDE Config File
+[General]
+Name=GTK+ application
+Name[fr]=Une application GTK+
+Category=Pascal/Free Pascal
+Comment=Generates a GTK+ based GUI application in Pascal
+Comment[fr]=Génère une application basée sur la bibliothéque GTK+ dans le language PASCAL.
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=src/APPNAMELC.pp
diff --git a/languages/pascal/app_templates/fpcgtk/fpcgtk.kdevtemplate b/languages/pascal/app_templates/fpcgtk/fpcgtk.kdevtemplate
new file mode 100644
index 00000000..56696aa1
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/fpcgtk.kdevtemplate
@@ -0,0 +1,114 @@
+# KDE Config File
+[General]
+Name=GTK+ application
+Name[ca]=Aplicació GTK+
+Name[da]=GTK+ program
+Name[de]=GTK+-Anwendung
+Name[el]=Εφα�μογή GTK+
+Name[es]=Aplicación GTK+
+Name[et]=GTK+ rakendus
+Name[eu]=GTK+ aplikazioa
+Name[fa]=کاربرد GTK+
+Name[fr]=Application GTK+
+Name[ga]=Feidhmchlár GTK+
+Name[gl]=Aplicación GTK+
+Name[hu]=GTK+-alapú alkalmazás
+Name[it]=Applicazione GTK+
+Name[ja]=GTK+ アプリケーション
+Name[nds]=GTK+-Programm
+Name[ne]=GTK+ अन�प�रयोग
+Name[nl]=GTK+-toepassing
+Name[pl]=Program GTK+
+Name[pt]=Aplicação do GTK+
+Name[pt_BR]=Aplicativo GTK+
+Name[ru]=Приложение GTK+
+Name[sk]=GTK+ aplikácia
+Name[sr]=GTK+ програм
+Name[sr@Latn]=GTK+ program
+Name[sv]=GTK+ program
+Name[tr]=GTK+ Uygulaması
+Name[zh_CN]=GTK+ 应用程�
+Name[zh_TW]=GTK+ 應用程�
+Category=Pascal/Free Pascal
+Comment=Generates a GTK+ based GUI application in Pascal
+Comment[ca]=Genera una aplicació IGU en Pascal basada en GTK+
+Comment[da]=Genererer et GTK+ baseret GUI program i Pascal
+Comment[de]=Erstellt eine auf GTK+ basierende GUI-Anwendung in Pascal
+Comment[el]=Δημιου�γεί μια γ�αφική εφα�μογή βασισμένη στο GTK+ σε Pascal
+Comment[es]=Genera una aplicación gráfica en Pascal basada en GTK+
+Comment[et]=Graafilise rakenduse loomine GTK+ põhjal Pascalis
+Comment[eu]=GTK+-en oinarritutako GUI aplikazio bat sortzen du Pascal-en
+Comment[fa]=یک کاربرد ونک بر مبنای GTK+ در پاسکال تولید می‌کند
+Comment[fr]=Génère une application avec interface graphique basée sur GTK+ en Pascal
+Comment[ga]=Cruthaigh feidhmchlár grafach i Pascal, bunaithe ar GTK+
+Comment[gl]=Xera unha aplicación GUI baseada en GTK+ en Pascal
+Comment[hu]=Létrehoz egy GTK+-alapú grafikus felületű alkalmazást Pascalban
+Comment[it]=Genera un'applicazione GUI basata su GTK+ in Pascal
+Comment[ja]=GTK+ ベース� GUI アプリケーションを Pascal �作����
+Comment[nds]=Stellt en op GTK+ opbuut Böversietprogramm in Pascal op
+Comment[ne]= GTK+ आधारित जी यू आई अन�प�रयोगलाई पास�कलमा उत�पन�न गर�दछ
+Comment[nl]=Genereert een GKT+-gebaseerde GUI-toepassing in Pascal
+Comment[pl]=Generuje program z graficznym interfejsem użytkownika używający GTK+ w Pascalu
+Comment[pt]=Gera uma aplicação gráfica, baseada em GTK+, em Pascal
+Comment[pt_BR]=Gera uma aplicação gráfica, baseada em GTK+, em Pascal
+Comment[ru]=Создание приложени� GTK+ на Pascal
+Comment[sk]=Vygeneruje GTK+ GUI aplikáciu v Pascal
+Comment[sr]=Прави GUI програм на о�нову GTK+ у Pascal-у
+Comment[sr@Latn]=Pravi GUI program na osnovu GTK+ u Pascal-u
+Comment[sv]=Skapar ett GTK+ baserat program med grafiskt användargränssnitt i Pascal
+Comment[zh_CN]=生�一个 Pascal 语言的 GTK+ GUI 应用程�
+Comment[zh_TW]=產生一個 Pascal 語言，以GTK+ 為基礎的使用者介�應用程�
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=%{dest}/src/%{APPNAMELC}.pp
+Archive=fpcgtk.tar.gz
+
+[GNU]
+Type=include
+File=%{kdevelop}/template-common/gnu.kdevtemplate
+
+[FILE1]
+Type=install
+EscapeXML=true
+Source=%{src}/app.kdevelop
+Dest=%{dest}/%{APPNAMELC}.kdevelop
+
+[MkDir1]
+Type=mkdir
+Dir=%{dest}/src
+
+[FILE2]
+Type=install
+Source=%{src}/main.pp
+Dest=%{dest}/src/%{APPNAMELC}.pp
+
+[MSG]
+Type=message
+Comment=A GTK+ application written in pascal was created in %{dest}
+Comment[ca]=Una aplicació GTK+ escrita en Pascal ha estat creada en %{dest}
+Comment[da]=Et GTK+ program skrevet i pascal blev oprettet i %{dest}
+Comment[de]=Eine in Pascal geschriebene GTK+-Anwendung wurde in %{dest} erstellt.
+Comment[el]=Μια εφα�μογή GTK+ γ�αμμένη σε pascal δημιου�γήθηκε στο %{dest}
+Comment[es]=Una aplicación GTK+ escrita en Pascal ha sido creada en %{dest}
+Comment[et]=GTK+ rakendus Pascalis loodi asukohta %{dest}
+Comment[eu]=Pascal-en idatzitako GTK+ aplikazio bat sortu da hemen: %{dest}
+Comment[fa]=یک کاربرد GTK+ نوشته‌شده در پاسکال در %{dest} ایجاد شد
+Comment[fr]=Une application GTK+ écrite en Pascal a été créée dans %{dest}
+Comment[ga]=Cruthaíodh feidhmchlár GTK+, scríofa i pascal, i %{dest}
+Comment[gl]=Creouse unha aplicación GTK+ escrita en pascal en %{dest}
+Comment[hu]=Létrejött egy egyszerű, Pascal nyelvű, GTK+-alapú alkalmazás itt: %{dest}
+Comment[it]=È stata creata un'applicazione GTK+ scritta in Pascal in %{dest}
+Comment[ja]=Pascal �書�れ� GTK+ アプリケーションを %{dest} �作�����
+Comment[nds]=In %{dest} wöör en Pascal-Programm för GTK+ opstellt
+Comment[ne]=पास�कलमा लेखि�को GTK+ अन�प�रयोग %{dest} मा सिर�जना गरियो
+Comment[nl]=Een GTK+-toepassing geschreven in Pascal is aangemaakt in %{dest}
+Comment[pl]=Program GTK+ napisany w Pascalu został utworzony w %{dest}
+Comment[pt]=Foi criada uma aplicação GTK+, escrita em Pascal, em %{dest}
+Comment[pt_BR]=Foi criada uma aplicação GTK+, escrita em Pascal, em %{dest}
+Comment[ru]=Приложение GTK+ на Pascal �оздано в %{dest}
+Comment[sk]=GTK+ aplikácia v Pascal bola vytvorená v %{dest}
+Comment[sr]=GTK+ програм у Pascal-у направљен је у %{dest}
+Comment[sr@Latn]=GTK+ program u Pascal-u napravljen je u %{dest}
+Comment[sv]=Ett GTK+ program skrivet i Pascal skapades i %{dest}
+Comment[tr]=Pascal'da yazılmış bir GTK+ uygulaması %{dest} içinde yaratıldı.
+Comment[zh_CN]=在 %{dest} 创建了 Pascal 语言的 GTK+ 应用程�
+Comment[zh_TW]=一個 Pascal 的 GTK+ 應用程�已建立於 %{dest}
diff --git a/languages/pascal/app_templates/fpcgtk/fpcgtk.png b/languages/pascal/app_templates/fpcgtk/fpcgtk.png
new file mode 100644
index 00000000..840a953c
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/fpcgtk.png
diff --git a/languages/pascal/app_templates/fpcgtk/main.pp b/languages/pascal/app_templates/fpcgtk/main.pp
new file mode 100644
index 00000000..4ac4a3b4
--- /dev/null
+++ b/languages/pascal/app_templates/fpcgtk/main.pp
@@ -0,0 +1,84 @@
+program %{APPNAMELC};
+
+{$mode objfpc}
+
+uses
+ glib,gdk,gtk;
+
+procedure hello(widget : pGtkWidget ; data: pgpointer ); cdecl;
+begin
+  writeln('Hello World');
+end;
+
+function delete_event (widget : pGtkWidget ; event: pGdkEvent; data: pgpointer ): integer; cdecl;
+begin
+  writeln('Delete Event Occurred');
+  delete_event := ord(true);
+end;
+
+procedure destroy(widget : pGtkWidget ; data: pgpointer ); cdecl;
+begin
+  gtk_main_quit();
+end;
+
+var
+  window, button :  pGtkWidget;//GtkWidget is the storage type for widgets
+
+
+begin
+  // This is called in all GTK applications. Arguments are parsed
+  // from the command line and are returned to the application.
+  gtk_init (@argc, @argv);
+
+  // create a new window
+  window := gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+  // When the window is given the "delete_event" signal (this is given
+  // by the window manager, usually by the 'close' option, or on the
+  // titlebar), we ask it to call the delete_event () function
+  // as defined above. The data passed to the callback
+  // function is NULL and is ignored in the callback function.
+  gtk_signal_connect (pGTKOBJECT (window), 'delete_event',
+                      GTK_SIGNAL_FUNC (@delete_event), NIL);
+
+
+  // Here we connect the "destroy" event to a signal handler.
+  // This event occurs when we call gtk_widget_destroy() on the window,
+  // or if we return 'FALSE' in the "delete_event" callback.
+  gtk_signal_connect (pGTKOBJECT (window), 'destroy',
+                    GTK_SIGNAL_FUNC (@destroy), NULL);
+
+  // Sets the border width of the window.
+  gtk_container_set_border_width (GTK_CONTAINER (window), 10);
+
+  // Creates a new button with the label "Hello World".
+  button := gtk_button_new_with_label ('Hello_World');
+
+  // When the button receives the "clicked" signal, it will call the
+  // function hello() passing it NULL as its argument.  The hello()
+  // function is defined above. */
+  gtk_signal_connect (pGTKOBJECT (button), 'clicked',
+                              GTK_SIGNAL_FUNC (@hello), NULL);
+
+  // This will cause the window to be destroyed by calling
+  // gtk_widget_destroy(window) when "clicked".  Again, the destroy
+  // signal could come from here, or the window manager
+  gtk_signal_connect_object (pGTKOBJECT (button), 'clicked',
+                      GTK_SIGNAL_FUNC (@gtk_widget_destroy),
+                      pGTKOBJECT(window));
+
+  // This packs the button into the window (a gtk container).
+  gtk_container_add (GTK_CONTAINER (window), button);
+
+  // The final step is to display this newly created widget.
+  gtk_widget_show (button);
+
+  // and the window
+  gtk_widget_show (window);
+
+  // All GTK applications must have a gtk_main(). Control ends here
+  // and waits for an event to occur (like a key press or
+  // mouse event).
+  gtk_main ();
+
+end.
diff --git a/languages/pascal/app_templates/fpchello/.kdev_ignore b/languages/pascal/app_templates/fpchello/.kdev_ignore
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/.kdev_ignore
diff --git a/languages/pascal/app_templates/fpchello/Makefile.am b/languages/pascal/app_templates/fpchello/Makefile.am
new file mode 100644
index 00000000..e09141dc
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/Makefile.am
@@ -0,0 +1,16 @@
+dataFiles = main.pp app.kdevelop
+templateName = fpchello
+
+### no need to change below:
+template_DATA = $(templateName).kdevtemplate
+templatedir = ${appwizarddatadir}/templates
+
+appwizarddatadir = ${kde_datadir}/kdevappwizard
+$(templateName).tar.gz: ${dataFiles}
+	$(TAR) -cf $(templateName).tar -C $(srcdir) ${dataFiles}
+	$(GZIP_COMMAND) -f9 $(templateName).tar
+
+archivedir = ${appwizarddatadir}
+archive_DATA = $(templateName).tar.gz ${templateName}.png
+
+CLEANFILES = *.tar.gz
\ No newline at end of file
diff --git a/languages/pascal/app_templates/fpchello/app.kdevelop b/languages/pascal/app_templates/fpchello/app.kdevelop
new file mode 100644
index 00000000..f0a07582
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/app.kdevelop
@@ -0,0 +1,86 @@
+<?xml version="1.0"?>
+<kdevelop>
+ <general>
+  <author>%{AUTHOR}</author>
+  <email>%{EMAIL}</email>
+  <version>%{VERSION}</version>
+  <projectmanagement>KDevPascalProject</projectmanagement>
+  <primarylanguage>Pascal</primarylanguage>
+  <keywords>
+   <keyword>Pascal</keyword>
+   <keyword>Code</keyword>
+  </keywords>
+ </general>
+ <kdevpascalproject>
+  <general>
+    <useconfiguration>default</useconfiguration>
+  </general>
+  <configurations>
+   <default>
+    <mainsource>src/%{APPNAMELC}.pp</mainsource>
+    <compiler>kdevfpcoptions</compiler>
+    <compileroptions>-vr</compileroptions>
+    <compilerexec>fpc</compilerexec>
+   </default>
+  </configurations>
+  <run>
+   <terminal>true</terminal>
+  </run>
+ </kdevpascalproject>
+ <kdevdoctreeview>
+    <ignoretocs>
+      <toc>ada</toc>
+      <toc>ada_bugs_gcc</toc>
+      <toc>bash</toc>
+      <toc>bash_bugs</toc>
+      <toc>c++_bugs_gcc</toc>
+      <toc>clanlib</toc>
+      <toc>w3c-dom-level2-html</toc>
+      <toc>fortran_bugs_gcc</toc>
+      <toc>gnome1</toc>
+      <toc>gnustep</toc>
+      <toc>gtk</toc>
+      <toc>gtk_bugs</toc>
+      <toc>haskell</toc>
+      <toc>haskell_bugs_ghc</toc>
+      <toc>java_bugs_gcc</toc>
+      <toc>java_bugs_sun</toc>
+      <toc>kde2book</toc>
+      <toc>libc</toc>
+      <toc>libstdc++</toc>
+      <toc>opengl</toc>
+      <toc>php</toc>
+      <toc>php_bugs</toc>
+      <toc>perl</toc>
+      <toc>perl_bugs</toc>
+      <toc>python</toc>
+      <toc>python_bugs</toc>
+      <toc>qt-kdev3</toc>
+      <toc>ruby</toc>
+      <toc>ruby_bugs</toc>
+      <toc>sdl</toc>
+      <toc>stl</toc>
+      <toc>w3c-svg</toc>
+      <toc>sw</toc>
+      <toc>w3c-uaag10</toc>
+      <toc>wxwidgets_bugs</toc>
+    </ignoretocs>
+    <ignoreqt_xml>
+      <toc>Guide to the Qt Translation Tools</toc>
+      <toc>Qt Assistant Manual</toc>
+      <toc>Qt Designer Manual</toc>
+      <toc>Qt Reference Documentation</toc>
+      <toc>qmake User Guide</toc>
+    </ignoreqt_xml>
+    <ignoredoxygen>
+      <toc>KDE Libraries (Doxygen)</toc>
+    </ignoredoxygen>
+ </kdevdoctreeview>
+ <kdevfilecreate>
+  <useglobaltypes>
+   <type ext="pp"/>
+   <type ext="pas"/>
+   <type ext="dpr"/>
+  </useglobaltypes>
+ </kdevfilecreate>
+</kdevelop>
diff --git a/languages/pascal/app_templates/fpchello/fpchello b/languages/pascal/app_templates/fpchello/fpchello
new file mode 100644
index 00000000..b5a0acbf
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/fpchello
@@ -0,0 +1,9 @@
+# KDE Config File
+[General]
+Name=Simple program
+Name[fr]=Un simple programme de test
+Category=Pascal/Free Pascal
+Comment=Generates a simple program in Pascal
+Comment[fr]=Génère un simple programme de test dans le language PASCAL.
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=src/APPNAMELC.pp
diff --git a/languages/pascal/app_templates/fpchello/fpchello.kdevtemplate b/languages/pascal/app_templates/fpchello/fpchello.kdevtemplate
new file mode 100644
index 00000000..44fa8bc1
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/fpchello.kdevtemplate
@@ -0,0 +1,115 @@
+# KDE Config File
+[General]
+Name=Simple program
+Name[ca]=Simple programa
+Name[da]=Simpelt program
+Name[de]=Einfaches Programm
+Name[el]=Απλό π�όγ�αμμα
+Name[es]=Programa sencillo
+Name[et]=Lihtne programm
+Name[eu]=Programa sinplea
+Name[fa]=برنامۀ ساده
+Name[fr]=Programme simple
+Name[ga]=Ríomhchlár simplí
+Name[gl]=Programa sinxelo
+Name[hu]=Egyszerű program
+Name[it]=Semplice programma
+Name[ja]=簡��プログラム
+Name[nds]=Eenfach Programm
+Name[ne]=साधारण कार�यक�रम
+Name[nl]=Eenvoudig programma
+Name[pl]=Prosty program
+Name[pt]=Programa simples
+Name[pt_BR]=Programa simples
+Name[ru]=Про�тое приложение
+Name[sk]=Jednoduchý prohram
+Name[sr]=Једно�таван програм
+Name[sr@Latn]=Jednostavan program
+Name[sv]=Enkelt program
+Name[tr]=Basit program
+Name[zh_CN]=简�程�
+Name[zh_TW]=簡單程�
+Category=Pascal/Free Pascal
+Comment=Generates a simple program in Pascal
+Comment[ca]=Genera un simple programa en Pascal
+Comment[da]=Genererer et simpelt program i Pascal
+Comment[de]=Erstellt ein einfaches Programm in Pascal
+Comment[el]=Δημιου�γεί ένα απλό π�όγ�αμμα σε Pascal
+Comment[es]=Genera un sencillo programa en Pascal
+Comment[et]=Lihtsa programmi loomine Pascalis
+Comment[eu]=Pascal-en idatzitako programa sinple bat
+Comment[fa]=یک برنامۀ ساده در پاسکال تولید می‌کند
+Comment[fr]=Génère un programme simple en Pascal
+Comment[ga]=Cruthaíonn sé seo ríomhchlár simplí i Pascal
+Comment[gl]=Xera un programa sinxelo en Pascal
+Comment[hu]=Létrehoz egy egyszerű programot Pascalban
+Comment[it]=Genera un semplice programma in Pascal
+Comment[ja]=簡��プログラムを Pascal �作����
+Comment[nds]=Stellt en eenfach Pascal-Programm op
+Comment[ne]=पास�कलमा साधारण कार�यक�रम उत�पन�न गर�दछ
+Comment[nl]=Genereert een eenvoudig programma in Pascal
+Comment[pl]=Generuje prosty program w Pascalu
+Comment[pt]=Gera um programa simples em Pascal
+Comment[pt_BR]=Gera um programa simples em Pascal
+Comment[ru]=Создание про�того приложени� на Pascal
+Comment[sk]=Vygeneruje jednoduchý program v Pascal
+Comment[sr]=Прави једно�таван програм у Pascal-у
+Comment[sr@Latn]=Pravi jednostavan program u Pascal-u
+Comment[sv]=Skapar ett enkelt program i Pascal
+Comment[tr]=Pascal'da basit bir program yaratır
+Comment[zh_CN]=生�一个简�的 Pascal 语言程�
+Comment[zh_TW]=產生一個 Pascal 的簡單程�
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=%{dest}/src/%{APPNAMELC}.pp
+Archive=fpchello.tar.gz
+
+[GNU]
+Type=include
+File=%{kdevelop}/template-common/gnu.kdevtemplate
+
+[FILE1]
+Type=install
+EscapeXML=true
+Source=%{src}/app.kdevelop
+Dest=%{dest}/%{APPNAMELC}.kdevelop
+
+[MkDir1]
+Type=mkdir
+Dir=%{dest}/src
+
+[FILE2]
+Type=install
+Source=%{src}/main.pp
+Dest=%{dest}/src/%{APPNAMELC}.pp
+
+[MSG]
+Type=message
+Comment=A simple pascal program was created in %{dest}
+Comment[ca]=Un simple programa en Pascal ha estat creat en %{dest}
+Comment[da]=Et simpelt pascal program blev oprettet i %{dest}
+Comment[de]=Ein einfaches Programm in Pascal wurde in %{dest} erstellt.
+Comment[el]=Ένα απλό π�όγ�αμμα pascal δημιου�γήθηκε στο %{dest}
+Comment[es]=Un sencillo programa en Pascal ha sido creado en %{dest}
+Comment[et]=Lihtne Pascali programm loodi asukohta %{dest}
+Comment[eu]=Pascal-en oinarritutako programa sinple bat sortu da hemen: %{dest}
+Comment[fa]=یک برنامۀ سادۀ پاسکال در %{dest} ایجاد شد
+Comment[fr]=Un programme Pascal simple a été créé dans %{dest}
+Comment[ga]=Cruthaíodh ríomhchlár simplí pascal i %{dest}
+Comment[gl]=Creouse un programa sinxelo en pascal en %{dest}
+Comment[hu]=Létrejött egy egyszerű Pascal-program itt: %{dest}
+Comment[it]=È stato creato un semplice programma Pascal in %{dest}
+Comment[ja]=簡�� Pascal プログラムを %{dest} �作�����
+Comment[nds]=In %{dest} wöör en eenfach Pascal-Programm opstellt
+Comment[ne]=साधारण पास�कल कार�यक�रम %{dest} मा सिर�जना गरियो
+Comment[nl]=Een eenvoudig Pascal-programma is aangemaakt in %{dest}
+Comment[pl]=Prosty program w Pascalu został utworzony w %{dest}
+Comment[pt]=Foi criado um programa simples em Pascal em %{dest}
+Comment[pt_BR]=Foi criado um programa simples em Pascal em %{dest}
+Comment[ru]=Про�тое приложение на Pascal �оздано в %{dest}
+Comment[sk]=Jednoduchý program v Pascal bol vytvorený v %{dest}
+Comment[sr]=Једно�таван pascal програм направљен је у %{dest}
+Comment[sr@Latn]=Jednostavan pascal program napravljen je u %{dest}
+Comment[sv]=Ett enkelt Pascal-program skapades i %{dest}
+Comment[tr]=Pascal'da basit bir program %{dest} içinde yaratıldı
+Comment[zh_CN]=在 %{dest} 创建了一个简�的 Pascal 程�
+Comment[zh_TW]=一個簡單的 Pascal 程�已建立於 %{dest}
diff --git a/languages/pascal/app_templates/fpchello/fpchello.png b/languages/pascal/app_templates/fpchello/fpchello.png
new file mode 100644
index 00000000..840a953c
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/fpchello.png
diff --git a/languages/pascal/app_templates/fpchello/main.pp b/languages/pascal/app_templates/fpchello/main.pp
new file mode 100644
index 00000000..932c3c0b
--- /dev/null
+++ b/languages/pascal/app_templates/fpchello/main.pp
@@ -0,0 +1,5 @@
+program main;
+
+begin
+    WriteLn('Hello World');
+end.
diff --git a/languages/pascal/app_templates/fpcsharedlib/.kdev_ignore b/languages/pascal/app_templates/fpcsharedlib/.kdev_ignore
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/.kdev_ignore
diff --git a/languages/pascal/app_templates/fpcsharedlib/Makefile.am b/languages/pascal/app_templates/fpcsharedlib/Makefile.am
new file mode 100644
index 00000000..6a7f1a85
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/Makefile.am
@@ -0,0 +1,16 @@
+dataFiles = main.pp app.kdevelop
+templateName = fpcsharedlib
+
+### no need to change below:
+template_DATA = $(templateName).kdevtemplate
+templatedir = ${appwizarddatadir}/templates
+
+appwizarddatadir = ${kde_datadir}/kdevappwizard
+$(templateName).tar.gz: ${dataFiles}
+	$(TAR) -cf $(templateName).tar -C $(srcdir) ${dataFiles}
+	$(GZIP_COMMAND) -f9 $(templateName).tar
+
+archivedir = ${appwizarddatadir}
+archive_DATA = $(templateName).tar.gz ${templateName}.png
+
+CLEANFILES = *.tar.gz
\ No newline at end of file
diff --git a/languages/pascal/app_templates/fpcsharedlib/app.kdevelop b/languages/pascal/app_templates/fpcsharedlib/app.kdevelop
new file mode 100644
index 00000000..bdf974e9
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/app.kdevelop
@@ -0,0 +1,86 @@
+<?xml version="1.0"?>

+<kdevelop>

+ <general>

+  <author>%{AUTHOR}</author>

+  <email>%{EMAIL}</email>

+  <version>%{VERSION}</version>

+  <projectmanagement>KDevPascalProject</projectmanagement>

+  <primarylanguage>Pascal</primarylanguage>

+  <keywords>

+   <keyword>Pascal</keyword>

+   <keyword>Code</keyword>

+  </keywords>

+ </general>

+ <kdevpascalproject>

+  <general>

+    <useconfiguration>default</useconfiguration>

+  </general>

+  <configurations>

+   <default>

+    <mainsource>src/%{APPNAMELC}.pp</mainsource>

+    <compiler>kdevfpcoptions</compiler>

+    <compileroptions>-vr</compileroptions>

+    <compilerexec>fpc</compilerexec>

+   </default>

+  </configurations>

+  <run>

+   <terminal>true</terminal>

+  </run>

+ </kdevpascalproject>

+ <kdevdoctreeview>

+    <ignoretocs>

+      <toc>ada</toc>

+      <toc>ada_bugs_gcc</toc>

+      <toc>bash</toc>

+      <toc>bash_bugs</toc>

+      <toc>c++_bugs_gcc</toc>

+      <toc>clanlib</toc>

+      <toc>w3c-dom-level2-html</toc>

+      <toc>fortran_bugs_gcc</toc>

+      <toc>gnome1</toc>

+      <toc>gnustep</toc>

+      <toc>gtk</toc>

+      <toc>gtk_bugs</toc>

+      <toc>haskell</toc>

+      <toc>haskell_bugs_ghc</toc>

+      <toc>java_bugs_gcc</toc>

+      <toc>java_bugs_sun</toc>

+      <toc>kde2book</toc>

+      <toc>libc</toc>

+      <toc>libstdc++</toc>

+      <toc>opengl</toc>

+      <toc>php</toc>

+      <toc>php_bugs</toc>

+      <toc>perl</toc>

+      <toc>perl_bugs</toc>

+      <toc>python</toc>

+      <toc>python_bugs</toc>

+      <toc>qt-kdev3</toc>

+      <toc>ruby</toc>

+      <toc>ruby_bugs</toc>

+      <toc>sdl</toc>

+      <toc>stl</toc>

+      <toc>w3c-svg</toc>

+      <toc>sw</toc>

+      <toc>w3c-uaag10</toc>

+      <toc>wxwidgets_bugs</toc>

+    </ignoretocs>

+    <ignoreqt_xml>

+      <toc>Guide to the Qt Translation Tools</toc>

+      <toc>Qt Assistant Manual</toc>

+      <toc>Qt Designer Manual</toc>

+      <toc>Qt Reference Documentation</toc>

+      <toc>qmake User Guide</toc>

+    </ignoreqt_xml>

+    <ignoredoxygen>

+      <toc>KDE Libraries (Doxygen)</toc>

+    </ignoredoxygen>

+ </kdevdoctreeview>

+ <kdevfilecreate>

+  <useglobaltypes>

+   <type ext="pp"/>

+   <type ext="pas"/>

+   <type ext="dpr"/>

+  </useglobaltypes>

+ </kdevfilecreate>

+</kdevelop>

diff --git a/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib b/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib
new file mode 100644
index 00000000..51a294f9
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib
@@ -0,0 +1,9 @@
+# KDE Config File
+[General]
+Name=Shared library
+Name[fr]=Une bibliothéque partagée
+Category=Pascal/Free Pascal
+Comment=Generates a shared library in Pascal
+Comment[fr]=Génère une bibliothéque partagée dans le language PASCAL.
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=src/APPNAMELC.pp
diff --git a/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib.kdevtemplate b/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib.kdevtemplate
new file mode 100644
index 00000000..3e4eb4fe
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib.kdevtemplate
@@ -0,0 +1,115 @@
+# KDE Config File
+[General]
+Name=Shared library
+Name[ca]=Biblioteca compartida
+Name[da]=Delt bibliotek
+Name[de]=Shared Library
+Name[el]=Κοινόχ�ηστη βιβλιοθήκη
+Name[es]=Biblioteca compartida
+Name[et]=Jagatud teek
+Name[eu]=Liburutegi partekatua
+Name[fa]=کتابخانۀ مشترک
+Name[fr]=Bibliothèque partagée
+Name[ga]=Comhleabharlann
+Name[gl]=Biblioteca compartida
+Name[hu]=Osztott programkönyvtár
+Name[it]=Libreria condivisa
+Name[ja]=共有ライブラリ
+Name[nds]=Deelt Bibliotheek
+Name[ne]=सा�ेदार लाइब�रेरी
+Name[nl]=Gedeelde bibliotheek
+Name[pl]=Biblioteka dzielona
+Name[pt]=Biblioteca dinâmica
+Name[pt_BR]=Biblioteca compartilhada
+Name[ru]=Раздел�ема� библиотека
+Name[sk]=Zdieľaná knižnica
+Name[sr]=Дељена библиотека
+Name[sr@Latn]=Deljena biblioteka
+Name[sv]=Delat bibliotek
+Name[tr]=Paylaşılan Kütüphane
+Name[zh_CN]=共享库
+Name[zh_TW]=共享函�庫
+Category=Pascal/Free Pascal
+Comment=Generates a shared library in Pascal
+Comment[ca]=Genera una biblioteca compartida en Pascal
+Comment[da]=Genererer et delt bibliotek i Pascal
+Comment[de]=Erstellt eine Shared Library in Pascal
+Comment[el]=Δημιου�γία μιας κοινόχ�ηστης βιβλιοθήκης σε Pascal
+Comment[es]=Genera una biblioteca compartida en Pascal
+Comment[et]=Jagatud teegi loomine Pascalis
+Comment[eu]=Pascal-en idatzitako liburutegi partekatu bat sortzen du
+Comment[fa]=یک کتابخانۀ مشترک در پاسکال تولید می‌کند
+Comment[fr]=Génère une bibliothèque partagée en Pascal
+Comment[ga]=Cruthaíonn sé seo comhleabharlann i Pascal
+Comment[gl]=Xera unha biblioteca compartida en Pascal
+Comment[hu]=Létrehoz egy osztott programkönyvtárt Pascalban
+Comment[it]=Genera una libreria condivisa in Pascal
+Comment[ja]=共有ライブラリを Pascal �作����
+Comment[nds]=Stellt en deelt Bibliotheek in Pascal op
+Comment[ne]=सा�ेदार लाइब�रेरीलाई पास�कलमा उत�पन�न गर�दछ
+Comment[nl]=Genereert een gedeelde bibliotheek in Pascal
+Comment[pl]=Generuje bibliotekÄ™ dzielonÄ… w Pascalu
+Comment[pt]=Gera uma biblioteca dinâmica em Pascal
+Comment[pt_BR]=Gera uma biblioteca dinâmica em Pascal
+Comment[ru]=Создание раздел�емой библиотеки на Pascal
+Comment[sk]=Vygeneruje zdieľanú knižnicu v Pascal
+Comment[sr]=Прави дељену библиотеку у Pascal-у
+Comment[sr@Latn]=Pravi deljenu biblioteku u Pascal-u
+Comment[sv]=Skapar ett delat bibliotek i Pascal
+Comment[tr]=Pascal'da bir paylaşılan kütüphane yaratır
+Comment[zh_CN]=生� Pascal 语言的共享库
+Comment[zh_TW]=產生一個 Pascal 的共享函�庫
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=%{dest}/src/%{APPNAMELC}.pp
+Archive=fpcsharedlib.tar.gz
+
+[GNU]
+Type=include
+File=%{kdevelop}/template-common/gnu.kdevtemplate
+
+[FILE1]
+Type=install
+EscapeXML=true
+Source=%{src}/app.kdevelop
+Dest=%{dest}/%{APPNAMELC}.kdevelop
+
+[MkDir1]
+Type=mkdir
+Dir=%{dest}/src
+
+[FILE2]
+Type=install
+Source=%{src}/main.pp
+Dest=%{dest}/src/%{APPNAMELC}.pp
+
+[MSG]
+Type=message
+Comment=A shared library project written in pascal was created in %{dest}
+Comment[ca]=Una biblioteca compartida escrita en Pascal ha estat creada en %{dest}
+Comment[da]=Et delt biblioteksprojekt skrevet i pascal blev oprettet i %{dest}
+Comment[de]=Ein Projekt für eine in Pascal geschriebene Shared Library wurde in %{dest} erstellt.
+Comment[el]=Ένα έ�γο κοινόχ�ηστης βιβλιοθήκης γ�αμμένο σε pascal δημιου�γήθηκε στο %{dest}
+Comment[es]=Un proyecto de biblioteca compartida escrito en Pascal ha sido creado en %{dest}
+Comment[et]=Jagatud teegi projekt Pascalis loodi asukohta %{dest}
+Comment[eu]=Pascal-en idatzitako liburutegi partekatu bat sortu da hemen: %{dest}
+Comment[fa]=یک پروژۀ کتابخانۀ مشترک نوشته‌شده در پاسکال در %{dest} ایجاد شد
+Comment[fr]=Un projet de bibliothèque partagée écrit en Pascal a été créé dans %{dest}
+Comment[ga]=Cruthaíodh tionscadal comhleabharlainne, scríofa i pascal, i %{dest}
+Comment[gl]=Creouse un proxecto de biblioteca compartida en pascan en %{dest}
+Comment[hu]=Létrejött egy Pascal nyelvű projekt osztott programkönyvtár készítéséhez itt: %{dest}
+Comment[it]=È stato creato un progetto di libreria condivisa scritto in Pascal in %{dest}
+Comment[ja]=Pascal �書�れ�共有ライブラリプロジェクトを %{dest} �作�����
+Comment[nds]=In %{dest} wöör en Projekt för en in Pascal schreven deelt Bibliotheek opstellt
+Comment[ne]=पास�कलमा लेखि�को सा�ेदार लाइब�रेरी परियोजना %{dest} मा सिर�जना गरियो
+Comment[nl]=Een gedeelde bibliotheek geschreven in Pascal is aangemaakt in %{dest}
+Comment[pl]=Projekt biblioteki dzielonej napisanej w Pascalu został utworzony w %{dest}
+Comment[pt]=Foi criado o projecto de uma biblioteca dinâmica em Pascal em %{dest}
+Comment[pt_BR]=Foi criado o projecto de uma biblioteca dinâmica em Pascal em %{dest}
+Comment[ru]=Раздел�ема� библиотека на Pascal �оздана в %{dest}
+Comment[sk]=Zdieľaná knižnica v Pascal bola vytvorená v %{dest}
+Comment[sr]=Пројекат дељене библиотеке у Pascal-у направљен је у %{dest}
+Comment[sr@Latn]=Projekat deljene biblioteke u Pascal-u napravljen je u %{dest}
+Comment[sv]=Ett projekt med delat bibliotek skrivet i Pascal skapades i %{dest}
+Comment[tr]=Pascal'da bir paylaşılan kütüphane projesi %{dest} içinde yaratıldı.
+Comment[zh_CN]=在 %{dest} 创建了一个 Pascal 语言的共享库工程
+Comment[zh_TW]=一個 Pascal 的共享函�庫專案已建立於 %{dest}
diff --git a/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib.png b/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib.png
new file mode 100644
index 00000000..840a953c
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/fpcsharedlib.png
diff --git a/languages/pascal/app_templates/fpcsharedlib/main.pp b/languages/pascal/app_templates/fpcsharedlib/main.pp
new file mode 100644
index 00000000..c02e1472
--- /dev/null
+++ b/languages/pascal/app_templates/fpcsharedlib/main.pp
@@ -0,0 +1,11 @@
+library %{APPNAMELC};
+
+function %{APPNAMELC}_test: integer; cdecl; export;
+begin
+    %{APPNAMELC}_test := 0;
+end;
+
+exports
+    %{APPNAMELC}_test;
+
+end.
diff --git a/languages/pascal/app_templates/pascal.appwizard b/languages/pascal/app_templates/pascal.appwizard
new file mode 100644
index 00000000..766cc0ba
--- /dev/null
+++ b/languages/pascal/app_templates/pascal.appwizard
@@ -0,0 +1,2 @@
+[General]
+List=pascalhello,fpcgtk,fpchello,fpcsharedlib
diff --git a/languages/pascal/app_templates/pascalhello/.kdev_ignore b/languages/pascal/app_templates/pascalhello/.kdev_ignore
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/.kdev_ignore
diff --git a/languages/pascal/app_templates/pascalhello/Makefile.am b/languages/pascal/app_templates/pascalhello/Makefile.am
new file mode 100644
index 00000000..02924e72
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/Makefile.am
@@ -0,0 +1,16 @@
+dataFiles = main.pp app.kdevelop
+templateName = pascalhello
+
+### no need to change below:
+template_DATA = $(templateName).kdevtemplate
+templatedir = ${appwizarddatadir}/templates
+
+appwizarddatadir = ${kde_datadir}/kdevappwizard
+$(templateName).tar.gz: ${dataFiles}
+	$(TAR) -cf $(templateName).tar -C $(srcdir) ${dataFiles}
+	$(GZIP_COMMAND) -f9 $(templateName).tar
+
+archivedir = ${appwizarddatadir}
+archive_DATA = $(templateName).tar.gz ${templateName}.png
+
+CLEANFILES = *.tar.gz
\ No newline at end of file
diff --git a/languages/pascal/app_templates/pascalhello/app.kdevelop b/languages/pascal/app_templates/pascalhello/app.kdevelop
new file mode 100644
index 00000000..fcb75f33
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/app.kdevelop
@@ -0,0 +1,83 @@
+<?xml version="1.0"?>
+<kdevelop>
+ <general>
+  <author>%{AUTHOR}</author>
+  <email>%{EMAIL}</email>
+  <version>%{VERSION}</version>
+  <projectmanagement>KDevPascalProject</projectmanagement>
+  <primarylanguage>Pascal</primarylanguage>
+  <keywords>
+   <keyword>Pascal</keyword>
+   <keyword>Code</keyword>
+  </keywords>
+ </general>
+ <kdevpascalproject>
+  <general>
+    <useconfiguration>default</useconfiguration>
+  </general>
+  <configurations>
+   <default>
+     <mainsource>src/%{APPNAMELC}.pp</mainsource>
+   </default>
+  </configurations>
+  <run>
+   <terminal>true</terminal>
+  </run>
+ </kdevpascalproject>
+ <kdevdoctreeview>
+    <ignoretocs>
+      <toc>ada</toc>
+      <toc>ada_bugs_gcc</toc>
+      <toc>bash</toc>
+      <toc>bash_bugs</toc>
+      <toc>c++_bugs_gcc</toc>
+      <toc>clanlib</toc>
+      <toc>w3c-dom-level2-html</toc>
+      <toc>fortran_bugs_gcc</toc>
+      <toc>gnome1</toc>
+      <toc>gnustep</toc>
+      <toc>gtk</toc>
+      <toc>gtk_bugs</toc>
+      <toc>haskell</toc>
+      <toc>haskell_bugs_ghc</toc>
+      <toc>java_bugs_gcc</toc>
+      <toc>java_bugs_sun</toc>
+      <toc>kde2book</toc>
+      <toc>libc</toc>
+      <toc>libstdc++</toc>
+      <toc>opengl</toc>
+      <toc>php</toc>
+      <toc>php_bugs</toc>
+      <toc>perl</toc>
+      <toc>perl_bugs</toc>
+      <toc>python</toc>
+      <toc>python_bugs</toc>
+      <toc>qt-kdev3</toc>
+      <toc>ruby</toc>
+      <toc>ruby_bugs</toc>
+      <toc>sdl</toc>
+      <toc>stl</toc>
+      <toc>w3c-svg</toc>
+      <toc>sw</toc>
+      <toc>w3c-uaag10</toc>
+      <toc>wxwidgets_bugs</toc>
+    </ignoretocs>
+    <ignoreqt_xml>
+      <toc>Guide to the Qt Translation Tools</toc>
+      <toc>Qt Assistant Manual</toc>
+      <toc>Qt Designer Manual</toc>
+      <toc>Qt Reference Documentation</toc>
+      <toc>qmake User Guide</toc>
+    </ignoreqt_xml>
+    <ignoredoxygen>
+      <toc>KDE Libraries (Doxygen)</toc>
+    </ignoredoxygen>
+ </kdevdoctreeview>
+ <kdevfilecreate>
+  <useglobaltypes>
+   <type ext="pp"/>
+   <type ext="pas"/>
+   <type ext="dpr"/>
+  </useglobaltypes>
+ </kdevfilecreate>
+</kdevelop>
diff --git a/languages/pascal/app_templates/pascalhello/main.pp b/languages/pascal/app_templates/pascalhello/main.pp
new file mode 100644
index 00000000..932c3c0b
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/main.pp
@@ -0,0 +1,5 @@
+program main;
+
+begin
+    WriteLn('Hello World');
+end.
diff --git a/languages/pascal/app_templates/pascalhello/pascalhello b/languages/pascal/app_templates/pascalhello/pascalhello
new file mode 100644
index 00000000..7482fb78
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/pascalhello
@@ -0,0 +1,10 @@
+# KDE Config File
+[General]
+Name=Simple Hello world program
+Name[fr]=Un simple programme de test « Hello world »
+Icon=pascalhello.png
+Category=Pascal
+Comment=Generates a simple Hello world program in Pascal
+Comment[fr]=Génère un simple programme de test du type « Hello world » dans le language PASCAL.
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=src/APPNAMELC.pp
diff --git a/languages/pascal/app_templates/pascalhello/pascalhello.kdevtemplate b/languages/pascal/app_templates/pascalhello/pascalhello.kdevtemplate
new file mode 100644
index 00000000..13c9df69
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/pascalhello.kdevtemplate
@@ -0,0 +1,116 @@
+# KDE Config File
+[General]
+Name=Simple Hello world program
+Name[ca]=Simple programa Hello world
+Name[da]=Simpelt Goddag verden program
+Name[de]=Ein einfaches "Hello World"-Programm
+Name[el]=Απλό π�όγ�αμμα Γεια σου Κόσμε
+Name[es]=Programa «Hola mundo» sencillo
+Name[et]=Lihtne "Tere, maailm" programm
+Name[eu]="Kaixo mundua" programa sinplea
+Name[fa]=برنامۀ سادۀ Hello world
+Name[fr]=Programme « Bonjour monde » simple
+Name[ga]=Ríomhchlár simplí "Hello World"
+Name[gl]=Programa sinxelo Ola mundo
+Name[hu]=Egyszerű Hello world program
+Name[it]=Semplice programma di "Hello world"
+Name[ja]=簡�� Hello world プログラム
+Name[ms]=Program Hello World mudah
+Name[nds]=En eenfach "Moin Welt"-Programm
+Name[ne]=साधारण हेल�लो वोल�ड कार�यक�रम
+Name[nl]=Eenvoudig 'Hello World' programma
+Name[pl]=Prosty program witaj świecie
+Name[pt]=Programa simples Olá Mundo
+Name[pt_BR]=Programa simples Olá Mundo
+Name[ru]=Про�та� программа Hello world
+Name[sk]=Jednoduchý "Ahoj svet" program
+Name[sl]=Preprost program Hello world
+Name[sr]=Једно�таван „Здраво �вете“ програм
+Name[sr@Latn]=Jednostavan „Zdravo svete“ program
+Name[sv]=Enkelt Hello world-program
+Name[tr]=Basit Merhaba dünya programı
+Name[zh_CN]=简�的 Hello world 程�
+Name[zh_TW]=簡單的 Hello world 程�
+Icon=pascalhello.png
+Category=Pascal
+Comment=Generates a simple Hello world program in Pascal
+Comment[ca]=Genera un simple programa de Hello world en Pascal
+Comment[da]=Genererer et simpelt Goddag verden program i Pascal
+Comment[de]=Erstellt ein einfaches "Hello World"-Programm in Pascal
+Comment[el]=Δημιου�γεί ένα απλό π�όγ�αμμα Γεια σου Κόσμε σε Pascal
+Comment[es]=Genera un programa «Hola mundo» sencillo en Pascal
+Comment[et]=Lihtsa "Tere, maailm" programmi loomine Pascalis
+Comment[eu]=Pascal-en idatzitako "Kaixo mundua" programa sinple bat sortzen du
+Comment[fa]=یک برنامۀ سادۀ Hello world در پاسکال تولید می‌کند
+Comment[fr]=Génère un programme « Bonjour monde » simple en Pascal
+Comment[gl]=Xera un programa sinxelo Ola mundo en Pascal
+Comment[hu]=Létrehoz egy egyszerű Hello world programot Pascalban
+Comment[it]=Genera un semplice programma di "Hello world" in Pascal
+Comment[ja]=簡�� Hello world プログラムを Pascal �作����
+Comment[nds]=Stellt in Pascal en eenfach "Moin Welt"-Programm op
+Comment[ne]=साधारण हेल�लो वोल�ड कार�यक�रमलाई पास�कलमा उत�पन�न गर�दछ
+Comment[nl]=Genereert een eenvudig Hello World-programma in Pascal
+Comment[pl]=Generuje prosty program "Witaj świecie" w Pascalu
+Comment[pt]=Gera um programa simples Olá Mundo em Pascal
+Comment[pt_BR]=Gera um programa simples Olá Mundo em Pascal
+Comment[ru]=Создание про�того приложени� Hello world на Pascal
+Comment[sk]=Vygeneruje jednoduchý Ahoj svet program v Pascal
+Comment[sr]=Прави једно�таван „Здраво �вете“ у Pascal-у
+Comment[sr@Latn]=Pravi jednostavan „Zdravo svete“ u Pascal-u
+Comment[sv]=Skapar ett enkelt Hello world-program i Pascal
+Comment[tr]=Pascal'da basit bir Merhaba Dünya programı yaratır.
+Comment[zh_CN]=生�一个简�的 Pascal 语言 Hello world 程�
+Comment[zh_TW]=產生一個簡單的 Pascal Hello world 程�
+FileTemplates=pp-program,PStyle,pp-unit,PStyle
+ShowFilesAfterGeneration=%{dest}/src/%{APPNAMELC}.pp
+Archive=pascalhello.tar.gz
+
+[GNU]
+Type=include
+File=%{kdevelop}/template-common/gnu.kdevtemplate
+
+[FILE1]
+Type=install
+EscapeXML=true
+Source=%{src}/app.kdevelop
+Dest=%{dest}/%{APPNAMELC}.kdevelop
+
+[MkDir1]
+Type=mkdir
+Dir=%{dest}/src
+
+[FILE2]
+Type=install
+Source=%{src}/main.pp
+Dest=%{dest}/src/%{APPNAMELC}.pp
+
+[MSG]
+Type=message
+Comment=A simple 'hello world' program in Pascal was created in %{dest}
+Comment[ca]=Un simple programa de 'hello world' en Pascal ha estat creat en %{dest}
+Comment[da]=Et simpelt 'goddag verden' program i Pascal blev oprettet i %{dest}
+Comment[de]=Ein einfaches "Hello world"-Programm in Pascal wurde in %{dest} erstellt.
+Comment[el]=Ένα απλό π�όγ�αμμα 'Γεια σου κόσμε' σε Pascal δημιου�γήθηκε στο %{dest}
+Comment[es]=Un sencillo programa «Hola mundo» en Pascal ha sido creado en %{dest}
+Comment[et]=Lihtne "Tere, maailm" programm Pascalis loodi asukohta %{dest}
+Comment[eu]=Pascal-en idatzitako "Kaixo mundua" programa sinple bat sortu da hemen: %{dest}
+Comment[fa]=یک برنامۀ سادۀ «hello world» در پاسکال در %{dest} ایجاد شد
+Comment[fr]=Un programme « Bonjour monde » simple en Pascal a été créé dans %{dest}
+Comment[gl]=Creouse un programa sinxelo en Pascal 'ola mundo' en %{dest}
+Comment[hu]=Létrejött egy egyszerű Hello world Pascal-program itt: %{dest}
+Comment[it]=È stato creato un semplice programma Pascal di "hello world" in %{dest}
+Comment[ja]=Pascal �書�れ�簡�� hello world プログラムを %{dest} �作�����
+Comment[nds]=In %{dest} wöör en eenfach "Moin Welt"-Programm in Pascal opstellt
+Comment[ne]=पास�कलमा साधारण 'हेल�लो वोल�ड' कार�यक�रम %{dest} सिर�जना गरियो
+Comment[nl]=Een eenvoudig Hello World-programma geschreven in Pascal is aangemaakt in %{dest}
+Comment[pl]=Prosty program "Witaj świecie" w Pascalu został utworzony w %{dest}
+Comment[pt]=Foi criado um programa simples 'olá mundo' em Pascal em %{dest}
+Comment[pt_BR]=Foi criado um programa simples 'olá mundo' em Pascal em %{dest}
+Comment[ru]=Про�тое приложение 'hello world' на Pascal �оздано в %{dest}
+Comment[sk]=Jednoduchý Ahoj svet program v Pascal bol vytvorený v %{dest}
+Comment[sr]=Једно�таван „Здраво �вете“ програм у Pascal-у направљен је у %{dest}
+Comment[sr@Latn]=Jednostavan „Zdravo svete“ program u Pascal-u napravljen je u %{dest}
+Comment[sv]=Ett enkelt 'Hello world'-program i Pascal skapades i %{dest}
+Comment[tr]=Pascal'da basit bir "Merhaba Dünya" uygulaması %{dest} içinde yaratıldı.
+Comment[zh_CN]=在 %{dest} 创建了一个简�的“Hello world�程�
+Comment[zh_TW]=一個簡單的 Pascal Hello world 程�已建立於 %{dest}
diff --git a/languages/pascal/app_templates/pascalhello/pascalhello.png b/languages/pascal/app_templates/pascalhello/pascalhello.png
new file mode 100644
index 00000000..888d4f13
--- /dev/null
+++ b/languages/pascal/app_templates/pascalhello/pascalhello.png
diff --git a/languages/pascal/backgroundparser.cpp b/languages/pascal/backgroundparser.cpp
new file mode 100644
index 00000000..a61c9774
--- /dev/null
+++ b/languages/pascal/backgroundparser.cpp
@@ -0,0 +1,95 @@
+/***************************************************************************
+ *   Copyright (C) 2002 by Roberto Raggi                                   *
+ *   roberto@kdevelop.org                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#include <sstream>
+
+#include "backgroundparser.h"
+#include "problemreporter.h"
+#include "PascalLexer.hpp"
+#include "PascalParser.hpp"
+#include "PascalAST.hpp"
+#include <kdebug.h>
+#include <qfile.h>
+#include <antlr/ASTFactory.hpp>
+
+BackgroundParser::BackgroundParser( ProblemReporter* reporter,
+                                    const QString& source,
+                                    const QString& filename )
+    : m_reporter( reporter ),
+      m_source( source.unicode(), source.length() ),
+      m_fileName( filename )
+{
+}
+
+BackgroundParser::~BackgroundParser()
+{
+}
+
+void BackgroundParser::run()
+{
+    kdDebug() << "11" << endl;
+
+    QCString _fn = QFile::encodeName(m_fileName);
+    std::string fn( _fn.data() );
+
+    QCString text = m_source.utf8();
+    std::istringstream stream( text.data() );
+
+    kdDebug() << "12" << endl;
+
+    PascalLexer lexer( stream );
+    lexer.setFilename( fn );
+    lexer.setProblemReporter( m_reporter );
+
+    kdDebug() << "13" << endl;
+
+    PascalParser parser( lexer );
+    parser.setFilename( fn );
+    parser.setProblemReporter( m_reporter );
+
+        antlr::ASTFactory my_factory( "PascalAST", PascalAST::factory );
+        parser.initializeASTFactory(my_factory);
+        parser.setASTFactory( &my_factory );
+
+    kdDebug() << "14" << endl;
+
+    try{
+
+        kdDebug() << "15" << endl;
+
+        lexer.resetErrors();
+        parser.resetErrors();
+
+        kdDebug() << "16" << endl;
+
+        parser.compilationUnit();
+
+        kdDebug() << "17" << endl;
+
+        int errors = lexer.numberOfErrors() + parser.numberOfErrors();
+
+        kdDebug() << "18" << endl;
+    } catch( antlr::ANTLRException& ex ){
+
+        kdDebug() << "19" << endl;
+
+        kdDebug() << "*exception*: " << ex.toString().c_str() << endl;
+        m_reporter->reportError( ex.getMessage().c_str(),
+            m_fileName,
+            lexer.getLine(),
+            lexer.getColumn() );
+    }
+
+    kdDebug(9013) << "FINISHED!!" << endl;
+}
+
+
+
diff --git a/languages/pascal/backgroundparser.h b/languages/pascal/backgroundparser.h
new file mode 100644
index 00000000..7118c7f2
--- /dev/null
+++ b/languages/pascal/backgroundparser.h
@@ -0,0 +1,35 @@
+/***************************************************************************
+ *   Copyright (C) 2002 by Roberto Raggi                                   *
+ *   roberto@kdevelop.org                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+
+#ifndef BACKGROUNDPARSER_H
+#define BACKGROUNDPARSER_H
+
+#include <qthread.h>
+#include <qstring.h>
+
+class ProblemReporter;
+
+class BackgroundParser: public QThread{
+public:
+    BackgroundParser( ProblemReporter* reporter,
+                      const QString& source,
+                      const QString& filename );
+    virtual ~BackgroundParser();
+
+    virtual void run();
+
+private:
+    ProblemReporter* m_reporter;
+    QString m_source;
+    QString m_fileName;
+};
+
+#endif
diff --git a/languages/pascal/compiler/Makefile.am b/languages/pascal/compiler/Makefile.am
new file mode 100644
index 00000000..c9f7528b
--- /dev/null
+++ b/languages/pascal/compiler/Makefile.am
@@ -0,0 +1,6 @@
+# This is the collection of plugins. In contrast to the parts
+# directory, these are 'transient' in a sense and don't
+# share the complete KDevComponent interface.
+
+SUBDIRS = dccoptions  fpcoptions
+
diff --git a/languages/pascal/compiler/dccoptions/Makefile.am b/languages/pascal/compiler/dccoptions/Makefile.am
new file mode 100644
index 00000000..61dd304c
--- /dev/null
+++ b/languages/pascal/compiler/dccoptions/Makefile.am
@@ -0,0 +1,16 @@
+# Here resides the gcc option dialog plugin.
+
+INCLUDES = -I$(top_srcdir)/lib/interfaces -I$(top_srcdir)/lib/interfaces/extras \
+	-I$(top_srcdir)/lib/widgets $(all_includes)
+
+kde_module_LTLIBRARIES = libkdevdccoptions.la
+libkdevdccoptions_la_LDFLAGS = -module $(all_libraries) $(KDE_PLUGIN)
+libkdevdccoptions_la_LIBADD = $(top_builddir)/lib/libkdevelop.la \
+	$(top_builddir)/lib/widgets/libkdevwidgets.la $(top_builddir)/lib/interfaces/extras/libkdevextras.la $(LIB_KHTML)
+
+libkdevdccoptions_la_SOURCES = dccoptionsplugin.cpp optiontabs.cpp
+
+METASOURCES = AUTO
+
+servicedir = $(kde_servicesdir)
+service_DATA = kdevdccoptions.desktop
diff --git a/languages/pascal/compiler/dccoptions/dccoptionsplugin.cpp b/languages/pascal/compiler/dccoptions/dccoptionsplugin.cpp
new file mode 100644
index 00000000..a65ca9d6
--- /dev/null
+++ b/languages/pascal/compiler/dccoptions/dccoptionsplugin.cpp
@@ -0,0 +1,114 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#include <qvbox.h>
+#include <qdialog.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kgenericfactory.h>
+
+#include "dccoptionsplugin.h"
+
+#include "optiontabs.h"
+
+K_EXPORT_COMPONENT_FACTORY( libkdevdccoptions, KGenericFactory<DccOptionsPlugin>( "kdevdccoptions" ) )
+
+DccOptionsPlugin::DccOptionsPlugin(QObject *parent, const char *name, const QStringList/* &args*/)
+    : KDevCompilerOptions(parent, name)
+{
+}
+
+DccOptionsPlugin::~DccOptionsPlugin()
+{
+}
+
+QString DccOptionsPlugin::exec(QWidget *parent, const QString &flags)
+{
+    DccOptionsDialog *dlg = new DccOptionsDialog(parent, "dcc options dialog");
+    QString newFlags = flags;
+    dlg->setFlags(flags);
+    if(dlg->exec() == QDialog::Accepted)
+        newFlags = dlg->flags();
+    delete dlg;
+    return newFlags;
+}
+
+
+DccOptionsDialog::DccOptionsDialog( QWidget * parent, const char * name )
+    : KDialogBase(Tabbed, i18n("Delphi Compiler Options"), Ok|Cancel, Ok, parent, name, true)
+{
+    QVBox *vbox;
+
+    vbox = addVBoxPage(i18n("General"));
+    general = new GeneralTab(vbox, "general tab");
+
+    vbox = addVBoxPage(i18n("Locations I"));
+    locations = new LocationsTab(vbox, "locations tab");
+
+    vbox = addVBoxPage(i18n("Locations II"));
+    locations2 = new Locations2Tab(vbox, "locations2 tab");
+
+    vbox = addVBoxPage(i18n("Code Generation"));
+    codegen = new CodegenTab(vbox, "codegen tab");
+
+    vbox = addVBoxPage(i18n("Debug && Optimization"));
+    debug_optim = new DebugOptimTab(vbox, "debug and optim tab");
+
+    vbox = addVBoxPage(i18n("Linker"));
+    linker = new LinkerTab(vbox, "linker tab");
+}
+
+DccOptionsDialog::~DccOptionsDialog( )
+{
+}
+
+void DccOptionsDialog::setFlags( const QString & flags )
+{
+    QStringList flaglist = QStringList::split(" ", flags);
+
+    general->readFlags(&flaglist);
+    codegen->readFlags(&flaglist);
+    debug_optim->readFlags(&flaglist);
+    locations->readFlags(&flaglist);
+    locations2->readFlags(&flaglist);
+    linker->readFlags(&flaglist);
+
+    unrecognizedFlags = flaglist;
+}
+
+QString DccOptionsDialog::flags( ) const
+{
+    QStringList flaglist;
+
+    general->writeFlags(&flaglist);
+    locations->writeFlags(&flaglist);
+    locations2->writeFlags(&flaglist);
+    codegen->writeFlags(&flaglist);
+    debug_optim->writeFlags(&flaglist);
+    linker->writeFlags(&flaglist);
+
+    QString flags;
+    QStringList::ConstIterator li;
+    for (li = flaglist.begin(); li != flaglist.end(); ++li) {
+        flags += (*li);
+        flags += " ";
+    }
+
+    for (li = unrecognizedFlags.begin(); li != unrecognizedFlags.end(); ++li) {
+        flags += (*li);
+        flags += " ";
+    }
+
+    flags.truncate(flags.length()-1);
+    return flags;
+}
+
+#include "dccoptionsplugin.moc"
diff --git a/languages/pascal/compiler/dccoptions/dccoptionsplugin.h b/languages/pascal/compiler/dccoptions/dccoptionsplugin.h
new file mode 100644
index 00000000..35f34532
--- /dev/null
+++ b/languages/pascal/compiler/dccoptions/dccoptionsplugin.h
@@ -0,0 +1,56 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#ifndef DCCOPTIONSPLUGIN_H
+#define DCCOPTIONSPLUGIN_H
+
+#include <kdialogbase.h>
+
+#include "kdevcompileroptions.h"
+
+class DccOptionsPlugin : public KDevCompilerOptions
+{
+    Q_OBJECT
+
+public:
+    DccOptionsPlugin( QObject *parent, const char *name, const QStringList/* &args */);
+    ~DccOptionsPlugin();
+
+    virtual QString exec(QWidget *parent, const QString &flags);
+};
+
+class GeneralTab;
+class LinkerTab;
+class LocationsTab;
+class Locations2Tab;
+class CodegenTab;
+class DebugOptimTab;
+
+class DccOptionsDialog : public KDialogBase
+{
+public:
+    DccOptionsDialog( QWidget *parent=0, const char *name=0 );
+    ~DccOptionsDialog();
+
+    void setFlags(const QString &flags);
+    QString flags() const;
+
+private:
+    GeneralTab *general;
+    LinkerTab *linker;
+    LocationsTab *locations;
+    Locations2Tab *locations2;
+    CodegenTab *codegen;
+    DebugOptimTab *debug_optim;
+    QStringList unrecognizedFlags;
+};
+
+
+#endif
diff --git a/languages/pascal/compiler/dccoptions/kdevdccoptions.desktop b/languages/pascal/compiler/dccoptions/kdevdccoptions.desktop
new file mode 100644
index 00000000..8a577bb7
--- /dev/null
+++ b/languages/pascal/compiler/dccoptions/kdevdccoptions.desktop
@@ -0,0 +1,54 @@
+[Desktop Entry]
+Type=Service
+Exec=dcc
+Comment=Borland Delphi Compiler
+Comment[br]=Dastumer Delphi Borland
+Comment[ca]=Compilador Delphi de Borland
+Comment[da]=Borland Delphi oversætter
+Comment[el]=Μεταγλωττιστής Borland Delphi
+Comment[es]=Compilador de Delphi de Borland
+Comment[et]=Borland Delphi kompilaator
+Comment[eu]=Borland Delphi konpiladorea
+Comment[fa]=مترجم برلند دل�ی
+Comment[fr]=Compilateur Delphi de Borland
+Comment[ga]=Tiomsaitheoir Borland Delphi
+Comment[gl]=Compilador Borland Delphi
+Comment[hi]=बोरलैंड डेल�फ़ी कम�पायलर
+Comment[hu]=Borland Delphi fordítóprogram
+Comment[is]=Borland Delphi þýðandi
+Comment[it]=Compilatore per Borland Delphi
+Comment[ja]=Borland Delphi コンパイラ
+Comment[nds]=Borland Delphi-Kompilerer
+Comment[ne]=बोरल�यान�ड डेल�पी कम�पाइलर
+Comment[nl]=Borland Delphi-compiler
+Comment[pl]=Kompilator Borland Delphi
+Comment[pt]=Compilador de Borland Delphi
+Comment[pt_BR]=Compilador Delphi da Borland Delphi
+Comment[ru]=Компил�тор Borland Delphi
+Comment[sk]=Borland Delphi kompilátor
+Comment[sl]=Prevajalnik za Borland Delphi
+Comment[sr]=Borland-ов преводилац Delphi-ја
+Comment[sr@Latn]=Borland-ov prevodilac Delphi-ja
+Comment[sv]=Borland Delphi kompilator
+Comment[ta]=பொர�லான�ட� டெல�பி தொக�ப�பி
+Comment[tg]=Талфифгари Borland Delphi 
+Comment[tr]=Borland Delphi Derleyicisi
+Comment[zh_CN]=Borland Delphi 编译器
+Comment[zh_TW]=Borland Delphi 編譯器
+Name=DccOptions
+Name[da]=Delphi oversætter indstillinger
+Name[de]=Delphi-Einstellungen (KDevelop)
+Name[hi]=डीसीसी-विकल�प
+Name[nds]=Delphi-Optschonen (KDevelop)
+Name[pl]=Opcje Dcc
+Name[sk]=Dcc možnosti
+Name[sl]=Možnosti Dcc
+Name[sv]=Alternativ för dcc
+Name[ta]=Dccவிர�ப�பங�கள� 
+Name[tg]=DccИнтихобҳо
+Name[zh_TW]=Dcc �項
+ServiceTypes=KDevelop/CompilerOptions
+X-KDE-Library=libkdevdccoptions
+X-KDevelop-Version=5
+X-KDevelop-Language=Pascal
+X-KDevelop-Args=dcc
diff --git a/languages/pascal/compiler/dccoptions/optiontabs.cpp b/languages/pascal/compiler/dccoptions/optiontabs.cpp
new file mode 100644
index 00000000..97622606
--- /dev/null
+++ b/languages/pascal/compiler/dccoptions/optiontabs.cpp
@@ -0,0 +1,399 @@
+/***************************************************************************
+ *   Copyright (C) 2003 by Alexander Dymo                                  *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ ***************************************************************************/
+#include <kdialog.h>
+#include <klocale.h>
+
+#include <qspinbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qvbuttongroup.h>
+#include <qapplication.h>
+#include <qpushbutton.h>
+
+#include "flagboxes.h"
+
+#include "optiontabs.h"
+
+LinkerTab::LinkerTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), radioController(new FlagRadioButtonController()),
+    pathController(new FlagPathEditController()),
+    editController(new FlagEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    QVButtonGroup *map_group = new QVButtonGroup(i18n("Map File"), this);
+    QRadioButton *m_defaultMap = new QRadioButton(i18n("Off"), map_group);
+    m_defaultMap->setChecked(true);
+    new FlagRadioButton(map_group, radioController,
+                     "-GS", i18n("Segments"));
+    new FlagRadioButton(map_group, radioController,
+                     "-GP", i18n("Publics"));
+    new FlagRadioButton(map_group, radioController,
+                     "-GD", i18n("Detailed"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    new FlagPathEdit(this, "", pathController,
+                     "--dynamicloader=", i18n("Default dynamic loader:"), KFile::File);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    new FlagSpinEdit(this, 0, 2147483647, 1024, 1048576, editController,
+                     "-$M", i18n("Reserved address space:"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    layout->addStretch();
+}
+
+LinkerTab::~LinkerTab( )
+{
+    delete radioController;
+    delete pathController;
+    delete editController;
+}
+
+void LinkerTab::readFlags( QStringList * str )
+{
+    pathController->readFlags(str);
+    radioController->readFlags(str);
+    editController->readFlags(str);
+}
+
+void LinkerTab::writeFlags( QStringList * str )
+{
+    pathController->writeFlags(str);
+    radioController->writeFlags(str);
+    editController->writeFlags(str);
+}
+
+
+
+LocationsTab::LocationsTab( QWidget * parent, const char * name )
+    :QWidget(parent, name), pathController(new FlagPathEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    new FlagPathEdit(this, ":", pathController,
+                     "-I", i18n("Include search path (delimited by \":\"):"));
+    new FlagPathEdit(this, ":", pathController,
+                     "-R", i18n("Resource search path (delimited by \":\"):"));
+    new FlagPathEdit(this, ":", pathController,
+                     "-U", i18n("Unit search path (delimited by \":\"):"));
+    new FlagPathEdit(this, ":", pathController,
+                     "-O", i18n("Object search path (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addStretch();
+}
+
+LocationsTab::~LocationsTab( )
+{
+    delete pathController;
+}
+
+void LocationsTab::readFlags( QStringList * str )
+{
+    pathController->readFlags(str);
+}
+
+void LocationsTab::writeFlags( QStringList * str )
+{
+    pathController->writeFlags(str);
+}
+
+
+
+Locations2Tab::Locations2Tab( QWidget * parent, const char * name )
+    :QWidget(parent, name), pathController(new FlagPathEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    new FlagPathEdit(this, "", pathController,
+                     "-E", i18n("Executable output directory:"));
+    new FlagPathEdit(this, "", pathController,
+                     "-N", i18n("Unit output directory:"));
+    new FlagPathEdit(this, "", pathController,
+                     "-LE", i18n("Package directory:"));
+    new FlagPathEdit(this, "", pathController,
+                     "-LN", i18n("Package source code directory:"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addStretch();
+}
+
+Locations2Tab::~Locations2Tab( )
+{
+    delete pathController;
+}
+
+void Locations2Tab::readFlags( QStringList * str )
+{
+    pathController->readFlags(str);
+}
+
+void Locations2Tab::writeFlags( QStringList * str )
+{
+    pathController->writeFlags(str);
+}
+
+
+
+GeneralTab::GeneralTab( QWidget * parent, const char * name )
+    :QWidget(parent, name), controller(new FlagCheckBoxController()),
+    editController(new FlagEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    QVButtonGroup *build_group = new QVButtonGroup(i18n("Build"), this);
+    new FlagCheckBox(build_group, controller,
+                     "-B", i18n("Build all units"));
+    new FlagCheckBox(build_group, controller,
+                     "-M", i18n("Make modified units"));
+    new FlagCheckBox(build_group, controller,
+                     "-Q", i18n("Quiet compile"));
+    new FlagCheckBox(build_group, controller,
+                     "-Z", i18n("Disable implicit package compilation"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addSpacing(10);
+
+    new FlagListEdit(this, ":", editController, "-D", i18n("Conditional defines (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    new FlagListEdit(this, ":", editController, "-A", i18n("Unit aliases in form unit=alias (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addSpacing(10);
+
+    QVButtonGroup *message_group = new QVButtonGroup(i18n("Messages"), this);
+    new FlagCheckBox(message_group, controller,
+                     "-H", i18n("Output hint messages"));
+    new FlagCheckBox(message_group, controller,
+                     "-W", i18n("Output warning messages"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addSpacing(10);
+    QVButtonGroup *package_group = new QVButtonGroup(i18n("Packages"), this);
+    new FlagListEdit(package_group, ":", editController, "-LU", i18n("Build with packages (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+GeneralTab::~GeneralTab( )
+{
+    delete controller;
+    delete editController;
+}
+
+void GeneralTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    editController->readFlags(str);
+}
+
+void GeneralTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    editController->writeFlags(str);
+}
+
+
+
+CodegenTab::CodegenTab( QWidget * parent, const char * name )
+    :QWidget(parent, name), controller(new FlagCheckBoxController()),
+    listController(new FlagEditController()),
+    radioController(new FlagRadioButtonController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+//    layout->setAutoAdd(true);
+
+    QGridLayout *layout2 = new QGridLayout(layout, 2, 2, KDialog::spacingHint());
+
+    QVButtonGroup *align_group = new QVButtonGroup(i18n("Code Alignment && Stack Frames"), this);
+    QRadioButton *align_def = new QRadioButton(i18n("Default (-$A8)"), align_group);
+    align_def->setChecked(true);
+    new FlagRadioButton(align_group, radioController,
+                     "'-$A1'", i18n("Never align"));
+    new FlagRadioButton(align_group, radioController,
+                     "'-$A2'", i18n("On word boundaries"));
+    new FlagRadioButton(align_group, radioController,
+                     "'-$A4'", i18n("On double word boundaries"));
+    new FlagRadioButton(align_group, radioController,
+                     "'-$A8'", i18n("On quad word boundaries"));
+    new FlagCheckBox(align_group, controller,
+                     "'-$W+'", i18n("Generate stack frames"), "'-$W-'");
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout2->addWidget(align_group, 0, 0);
+
+    QVButtonGroup *enum_group = new QVButtonGroup(i18n("Enumeration Size"), this);
+    QRadioButton *enum_def = new QRadioButton(i18n("Default (-$Z1)"), enum_group);
+    enum_def->setChecked(true);
+    new FlagRadioButton(enum_group, radioController,
+                     "'-$Z1'", i18n("Unsigned byte (256 values)"));
+    new FlagRadioButton(enum_group, radioController,
+                     "'-$Z2'", i18n("Unsigned word (64K values)"));
+    new FlagRadioButton(enum_group, radioController,
+                     "'-$Z4'", i18n("Unsigned double word (4096M values)"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout2->addWidget(enum_group, 0, 1);
+
+    QVButtonGroup *compile_group = new QVButtonGroup(i18n("Compile Time Checks"), this);
+    new FlagCheckBox(compile_group, controller,
+                     "'-$C+'", i18n("Assertions"), "'-$C-'", "'-$C+'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$B+'", i18n("Complete boolean evaluation"), "'-$B-'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$X+'", i18n("Extended syntax"), "'-$X-'", "'-$X+'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$H+'", i18n("Long strings"), "'-$H-'", "'-$H+'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$P+'", i18n("Open string parameters"), "'-$P-'", "'-$P+'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$T+'", i18n("Type-checked pointers"), "'-$T-'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$V+'", i18n("Var-string checking"), "'-$V-'", "'-$V+'");
+    new FlagCheckBox(compile_group, controller,
+                     "'-$J+'", i18n("Writable typed constants"), "'-$J-'");
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout2->addWidget(compile_group, 1, 0);
+
+    QVButtonGroup *run_group = new QVButtonGroup(i18n("Run Time Checks"), this);
+    new FlagCheckBox(run_group, controller,
+                     "'-$M+'", i18n("Runtime type information"), "'-$M-'");
+    new FlagCheckBox(run_group, controller,
+                     "'-$G+'", i18n("Imported data references"), "'-$G-'", "'-$G+'");
+    new FlagCheckBox(run_group, controller,
+                     "'-$I+'", i18n("Input/Output checking"), "'-$I-'", "'-$I+'");
+    new FlagCheckBox(run_group, controller,
+                     "'-$Q+'", i18n("Overflow checking"), "'-$Q-'");
+    new FlagCheckBox(run_group, controller,
+                     "'-$R+'", i18n("Range checking"), "'-$R-'");
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout2->addWidget(run_group, 1, 1);
+
+    layout->addStretch();
+}
+
+CodegenTab::~CodegenTab( )
+{
+    delete controller;
+    delete listController;
+    delete radioController;
+}
+
+void CodegenTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    listController->readFlags(str);
+    radioController->readFlags(str);
+}
+
+void CodegenTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    listController->writeFlags(str);
+    radioController->writeFlags(str);
+}
+
+
+
+DebugOptimTab::DebugOptimTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController()),
+    radioController(new FlagRadioButtonController)
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+//    layout->setAutoAdd(true);
+
+    QVButtonGroup *optim_group = new QVButtonGroup(i18n("Optimization"), this);
+    new FlagCheckBox(optim_group, controller,
+                     "'-$O+'", i18n("Enable optimizations"), "'-$O-'", "'-$O+'");
+    layout->addWidget(optim_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QBoxLayout *layout2 = new QHBoxLayout(layout, KDialog::spacingHint());
+
+    QVButtonGroup *debug_group = new QVButtonGroup(i18n("Debugging"), this);
+    new FlagCheckBox(debug_group, controller,
+                     "'-$D+'", i18n("Debug information"), "'-$D-'", "'-$D+'");
+    new FlagCheckBox(debug_group, controller,
+                     "'-$L+'", i18n("Local symbol information"), "'-$L-'", "'-$L+'");
+    gdb = new FlagCheckBox(debug_group, controller,
+                     "-V", i18n("Debug information for GDB"));
+    namespacedb = new FlagCheckBox(debug_group, controller,
+                     "-VN", i18n("Namespace debug info"));
+    symboldb = new FlagCheckBox(debug_group, controller,
+                     "-VR", i18n("Write symbol info in an .rsm file"));
+    layout2->addWidget(debug_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    QVButtonGroup *debug_add = new QVButtonGroup(i18n("Symbol Reference Information"), this);
+    QRadioButton *m_default = new QRadioButton(i18n("Default (-$YD)"), debug_add);
+    m_default->setChecked(true);
+    new FlagRadioButton(debug_add, radioController,
+                        "'-$Y-'", i18n("No information"));
+    new FlagRadioButton(debug_add, radioController,
+                        "'-$YD'", i18n("Definition information"));
+    new FlagRadioButton(debug_add, radioController,
+                        "'-$Y+'", i18n("Full reference information"));
+    layout2->addWidget(debug_add);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QHBoxLayout *layout3 = new QHBoxLayout(layout, KDialog::spacingHint());
+    QPushButton *release = new QPushButton(i18n("Release"), this);
+    QPushButton *debug = new QPushButton(i18n("Debug"), this);
+    layout3->addWidget(release);
+    layout3->addWidget(debug);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    connect(release, SIGNAL(clicked()), this, SLOT(setReleaseOptions()));
+    connect(debug, SIGNAL(clicked()), this, SLOT(setDebugOptions()));
+
+    layout->addStretch();
+}
+
+ DebugOptimTab::~ DebugOptimTab( )
+{
+    delete controller;
+    delete radioController;
+}
+
+void DebugOptimTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    radioController->readFlags(str);
+}
+
+void DebugOptimTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    radioController->writeFlags(str);
+}
+
+void DebugOptimTab::setReleaseOptions()
+{
+    QStringList sl = QStringList::split(",", "'-$O+','-$Y-','-$D-','-$L-'");
+    readFlags(&sl);
+    gdb->setChecked(false);
+    namespacedb->setChecked(false);
+    symboldb->setChecked(false);
+}
+
+void DebugOptimTab::setDebugOptions()
+{
+    QStringList sl = QStringList::split(",", "'-$O-','-$Y+','-$D+','-$L+',-V,-VN");
+    readFlags(&sl);
+}
+
+#include "optiontabs.moc"
diff --git a/languages/pascal/compiler/dccoptions/optiontabs.h b/languages/pascal/compiler/dccoptions/optiontabs.h
new file mode 100644
index 00000000..048684a5
--- /dev/null
+++ b/languages/pascal/compiler/dccoptions/optiontabs.h
@@ -0,0 +1,116 @@
+/***************************************************************************
+ *   Copyright (C) 2003 by Alexander Dymo                                  *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ ***************************************************************************/
+#ifndef OPTIONTABS_H
+#define OPTIONTABS_H
+
+#include <qwidget.h>
+
+class FlagRadioButtonController;
+class FlagPathEditController;
+class FlagCheckBoxController;
+class FlagEditController;
+class QRadioButton;
+class FlagRadioButton;
+class FlagCheckBox;
+
+class LinkerTab : public QWidget
+{
+public:
+    LinkerTab( QWidget *parent=0, const char *name=0 );
+    ~LinkerTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagRadioButtonController *radioController;
+    FlagPathEditController *pathController;
+    FlagEditController *editController;
+};
+
+class LocationsTab : public QWidget
+{
+public:
+    LocationsTab( QWidget *parent=0, const char *name=0 );
+    ~LocationsTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagPathEditController *pathController;
+};
+
+class Locations2Tab : public QWidget
+{
+public:
+    Locations2Tab( QWidget *parent=0, const char *name=0 );
+    ~Locations2Tab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagPathEditController *pathController;
+};
+
+class GeneralTab: public QWidget
+{
+public:
+    GeneralTab( QWidget *parent=0, const char *name=0 );
+    ~GeneralTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagEditController *editController;
+};
+
+class CodegenTab : public QWidget
+{
+public:
+    CodegenTab( QWidget *parent=0, const char *name=0 );
+    ~CodegenTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagEditController *listController;
+    FlagRadioButtonController *radioController;
+};
+
+class DebugOptimTab : public QWidget
+{
+    Q_OBJECT
+public:
+    DebugOptimTab( QWidget *parent=0, const char *name=0 );
+    ~DebugOptimTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagRadioButtonController *radioController;
+
+    FlagCheckBox *gdb;
+    FlagCheckBox *namespacedb;
+    FlagCheckBox *symboldb;
+
+private slots:
+    void setReleaseOptions();
+    void setDebugOptions();
+};
+
+#endif
diff --git a/languages/pascal/compiler/fpcoptions/Makefile.am b/languages/pascal/compiler/fpcoptions/Makefile.am
new file mode 100644
index 00000000..2868bd01
--- /dev/null
+++ b/languages/pascal/compiler/fpcoptions/Makefile.am
@@ -0,0 +1,20 @@
+# Here resides the gcc option dialog plugin.
+
+INCLUDES = -I$(top_srcdir)/lib/interfaces -I$(top_srcdir)/lib/interfaces/extras \
+	-I$(top_srcdir)/lib/widgets $(all_includes)
+
+kde_module_LTLIBRARIES = libkdevfpcoptions.la
+libkdevfpcoptions_la_LDFLAGS = -module $(all_libraries) $(KDE_PLUGIN)
+libkdevfpcoptions_la_LIBADD = $(top_builddir)/lib/libkdevelop.la \
+	$(top_builddir)/lib/widgets/libkdevwidgets.la $(top_builddir)/lib/interfaces/extras/libkdevextras.la $(LIB_KHTML)
+
+libkdevfpcoptions_la_SOURCES = fpcoptionsplugin.cpp optiontabs.cpp
+
+METASOURCES = AUTO
+
+servicedir = $(kde_servicesdir)
+service_DATA = kdevfpcoptions.desktop
+
+
+
+
diff --git a/languages/pascal/compiler/fpcoptions/fpcoptionsplugin.cpp b/languages/pascal/compiler/fpcoptions/fpcoptionsplugin.cpp
new file mode 100644
index 00000000..6fd73e5f
--- /dev/null
+++ b/languages/pascal/compiler/fpcoptions/fpcoptionsplugin.cpp
@@ -0,0 +1,126 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#include <qvbox.h>
+
+#include <klocale.h>
+#include <kgenericfactory.h>
+
+#include "optiontabs.h"
+#include "fpcoptionsplugin.h"
+
+K_EXPORT_COMPONENT_FACTORY( libkdevfpcoptions, KGenericFactory<FpcOptionsPlugin>( "kdevfpcoptions" ) )
+
+FpcOptionsPlugin::FpcOptionsPlugin(QObject *parent, const char *name, const QStringList& /*args*/)
+    : KDevCompilerOptions(parent, name)
+{
+}
+
+FpcOptionsPlugin::~FpcOptionsPlugin()
+{
+}
+
+QString FpcOptionsPlugin::exec(QWidget *parent, const QString &flags)
+{
+    FpcOptionsDialog *dlg = new FpcOptionsDialog(parent, "fpc options dialog");
+    QString newFlags = flags;
+    dlg->setFlags(flags);
+    if (dlg->exec() == QDialog::Accepted)
+        newFlags = dlg->flags();
+    delete dlg;
+    return newFlags;
+}
+
+
+
+FpcOptionsDialog::FpcOptionsDialog( QWidget *parent, const char *name )
+    : KDialogBase(Tabbed, i18n("Free Pascal Compiler Options"), Ok|Cancel, Ok, parent, name, true)
+{
+    QVBox *vbox;
+
+    vbox = addVBoxPage(i18n("Language"));
+    language = new LanguageTab(vbox, "language tab");
+
+    vbox = addVBoxPage(i18n("Locations I"));
+    directories = new FilesAndDirectoriesTab(vbox, "directories tab");
+
+    vbox = addVBoxPage(i18n("Locations II"));
+    directories2 = new FilesAndDirectoriesTab2(vbox, "directories2 tab");
+
+    vbox = addVBoxPage(i18n("Debug && Optimization"));
+    debug_optim = new DebugOptimTab(vbox, "debug_optim tab");
+
+    vbox = addVBoxPage(i18n("Code Generation"));
+    codegen = new CodegenTab(vbox, "codegen tab");
+
+    vbox = addVBoxPage(i18n("Assembler"));
+    assembler = new AssemblerTab(vbox, "assembler tab");
+
+    vbox = addVBoxPage(i18n("Linker"));
+    linker = new LinkerTab(vbox, "linker tab");
+
+    vbox = addVBoxPage(i18n("Feedback"));
+    feedback = new FeedbackTab(vbox, "feedback tab");
+
+    vbox = addVBoxPage(i18n("Miscellaneous"));
+    misc = new MiscTab(vbox, "miscellaneous tab");
+}
+
+FpcOptionsDialog::~FpcOptionsDialog()
+{
+}
+
+void FpcOptionsDialog::setFlags(const QString &flags)
+{
+    QStringList flaglist = QStringList::split(" ", flags);
+
+    feedback->readFlags(&flaglist);
+    language->readFlags(&flaglist);
+    assembler->readFlags(&flaglist);
+    linker->readFlags(&flaglist);
+    codegen->readFlags(&flaglist);
+    debug_optim->readFlags(&flaglist);
+    directories->readFlags(&flaglist);
+    directories2->readFlags(&flaglist);
+    misc->readFlags(&flaglist);
+    unrecognizedFlags = flaglist;
+}
+
+QString FpcOptionsDialog::flags() const
+{
+    QStringList flaglist;
+
+    language->writeFlags(&flaglist);
+    directories->writeFlags(&flaglist);
+    directories2->writeFlags(&flaglist);
+    debug_optim->writeFlags(&flaglist);
+    codegen->writeFlags(&flaglist);
+    assembler->writeFlags(&flaglist);
+    linker->writeFlags(&flaglist);
+    feedback->writeFlags(&flaglist);
+    misc->writeFlags(&flaglist);
+
+    QString flags;
+    QStringList::ConstIterator li;
+    for (li = flaglist.begin(); li != flaglist.end(); ++li) {
+        flags += (*li);
+        flags += " ";
+    }
+
+    for (li = unrecognizedFlags.begin(); li != unrecognizedFlags.end(); ++li) {
+        flags += (*li);
+        flags += " ";
+    }
+
+    flags.truncate(flags.length()-1);
+    return flags;
+}
+
+#include "fpcoptionsplugin.moc"
diff --git a/languages/pascal/compiler/fpcoptions/fpcoptionsplugin.h b/languages/pascal/compiler/fpcoptions/fpcoptionsplugin.h
new file mode 100644
index 00000000..f6b15fff
--- /dev/null
+++ b/languages/pascal/compiler/fpcoptions/fpcoptionsplugin.h
@@ -0,0 +1,63 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#ifndef DCCOPTIONSPLUGIN_H
+#define DCCOPTIONSPLUGIN_H
+
+#include <kdialogbase.h>
+
+#include "kdevcompileroptions.h"
+
+class FpcOptionsPlugin : public KDevCompilerOptions
+{
+    Q_OBJECT
+
+public:
+    FpcOptionsPlugin( QObject *parent, const char *name, const QStringList &args );
+    ~FpcOptionsPlugin();
+
+    virtual QString exec(QWidget *parent, const QString &flags);
+};
+
+
+class FeedbackTab;
+class FilesAndDirectoriesTab;
+class LanguageTab;
+class CodegenTab;
+
+class FpcOptionsDialog : public KDialogBase
+{
+public:
+    FpcOptionsDialog( QWidget *parent=0, const char *name=0 );
+    ~FpcOptionsDialog();
+
+    void setFlags(const QString &flags);
+    QString flags() const;
+
+private:
+/*    GeneralTab *general;
+    OptimizationTab *optimization;
+    G77Tab *g77;
+    Warnings1Tab *warnings1;
+    Warnings2Tab *warnings2;*/
+
+    FeedbackTab *feedback;
+    FilesAndDirectoriesTab *directories;
+    FilesAndDirectoriesTab2 *directories2;
+    DebugOptimTab *debug_optim;
+    LanguageTab *language;
+    CodegenTab *codegen;
+    AssemblerTab *assembler;
+    LinkerTab *linker;
+    MiscTab *misc;
+    QStringList unrecognizedFlags;
+};
+
+#endif
diff --git a/languages/pascal/compiler/fpcoptions/kdevfpcoptions.desktop b/languages/pascal/compiler/fpcoptions/kdevfpcoptions.desktop
new file mode 100644
index 00000000..246cf08b
--- /dev/null
+++ b/languages/pascal/compiler/fpcoptions/kdevfpcoptions.desktop
@@ -0,0 +1,55 @@
+[Desktop Entry]
+Type=Service
+Exec=fpc
+Comment=Free Pascal Compiler
+Comment[br]=Dastumer Pascal dieub
+Comment[ca]=Compilador Free Pascal
+Comment[da]=Free Pascal oversætter
+Comment[el]=Μεταγλωττιστής Free Pascal
+Comment[es]=Compilador Free Pascal
+Comment[et]=Free Pascal kompilaator
+Comment[eu]=Free Pascal konpiladorea
+Comment[fa]=مترجم آزاد پاسکال
+Comment[fr]=Compilateur Free Pascal
+Comment[ga]=Tiomsaitheoir Saor Pascal
+Comment[gl]=Compilador Free Pascal
+Comment[hi]=फ�री पॉस�कल कम�पायलर
+Comment[hu]=Szabad forráskódú Pascal fordítóprogram
+Comment[is]=Frjáls Pascal þýðandi
+Comment[it]=Compilatore per Free Pascal
+Comment[ja]=Free Pascal コンパイラ
+Comment[nds]=Free Pascal-Kompilerer
+Comment[ne]=स�वतन�त�र पास�कल कम�पाइलर
+Comment[nl]=Free Pascal-compiler
+Comment[pt]=Compilador Free Pascal
+Comment[pt_BR]=Compilador Free Pascal
+Comment[ru]=Компил�тор Free Pascal
+Comment[sk]=Voľný Pascal kompilátor
+Comment[sl]=Prevajalnik za Free Pascal
+Comment[sr]=Слободни преводилац Pascal-а
+Comment[sr@Latn]=Slobodni prevodilac Pascal-a
+Comment[sv]=Fri Pascal-kompilator
+Comment[ta]=இலவச பாஸ�கல� தொக�ப�பி
+Comment[tg]=Талфифгари Free Pascal 
+Comment[tr]=Serbest Pascal Derleyicisi
+Comment[zh_CN]=Free Pascal 编译器
+Comment[zh_TW]=Free Pascal 編譯器
+Name=FpcOptions
+Name[da]=Free Pascal oversætter indstillinger
+Name[de]=Fpc-Einstellungen (KDevelop)
+Name[hi]=�फपीसी-विकल�प
+Name[nds]=Fpc-Optschonen (KDevelop)
+Name[pl]=Opcje Fpc
+Name[sk]=Fpc možnosti
+Name[sl]=Možnosti Fpc
+Name[sv]=Alternativ för fpc
+Name[ta]=Fpcவிர�ப�பங�கள� 
+Name[tg]=FpcИнтихобҳо
+Name[zh_TW]=Fpc �項
+ServiceTypes=KDevelop/CompilerOptions
+X-KDE-Library=libkdevfpcoptions
+X-KDevelop-Version=5
+X-KDevelop-Language=Pascal
+X-KDevelop-Args=fpc
+X-KDevelop-Default=true
+
diff --git a/languages/pascal/compiler/fpcoptions/optiontabs.cpp b/languages/pascal/compiler/fpcoptions/optiontabs.cpp
new file mode 100644
index 00000000..2579cb3c
--- /dev/null
+++ b/languages/pascal/compiler/fpcoptions/optiontabs.cpp
@@ -0,0 +1,657 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#include <kdialog.h>
+#include <klocale.h>
+
+#include <qspinbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qvbuttongroup.h>
+#include <qapplication.h>
+#include <qframe.h>
+#include <qpushbutton.h>
+
+#include "flagboxes.h"
+
+#include "optiontabs.h"
+
+FeedbackTab::FeedbackTab(QWidget *parent, const char *name)
+    : QWidget(parent, name), controller(new FlagCheckBoxController(QStringList::split(",","-v")))
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    QVButtonGroup *output_group = new QVButtonGroup(i18n("Output"), this);
+    new FlagCheckBox(output_group, controller,
+                     "-vr", i18n("Format errors like GCC does"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *verbose_group = new QVButtonGroup(i18n("Verbose"), this);
+    new FlagCheckBox(verbose_group, controller,
+                     "-va", i18n("Write all possible info"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-v0", i18n("Write no messages"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-ve", i18n("Show only errors"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-vi", i18n("Show some general information"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-vw", i18n("Issue warnings"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-vn", i18n("Issue notes"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-vh", i18n("Issue hints"));
+    new FlagCheckBox(verbose_group, controller,
+                     "-vd", i18n("Write other debugging info"));
+
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *other_group = new QVButtonGroup(i18n("Other Information"), this);
+    new FlagCheckBox(other_group, controller,
+                     "-vl", i18n("Show line numbers when processing files"));
+    new FlagCheckBox(other_group, controller,
+                     "-vu", i18n("Print information on loaded units"));
+    new FlagCheckBox(other_group, controller,
+                     "-vt", i18n("Print the names of loaded files"));
+    new FlagCheckBox(other_group, controller,
+                     "-vm", i18n("Write which macros are defined"));
+    new FlagCheckBox(other_group, controller,
+                     "-vc", i18n("Warn when processing a conditional"));
+    new FlagCheckBox(other_group, controller,
+                     "-vp", i18n("Print the names of procedures and functions"));
+    new FlagCheckBox(other_group, controller,
+                     "-vb", i18n("Show all procedure declarations if an overloaded function error occurs"));
+
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+FeedbackTab::~FeedbackTab()
+{
+    delete controller;
+}
+
+void FeedbackTab::readFlags(QStringList *list)
+{
+    controller->readFlags(list);
+}
+
+void FeedbackTab::writeFlags(QStringList *list)
+{
+    controller->writeFlags(list);
+}
+
+
+
+FilesAndDirectoriesTab::FilesAndDirectoriesTab( QWidget * parent, const char * name )
+    :QWidget(parent, name), controller(new FlagCheckBoxController()),
+    pathController(new FlagPathEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    new FlagPathEdit(this, ":", pathController,
+                     "-Fu", i18n("Unit search path (delimited by \":\"):"));
+    new FlagPathEdit(this, ":", pathController,
+                     "-Fi", i18n("Include file search path (delimited by \":\"):"));
+    new FlagPathEdit(this, ":", pathController,
+                     "-Fo", i18n("Object file search path (delimited by \":\"):"));
+    new FlagPathEdit(this, ":", pathController,
+                     "-Fl", i18n("Library search path (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addStretch();
+}
+
+FilesAndDirectoriesTab::~FilesAndDirectoriesTab( )
+{
+    delete controller;
+    delete pathController;
+}
+
+void FilesAndDirectoriesTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    pathController->readFlags(str);
+}
+
+void FilesAndDirectoriesTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    pathController->writeFlags(str);
+}
+
+FilesAndDirectoriesTab2::FilesAndDirectoriesTab2( QWidget * parent, const char * name )
+    :QWidget(parent, name), controller(new FlagCheckBoxController()),
+    pathController(new FlagPathEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    new FlagPathEdit(this, "", pathController,
+                     "-FE", i18n("Write executables and units in:"));
+    new FlagPathEdit(this, "", pathController,
+                     "-FU", i18n("Write units in:"));
+    new FlagPathEdit(this, "", pathController,
+                     "-o", i18n("Executable name:"), KFile::File);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(20);
+
+    new FlagPathEdit(this, "", pathController,
+                     "-e", i18n("Location of as and ld programs:"));
+    new FlagPathEdit(this, "", pathController,
+                     "-FL", i18n("Dynamic linker executable:"), KFile::File);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(20);
+
+    new FlagPathEdit(this, "", pathController,
+                     "-Fr", i18n("Compiler messages file:"), KFile::File);
+    new FlagPathEdit(this, "", pathController,
+                     "-Fe", i18n("Write compiler messages to file:"), KFile::File);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+FilesAndDirectoriesTab2::~FilesAndDirectoriesTab2( )
+{
+    delete controller;
+    delete pathController;
+}
+
+void FilesAndDirectoriesTab2::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    pathController->readFlags(str);
+}
+
+void FilesAndDirectoriesTab2::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    pathController->writeFlags(str);
+}
+
+
+LanguageTab::LanguageTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController(QStringList::split(",","-v")))
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    QVButtonGroup *compat_group = new QVButtonGroup(i18n("Pascal Compatibility"), this);
+    new FlagCheckBox(compat_group, controller,
+                     "-S2", i18n("Switch on Delphi 2 extensions"));
+    new FlagCheckBox(compat_group, controller,
+                     "-Sd", i18n("Strict Delphi compatibility mode"));
+    new FlagCheckBox(compat_group, controller,
+                     "-So", i18n("Borland TP 7.0 compatibility mode"));
+    new FlagCheckBox(compat_group, controller,
+                     "-Sp", i18n("GNU Pascal compatibility mode"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *ccompat_group = new QVButtonGroup(i18n("C/C++ Compatibility"), this);
+    new FlagCheckBox(ccompat_group, controller,
+                     "-Sc", i18n("Support C style operators *=, +=, /=, -="));
+    new FlagCheckBox(ccompat_group, controller,
+                     "-Si", i18n("Support C++ style INLINE"));
+    new FlagCheckBox(ccompat_group, controller,
+                     "-Sm", i18n("Support C style macros"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *lang_group = new QVButtonGroup(i18n("Language"), this);
+    new FlagCheckBox(lang_group, controller,
+                     "-Sg", i18n("Support the label and goto commands"));
+    new FlagCheckBox(lang_group, controller,
+                     "-Sh", i18n("Use ansistrings by default for strings"));
+    new FlagCheckBox(lang_group, controller,
+                     "-Ss", i18n("Require the name of constructors to be init\n and the name of destructors to be done"));
+    new FlagCheckBox(lang_group, controller,
+                     "-St", i18n("Allow the static keyword in objects"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+ LanguageTab::~ LanguageTab( )
+{
+    delete controller;
+}
+
+void LanguageTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+}
+
+void LanguageTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+}
+
+AssemblerTab::AssemblerTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController()),
+    asmController(new FlagRadioButtonController)
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+//    layout->setAutoAdd(true);
+
+    QBoxLayout *layout2 = new QHBoxLayout(layout, KDialog::spacingHint());
+
+    QVButtonGroup *info_group = new QVButtonGroup(i18n("Assembler Info"), this);
+    new FlagCheckBox(info_group, controller,
+                     "-a", i18n("Do not delete assembler files"));
+    new FlagCheckBox(info_group, controller,
+                     "-al", i18n("List source"));
+    new FlagCheckBox(info_group, controller,
+                     "-ar", i18n("List register allocation and release info"));
+    new FlagCheckBox(info_group, controller,
+                     "-at", i18n("List temporary allocations and deallocations"));
+    layout2->addWidget(info_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    //layout->addSpacing(10);
+
+    QVButtonGroup *asmkind_group = new QVButtonGroup(i18n("Assembler Reader"), this);
+    QRadioButton *m_defaultkind = new QRadioButton(i18n("Use default reader"), asmkind_group);
+    m_defaultkind->setChecked(true);
+    new FlagRadioButton(asmkind_group, asmController,
+                        "-Ratt", i18n("AT&T style assembler"));
+    new FlagRadioButton(asmkind_group, asmController,
+                        "-Rintel", i18n("Intel style assembler"));
+    new FlagRadioButton(asmkind_group, asmController,
+                        "-Rdirect", i18n("Direct assembler"));
+    layout2->addWidget(asmkind_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+
+    QVButtonGroup *asm_group = new QVButtonGroup(i18n("Assembler Output"), this);
+    new FlagCheckBox(asm_group, controller,
+                     "-P", i18n("Use pipes instead of files when assembling"));
+    QRadioButton *m_default = new QRadioButton(i18n("Use default output"), asm_group);
+    m_default->setChecked(true);
+    new FlagRadioButton(asm_group, asmController,
+                        "-Aas", i18n("Use GNU as"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Aasout", i18n("Use GNU asaout"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Anasmcoff", i18n("Use NASM coff"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Anasmelf", i18n("Use NASM elf"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Anasmobj", i18n("Use NASM obj"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Amasm", i18n("Use MASM"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Atasm", i18n("Use TASM"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Acoff", i18n("Use coff"));
+    new FlagRadioButton(asm_group, asmController,
+                        "-Apecoff", i18n("Use pecoff"));
+    layout->addWidget(asm_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+ AssemblerTab::~ AssemblerTab( )
+{
+    delete controller;
+    delete asmController;
+}
+
+void AssemblerTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    asmController->readFlags(str);
+}
+
+void AssemblerTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    asmController->writeFlags(str);
+}
+
+
+
+DebugOptimTab::DebugOptimTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController()),
+    optimController(new FlagRadioButtonController)
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+//    layout->setAutoAdd(true);
+
+    QBoxLayout *layout2 = new QHBoxLayout(layout, KDialog::spacingHint());
+
+    QBoxLayout *layout3 = new QVBoxLayout(layout2, KDialog::spacingHint());
+
+    QVButtonGroup *debug_group = new QVButtonGroup(i18n("Debugging"), this);
+    new FlagCheckBox(debug_group, controller,
+                     "-g", i18n("Generate information for GDB"), "-!g");
+    new FlagCheckBox(debug_group, controller,
+                     "-gd", i18n("Generate information for DBX"), "-!gd");
+    new FlagCheckBox(debug_group, controller,
+                     "-gl", i18n("Use lineinfo unit"), "-!gl");
+    new FlagCheckBox(debug_group, controller,
+                     "-gh", i18n("Use heaptrc unit"), "-!gh");
+    new FlagCheckBox(debug_group, controller,
+                     "-gc", i18n("Generate checks for pointers"), "-!gc");
+    layout3->addWidget(debug_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout3->addSpacing(10);
+
+    QVButtonGroup *profile_group = new QVButtonGroup(i18n("Profiling"), this);
+    new FlagCheckBox(profile_group, controller,
+                     "-pg", i18n("Generate profiler code for gprof"), "-!pg");
+    layout3->addWidget(profile_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout3->addSpacing(10);
+
+    QBoxLayout *layout4 = new QVBoxLayout(layout2, KDialog::spacingHint());
+
+    QVButtonGroup *optim_group1 = new QVButtonGroup(i18n("General Optimization"), this);
+    m_default = new QRadioButton(i18n("Default"), optim_group1);
+    m_default->setChecked(true);
+    new FlagRadioButton(optim_group1, optimController,
+                        "-Og", i18n("Generate smaller code"));
+    optim1 = new FlagRadioButton(optim_group1, optimController,
+                        "-OG", i18n("Generate faster code"));
+    layout4->addWidget(optim_group1);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout4->addSpacing(10);
+
+    QVButtonGroup *optim_group2 = new QVButtonGroup(i18n("Optimization Levels"), this);
+    m_default2 = new QRadioButton(i18n("Default"), optim_group2);
+    m_default2->setChecked(true);
+    new FlagRadioButton(optim_group2, optimController,
+                        "-O1", i18n("Level 1"));
+    new FlagRadioButton(optim_group2, optimController,
+                        "-O2", i18n("Level 2"));
+    optim2 = new FlagRadioButton(optim_group2, optimController,
+                        "-O3", i18n("Level 3"));
+    layout4->addWidget(optim_group2);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout4->addSpacing(10);
+
+    QHBoxLayout *layout5 = new QHBoxLayout(layout, KDialog::spacingHint());
+
+    QVButtonGroup *optim_group3 = new QVButtonGroup(i18n("Architecture"), this);
+    m_default3 = new QRadioButton(i18n("Default"), optim_group3);
+    m_default3->setChecked(true);
+    new FlagRadioButton(optim_group3, optimController,
+                     "-Op1", i18n("386/486"));
+    new FlagRadioButton(optim_group3, optimController,
+                     "-Op2", i18n("Pentium/PentiumMMX"));
+    new FlagRadioButton(optim_group3, optimController,
+                     "-Op2", i18n("PentiumPro/PII/Cyrix 6x86/K6"));
+    layout5->addWidget(optim_group3);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    QVButtonGroup *optim_group4 = new QVButtonGroup(i18n("Another Optimization"), this);
+    new FlagCheckBox(optim_group4, controller,
+                     "-Or", i18n("Use register variables"), "-!Or");
+    new FlagCheckBox(optim_group4, controller,
+                     "-Ou", i18n("Uncertain optimizations"), "-!Ou");
+    layout5->addWidget(optim_group4);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    QHBoxLayout *layout6 = new QHBoxLayout(layout, KDialog::spacingHint());
+    QPushButton *release = new QPushButton(i18n("Release"), this);
+    QPushButton *debug = new QPushButton(i18n("Debug"), this);
+    layout6->addWidget(release);
+    layout6->addWidget(debug);
+    connect(release, SIGNAL(clicked()), this, SLOT(setReleaseOptions()));
+    connect(debug, SIGNAL(clicked()), this, SLOT(setDebugOptions()));
+
+    layout->addStretch();
+}
+
+ DebugOptimTab::~ DebugOptimTab( )
+{
+    delete controller;
+    delete optimController;
+}
+
+void DebugOptimTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    optimController->readFlags(str);
+}
+
+void DebugOptimTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    optimController->writeFlags(str);
+}
+
+void DebugOptimTab::setReleaseOptions()
+{
+    m_default->setChecked(true);
+    m_default2->setChecked(true);
+//    m_default3->setChecked(true);
+    QStringList sl = QStringList::split(",", "-!g,-!gd,-!gl,-!gh,-!gc,-!pg,-!Ou,-!Or");
+    readFlags(&sl);
+    optim1->setChecked(true);
+    optim2->setChecked(true);
+}
+
+void DebugOptimTab::setDebugOptions()
+{
+    QStringList sl = QStringList::split(",", "-g,-gl,-gh,-gc");
+    readFlags(&sl);
+    m_default->setChecked(true);
+    m_default2->setChecked(true);
+//    m_default3->setChecked(true);
+}
+
+CodegenTab::CodegenTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController()),
+    listController(new FlagEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    QVButtonGroup *compile_group = new QVButtonGroup(i18n("Compile Time Checks"), this);
+    new FlagCheckBox(compile_group, controller,
+                     "-Sa", i18n("Include assert statements in compiled code"));
+    new FlagCheckBox(compile_group, controller,
+                     "-Un", i18n("Do not check the unit name for being the same as the file name"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *run_group = new QVButtonGroup(i18n("Run Time Checks"), this);
+    new FlagCheckBox(run_group, controller,
+                     "-Cr", i18n("Range checking"));
+    new FlagCheckBox(run_group, controller,
+                     "-Ct", i18n("Stack checking"));
+    new FlagCheckBox(run_group, controller,
+                     "-Ci", i18n("Input/Output checking"));
+    new FlagCheckBox(run_group, controller,
+                     "-Co", i18n("Integer overflow checking"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    new FlagListEdit(this, ":", listController, "-d", i18n("Conditional defines (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    new FlagListEdit(this, ":", listController, "-u", i18n("Undefine conditional defines (delimited by \":\"):"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    new FlagSpinEdit(this, 1024, 67107840, 1, 131072, listController,
+                    "-Cs", i18n("Stack size:"));
+    new FlagSpinEdit(this, 1024, 67107840, 1, 2097152, listController,
+                    "-Ch", i18n("Heap size:"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+CodegenTab::~ CodegenTab( )
+{
+    delete controller;
+    delete listController;
+}
+
+void CodegenTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    listController->readFlags(str);
+}
+
+void CodegenTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    listController->writeFlags(str);
+}
+
+LinkerTab::LinkerTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController()),
+    listController(new FlagEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+
+    QBoxLayout *layout2 = new QHBoxLayout(layout, KDialog::spacingHint());
+
+    QVButtonGroup *link_group = new QVButtonGroup(i18n("Linking Stage"), this);
+    new FlagCheckBox(link_group, controller,
+                     "-CD", i18n("Create dynamic library"));
+    new FlagCheckBox(link_group, controller,
+                     "-CX", i18n("Create smartlinked units"));
+    new FlagCheckBox(link_group, controller,
+                     "-Ur", i18n("Generate release units"));
+    new FlagCheckBox(link_group, controller,
+                     "-Cn", i18n("Omit the linking stage"));
+    new FlagCheckBox(link_group, controller,
+                     "-s",  i18n("Create assembling and linking script"));
+    layout2->addWidget(link_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    QVButtonGroup *exec_group = new QVButtonGroup(i18n("Executable Generation"), this);
+    new FlagCheckBox(exec_group, controller,
+                     "-Xs",  i18n("Strip the symbols from the executable"));
+    new FlagCheckBox(exec_group, controller,
+                     "-XS",  i18n("Link with static units"));
+    new FlagCheckBox(exec_group, controller,
+                     "-XX",  i18n("Link with smartlinked units"));
+    new FlagCheckBox(exec_group, controller,
+                     "-XD",  i18n("Link with dynamic libraries"));
+    new FlagCheckBox(exec_group, controller,
+                     "-Xc",  i18n("Link with the C library"));
+    layout2->addWidget(exec_group);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    FlagListEdit *led = new FlagListEdit(this, ":", listController, "-k", i18n("Options passed to the linker (delimited by \":\"):"));
+    layout->addWidget(led);
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+
+    layout->addStretch();
+}
+
+LinkerTab::~LinkerTab( )
+{
+    delete controller;
+    delete listController;
+}
+
+void LinkerTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    listController->readFlags(str);
+}
+
+void LinkerTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    listController->writeFlags(str);
+}
+
+MiscTab::MiscTab( QWidget * parent, const char * name )
+    : QWidget(parent, name), controller(new FlagCheckBoxController()),
+    radioController(new FlagRadioButtonController()),
+    pathController(new FlagPathEditController()),
+    editController(new FlagEditController())
+{
+    QBoxLayout *layout = new QVBoxLayout(this, KDialog::marginHint(), KDialog::spacingHint());
+    layout->setAutoAdd(true);
+
+    new FlagCheckBox(this, controller,
+                     "-B", i18n("Recompile all used units"));
+    new FlagCheckBox(this, controller,
+                     "-n", i18n("Do not read default configuration file"));
+    new FlagPathEdit(this, "", pathController,
+                     "@", i18n("Compiler configuration file:"), KFile::File);
+    new FlagSpinEdit(this, 1, 1000, 1, 50, editController,
+                    "-Se", i18n("Stop after the error:"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *browser_group = new QVButtonGroup(i18n("Browser Info"), this);
+    QRadioButton *m_defaultBrowser = new QRadioButton(i18n("No browser info"), browser_group);
+    m_defaultBrowser->setChecked(true);
+    new FlagRadioButton(browser_group, radioController,
+                     "-b", i18n("Global browser info"));
+    new FlagRadioButton(browser_group, radioController,
+                     "-bl", i18n("Global and local browser info"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    QVButtonGroup *target_group = new QVButtonGroup(i18n("Target OS"), this);
+    QRadioButton *m_defaultTarget = new QRadioButton(i18n("Default"), target_group);
+    m_defaultTarget->setChecked(true);
+    new FlagRadioButton(target_group, radioController,
+                     "-TGO32V1", i18n("DOS and version 1 of the DJ DELORIE extender"));
+    new FlagRadioButton(target_group, radioController,
+                     "-TGO32V2", i18n("DOS and version 2 of the DJ DELORIE extender"));
+    new FlagRadioButton(target_group, radioController,
+                     "-TLINUX",  i18n("Linux"));
+    new FlagRadioButton(target_group, radioController,
+                     "-TOS2", i18n("OS/2 (2.x) using the EMX extender"));
+    new FlagRadioButton(target_group, radioController,
+                     "-TWIN32", i18n("WINDOWS 32 bit"));
+    new FlagRadioButton(target_group, radioController,
+                     "-TSUNOS", i18n("SunOS/Solaris"));
+    new FlagRadioButton(target_group, radioController,
+                     "-TBEOS", i18n("BeOS"));
+    QApplication::sendPostedEvents(this, QEvent::ChildInserted);
+    layout->addSpacing(10);
+
+    layout->addStretch();
+}
+
+MiscTab::~ MiscTab( )
+{
+    delete controller;
+    delete pathController;
+    delete radioController;
+    delete editController;
+}
+
+void MiscTab::readFlags( QStringList * str )
+{
+    controller->readFlags(str);
+    radioController->readFlags(str);
+    pathController->readFlags(str);
+    editController->readFlags(str);
+}
+
+void MiscTab::writeFlags( QStringList * str )
+{
+    controller->writeFlags(str);
+    radioController->writeFlags(str);
+    pathController->writeFlags(str);
+    editController->writeFlags(str);
+}
+
+#include "optiontabs.moc"
diff --git a/languages/pascal/compiler/fpcoptions/optiontabs.h b/languages/pascal/compiler/fpcoptions/optiontabs.h
new file mode 100644
index 00000000..56109ae2
--- /dev/null
+++ b/languages/pascal/compiler/fpcoptions/optiontabs.h
@@ -0,0 +1,161 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ ***************************************************************************/
+#ifndef OPTIONTABS_H
+#define OPTIONTABS_H
+
+#include <qwidget.h>
+
+class QSpinBox;
+class QRadioButton;
+class FlagRadioButton;
+class FlagCheckBoxController;
+class FlagRadioButtonController;
+class FlagPathEditController;
+class FlagEditController;
+
+class FeedbackTab : public QWidget
+{
+public:
+    FeedbackTab( QWidget *parent=0, const char *name=0 );
+    ~FeedbackTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+};
+
+class FilesAndDirectoriesTab: public QWidget
+{
+public:
+    FilesAndDirectoriesTab( QWidget *parent = 0, const char *name = 0);
+    ~FilesAndDirectoriesTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagPathEditController *pathController;
+};
+
+class FilesAndDirectoriesTab2: public QWidget
+{
+public:
+    FilesAndDirectoriesTab2( QWidget *parent = 0, const char *name = 0);
+    ~FilesAndDirectoriesTab2();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagPathEditController *pathController;
+};
+
+class LanguageTab : public QWidget
+{
+public:
+    LanguageTab( QWidget *parent=0, const char *name=0 );
+    ~LanguageTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+};
+
+class AssemblerTab : public QWidget
+{
+public:
+    AssemblerTab( QWidget *parent=0, const char *name=0 );
+    ~AssemblerTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagRadioButtonController *asmController;
+};
+
+class DebugOptimTab : public QWidget
+{
+    Q_OBJECT
+public:
+    DebugOptimTab( QWidget *parent=0, const char *name=0 );
+    ~DebugOptimTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagRadioButtonController *optimController;
+
+    QRadioButton *m_default;
+    QRadioButton *m_default2;
+    QRadioButton *m_default3;
+    FlagRadioButton *optim1;
+    FlagRadioButton *optim2;
+
+private slots:
+    void setReleaseOptions();
+    void setDebugOptions();
+};
+
+class CodegenTab : public QWidget
+{
+public:
+    CodegenTab( QWidget *parent=0, const char *name=0 );
+    ~CodegenTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagEditController *listController;
+};
+
+class LinkerTab : public QWidget
+{
+public:
+    LinkerTab( QWidget *parent=0, const char *name=0 );
+    ~LinkerTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagEditController *listController;
+};
+
+class MiscTab : public QWidget
+{
+public:
+    MiscTab( QWidget *parent=0, const char *name=0 );
+    ~MiscTab();
+
+    void readFlags(QStringList *str);
+    void writeFlags(QStringList *str);
+
+private:
+    FlagCheckBoxController *controller;
+    FlagRadioButtonController *radioController;
+    FlagPathEditController *pathController;
+    FlagEditController *editController;
+};
+
+#endif
diff --git a/languages/pascal/configproblemreporter.ui b/languages/pascal/configproblemreporter.ui
new file mode 100644
index 00000000..a215f7a8
--- /dev/null
+++ b/languages/pascal/configproblemreporter.ui
@@ -0,0 +1,88 @@
+<!DOCTYPE UI><UI version="3.1" stdsetdef="1">
+<class>ConfigureProblemReporter</class>
+<widget class="QWidget">
+    <property name="name">
+        <cstring>ConfigureProblemReporter</cstring>
+    </property>
+    <property name="geometry">
+        <rect>
+            <x>0</x>
+            <y>0</y>
+            <width>390</width>
+            <height>306</height>
+        </rect>
+    </property>
+    <vbox>
+        <property name="name">
+            <cstring>unnamed</cstring>
+        </property>
+        <widget class="QCheckBox">
+            <property name="name">
+                <cstring>bgParserCheckbox</cstring>
+            </property>
+            <property name="text">
+                <string>&amp;Enable background parsing</string>
+            </property>
+        </widget>
+        <widget class="QSlider">
+            <property name="name">
+                <cstring>delaySlider</cstring>
+            </property>
+            <property name="maxValue">
+                <number>2000</number>
+            </property>
+            <property name="lineStep">
+                <number>250</number>
+            </property>
+            <property name="pageStep">
+                <number>500</number>
+            </property>
+            <property name="orientation">
+                <enum>Horizontal</enum>
+            </property>
+            <property name="tickmarks">
+                <enum>NoMarks</enum>
+            </property>
+            <property name="tickInterval">
+                <number>250</number>
+            </property>
+        </widget>
+        <spacer>
+            <property name="name">
+                <cstring>Spacer1</cstring>
+            </property>
+            <property name="orientation">
+                <enum>Vertical</enum>
+            </property>
+            <property name="sizeType">
+                <enum>Expanding</enum>
+            </property>
+            <property name="sizeHint">
+                <size>
+                    <width>0</width>
+                    <height>101</height>
+                </size>
+            </property>
+        </spacer>
+    </vbox>
+</widget>
+<connections>
+    <connection>
+        <sender>bgParserCheckbox</sender>
+        <signal>toggled(bool)</signal>
+        <receiver>ConfigureProblemReporter</receiver>
+        <slot>bgParserCheckbox_toggled(bool)</slot>
+    </connection>
+</connections>
+<includes>
+    <include location="global" impldecl="in implementation">kdialog.h</include>
+</includes>
+<slots>
+    <slot>init()</slot>
+    <slot>destroy()</slot>
+    <slot>accept()</slot>
+    <slot>bgParserCheckbox_toggled( bool b )</slot>
+</slots>
+<layoutdefaults spacing="6" margin="11"/>
+<layoutfunctions spacing="KDialog::spacingHint" margin="KDialog::marginHint"/>
+</UI>
diff --git a/languages/pascal/doc/Makefile.am b/languages/pascal/doc/Makefile.am
new file mode 100644
index 00000000..a7829d08
--- /dev/null
+++ b/languages/pascal/doc/Makefile.am
@@ -0,0 +1,6 @@
+tocdir = ${kde_datadir}/kdevdocumentation/tocs
+toc_DATA = pascal_bugs_fp.toc
+
+#indexdir = ${kde_datadir}/devdoctreeview/indices
+#index_DATA = 
+
diff --git a/languages/pascal/doc/pascal_bugs_fp.toc b/languages/pascal/doc/pascal_bugs_fp.toc
new file mode 100644
index 00000000..60be2ec5
--- /dev/null
+++ b/languages/pascal/doc/pascal_bugs_fp.toc
@@ -0,0 +1,7 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>Pascal bugs (fp)</title>
+<base href="http://www.freepascal.org/"/>
+<tocsect1 name="Query" url="bugs.html">
+</tocsect1>
+</kdeveloptoc>
diff --git a/languages/pascal/file_templates/Makefile.am b/languages/pascal/file_templates/Makefile.am
new file mode 100644
index 00000000..94891c97
--- /dev/null
+++ b/languages/pascal/file_templates/Makefile.am
@@ -0,0 +1,2 @@
+templatedir = $(kde_datadir)/kdevfilecreate/file-templates
+template_DATA = dpr pas-program pas-unit pp-program pp-unit
diff --git a/languages/pascal/file_templates/dpr b/languages/pascal/file_templates/dpr
new file mode 100644
index 00000000..3f271522
--- /dev/null
+++ b/languages/pascal/file_templates/dpr
@@ -0,0 +1,12 @@
+{
+   Pascal program: $MODULE$
+
+   Description:
+   Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+   Copyright: See COPYING file that comes with this distribution
+}
+program $MODULE$;
+
+begin
+
+end.
diff --git a/languages/pascal/file_templates/pas-program b/languages/pascal/file_templates/pas-program
new file mode 100644
index 00000000..3f271522
--- /dev/null
+++ b/languages/pascal/file_templates/pas-program
@@ -0,0 +1,12 @@
+{
+   Pascal program: $MODULE$
+
+   Description:
+   Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+   Copyright: See COPYING file that comes with this distribution
+}
+program $MODULE$;
+
+begin
+
+end.
diff --git a/languages/pascal/file_templates/pas-unit b/languages/pascal/file_templates/pas-unit
new file mode 100644
index 00000000..98b52e50
--- /dev/null
+++ b/languages/pascal/file_templates/pas-unit
@@ -0,0 +1,19 @@
+{
+   Pascal unit: $MODULE$
+
+   Description:
+   Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+   Copyright: See COPYING file that comes with this distribution
+}
+
+unit $MODULE$;
+
+interface
+
+implementation
+
+initialization
+
+finalization
+
+end.
diff --git a/languages/pascal/file_templates/pp-program b/languages/pascal/file_templates/pp-program
new file mode 100644
index 00000000..3f271522
--- /dev/null
+++ b/languages/pascal/file_templates/pp-program
@@ -0,0 +1,12 @@
+{
+   Pascal program: $MODULE$
+
+   Description:
+   Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+   Copyright: See COPYING file that comes with this distribution
+}
+program $MODULE$;
+
+begin
+
+end.
diff --git a/languages/pascal/file_templates/pp-unit b/languages/pascal/file_templates/pp-unit
new file mode 100644
index 00000000..98b52e50
--- /dev/null
+++ b/languages/pascal/file_templates/pp-unit
@@ -0,0 +1,19 @@
+{
+   Pascal unit: $MODULE$
+
+   Description:
+   Author: $AUTHOR$ <$EMAIL$>, (C) $YEAR$
+   Copyright: See COPYING file that comes with this distribution
+}
+
+unit $MODULE$;
+
+interface
+
+implementation
+
+initialization
+
+finalization
+
+end.
diff --git a/languages/pascal/kdevpascalsupport.desktop b/languages/pascal/kdevpascalsupport.desktop
new file mode 100644
index 00000000..e560b8da
--- /dev/null
+++ b/languages/pascal/kdevpascalsupport.desktop
@@ -0,0 +1,84 @@
+[Desktop Entry]
+Type=Service
+Exec=blubb
+Comment=Pascal Language Support
+Comment[ca]=Suport per al llenguatge Pascal
+Comment[da]=Pascal sprogunderstøttelse
+Comment[de]=Pascal-Unterstützung für KDevelop
+Comment[el]=Υποστή�ιξη γλώσσας Pascal
+Comment[es]=Soporte para el lenguaje Pascal
+Comment[et]=Pascali keele toetus
+Comment[eu]=Pascal lenguaiaren euskarria
+Comment[fa]=پشتیبانی زبان پاسکال
+Comment[fr]=Prise en charge du langage Pascal
+Comment[ga]=Tacaíocht Pascal
+Comment[gl]=Soporte para linguaxe Pascal
+Comment[hi]=पास�कल भाषा समर�थन
+Comment[hu]=Támogatás a Pascal nyelv használatához
+Comment[is]=Stuðningur við Pascal forritunarmálið
+Comment[it]=Supporto per il linguaggio Pascal
+Comment[ja]=Pascal 言語サ�ート
+Comment[nds]=Ünnerstütten för de Spraak Pascal
+Comment[ne]=पास�कल भाषा समर�थन
+Comment[nl]=Ondersteuning voor Pascal
+Comment[pl]=Obsługa języka Pascal
+Comment[pt]=Suporte da Linguagem Pascal
+Comment[pt_BR]=Suporte à Linguagem Pascal
+Comment[ru]=Поддержка �зыка Pascal
+Comment[sk]=Podpora jazyka Pascal
+Comment[sl]=Podpora jeziku pascal
+Comment[sr]=Језичка подршка за Pascal
+Comment[sr@Latn]=Jezi�ka podrška za Pascal
+Comment[sv]=Stöd för språket Pascal
+Comment[ta]=பாஸ�கல� மொழி ஆதரவ�
+Comment[tg]=�рӣ намудани забони Pascal Language 
+Comment[tr]=Pascal Dil DesteÄŸi
+Comment[zh_CN]=Pascal 语言支�
+Comment[zh_TW]=Pascal 語言支�
+Name=KDevPascalSupport
+Name[da]=KDevelop Pascal-understøttelse
+Name[de]=Sprachunterstützung für Pascal (KDevelop)
+Name[hi]=के-डेव-पॉस�कल-समर�थन
+Name[nds]=Pascal-Ünnerstütten för KDevelop
+Name[pl]=KDevObsługaPascala
+Name[sk]=KDev Pascal podpora
+Name[sv]=KDevelop Pascal-stöd
+Name[ta]=கெடெவ� பாஸ�கல� ஆதரவ�
+Name[zh_TW]=KDevelop Pascal 支�
+GenericName=Pascal Language Support
+GenericName[ca]=Suport per al llenguatge Pascal
+GenericName[da]=Pascal sprogunderstøttelse
+GenericName[de]=Sprachunterstützung für Pascal
+GenericName[el]=Υποστή�ιξη γλώσσας Pascal
+GenericName[es]=Soporte para el lenguaje Pascal
+GenericName[et]=Pascali keele toetus
+GenericName[eu]=Pascal lenguaiaren euskarria
+GenericName[fa]=پشتیبانی زبان پاسکال
+GenericName[fr]=Prise en charge du langage PASCAL
+GenericName[ga]=Tacaíocht Pascal
+GenericName[gl]=Soporte para linguaxe Pascal
+GenericName[hi]=पास�कल भाषा समर�थन
+GenericName[hu]=Pascal-támogatás
+GenericName[it]=Supporto per il linguaggio Pascal
+GenericName[ja]=Pascal 言語サ�ート
+GenericName[nds]=Ünnerstütten för de Spraak Pascal
+GenericName[ne]=पास�कल भाषा समर�थन
+GenericName[nl]=Ondersteuning voor Pascal
+GenericName[pl]=Obsługa języka Pascal
+GenericName[pt]=Suporte à Linguagem Pascal
+GenericName[pt_BR]=Suporte à Linguagem Pascal
+GenericName[ru]=Поддержка �зыка Pascal
+GenericName[sk]=Podpora jazyka Pascal
+GenericName[sl]=Podpora jezicu pascal
+GenericName[sr]=Језичка подршка за Pascal
+GenericName[sr@Latn]=Jezi�ka podrška za Pascal
+GenericName[sv]=Stöd för språket Pascal
+GenericName[ta]=பாஸ�கல� மொழி ஆதரவ�
+GenericName[tg]=�рӣ намудани забони Pascal 
+GenericName[tr]=Pascal Dil DesteÄŸi
+GenericName[zh_CN]=Pascal 语言支�
+GenericName[zh_TW]=Pascal 語言支�
+ServiceTypes=KDevelop/LanguageSupport
+X-KDE-Library=libkdevpascalsupport
+X-KDevelop-Version=5
+X-KDevelop-Language=Pascal
diff --git a/languages/pascal/kdevpascalsupport.rc b/languages/pascal/kdevpascalsupport.rc
new file mode 100644
index 00000000..4335b2a6
--- /dev/null
+++ b/languages/pascal/kdevpascalsupport.rc
@@ -0,0 +1,3 @@
+<!DOCTYPE kpartgui>
+<kpartplugin name="KDevPascalSupport" version="2">
+</kpartplugin>
diff --git a/languages/pascal/pascal.g b/languages/pascal/pascal.g
new file mode 100644
index 00000000..fde5dcb8
--- /dev/null
+++ b/languages/pascal/pascal.g
@@ -0,0 +1,1212 @@
+//
+//
+// Pascal Grammar
+//
+// Adapted from,
+// Pascal User Manual And Report (Second Edition-1978)
+// Kathleen Jensen - Niklaus Wirth
+//
+// By
+//
+// Hakki Dogusan dogusanh@tr-net.net.tr
+//
+// Then significantly enhanced by Piet Schoutteten
+// with some guidance by Terence Parr.  Piet added tree
+// construction, and some tree walkers.
+//
+//
+// Turbo Pascal, Free Pascal and Delphi pascal extensions
+// by Alexander Dymo <cloudtemple@mksat.net>
+//
+//
+// Adapted from,
+// Free Pascal: Reference Guide 1.9 April 2002
+//
+//
+// KDevelop 3.0 support by Alexander Dymo <cloudtemple@mksat.net>
+//
+
+header "pre_include_hpp" {
+        #include "problemreporter.h"
+        #include "PascalAST.hpp"
+
+        #include <qlistview.h>
+        #include <kdebug.h>
+
+        #define SET_POSITION(ast,t)\
+        { \
+                RefPascalAST(ast)->setLine( t->getLine() );\
+                RefPascalAST(ast)->setColumn( t->getColumn() ); \
+        }
+}
+
+options {
+        language="Cpp";
+}
+
+class PascalParser extends Parser;
+options {
+  k = 2;                           // two token lookahead
+  exportVocab=Pascal;              // Call its vocabulary "Pascal"
+  codeGenMakeSwitchThreshold = 2;  // Some optimizations
+  codeGenBitsetTestThreshold = 3;
+  defaultErrorHandler = true;     // Generate parser error handlers
+  buildAST = true;
+  ASTLabelType = "RefPascalAST";
+}
+
+/* Define imaginary tokens used to organize tree
+ *
+ * One of the principles here is that any time you have a list of
+ * stuff, you usually want to treat it like one thing (a list) a some
+ * point in the grammar.  You want trees to have a fixed number of children
+ * as much as possible.  For example, the definition of a procedure should
+ * be something like #(PROCEDURE ID #(ARGDECLS ARG1 ARG2...)) not
+ * #(PROCEDURE ID ARG1 ARG2 ... ) since this is harder to parse and
+ * harder to manipulate.  Same is true for statement lists (BLOCK) etc...
+ */
+tokens {
+	BLOCK; 		// list of statements
+	IDLIST;		// list of identifiers; e.g., #(PROGRAM #(IDLIST ID ID...))
+	ELIST;		// expression list for proc args etc...
+	FUNC_CALL;
+	PROC_CALL;
+	SCALARTYPE; // IDLIST that is really a scalar type like (Mon,Tue,Wed)
+	TYPELIST;	// list of types such as for array declarations
+	VARIANT_TAG;// for CASEs in a RECORD
+	VARIANT_TAG_NO_ID;// for CASEs in a RECORD (no id, just a type)
+	VARIANT_CASE;// a case of the variant
+	CONSTLIST;	// List of constants
+	FIELDLIST;	// list of fields in a record
+	ARGDECLS;	// overall group of declarations of args for proc/func.
+	VARDECL;	// declaration of a variable
+	ARGDECL;	// declaration of a parameter
+	ARGLIST;	// list of actual arguments (expressions)
+	TYPEDECL;	// declaration of a type
+	FIELD;		// the root a RECORD field
+}
+
+// Define some methods and variables to use in the generated parser.
+{
+private:
+        unsigned int m_numberOfErrors;
+        ProblemReporter* m_problemReporter;
+
+public:
+        void resetErrors()                              { m_numberOfErrors = 0; }
+        unsigned int numberOfErrors() const             { return m_numberOfErrors; }
+        void setProblemReporter( ProblemReporter* r )   { m_problemReporter = r; }
+
+        void reportError( const ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex ){
+                m_problemReporter->reportError( ex.getMessage().c_str(),
+                                                ex.getFilename().c_str(),
+                                                ex.getLine(),
+                                                ex.getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        void reportError( const ANTLR_USE_NAMESPACE(std)string& errorMessage ){
+                m_problemReporter->reportError( errorMessage.c_str(),
+                                                getFilename().c_str(),
+                                                LT(1)->getLine(),
+                                                LT(1)->getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        void reportMessage( const ANTLR_USE_NAMESPACE(std)string& message ){
+                m_problemReporter->reportMessage( message.c_str(),
+                                                getFilename().c_str(),
+                                                LT(1)->getLine(),
+                                                LT(1)->getColumn() );
+        }
+}
+
+compilationUnit
+    : program
+    | library
+    | unit
+    ;
+
+program
+    : programHeading
+      (usesClause)?
+      block
+      DOT!
+    ;
+
+library
+    : LIBRARY^ identifier SEMI!
+      (usesClause)?
+      libraryBlock
+      exportsClause
+      END! DOT!
+    ;
+
+libraryBlock
+    : declarationPart (statementPart)?
+    ;
+
+exportsClause
+    : EXPORTS^
+      exportsList
+    ;
+
+exportsList
+    : exportsEntry ( COMMA! exportsEntry )* (SEMI!)?
+    ;
+
+exportsEntry
+    : identifier ("index" integerConstant)? ("name" stringConstant)?
+    ;
+
+usesClause
+    : USES^ identifierList SEMI!
+    ;
+
+unit
+    : UNIT^ identifier SEMI!
+      interfacePart
+      implementationPart
+      ( (initializationPart (finalizationPart)?) | realizationPart )?
+      END!
+    ;
+
+interfacePart
+    : INTERFACE^
+      (usesClause)?
+    ( constantDeclarationPart
+    | typeDeclarationPart
+    | procedureHeadersPart
+    )*
+    ;
+
+implementationPart
+    : IMPLEMENTATION^
+      (usesClause)?
+      declarationPart
+    ;
+
+realizationPart
+    : BEGIN^ statement ( SEMI! statement )*
+    ;
+
+programHeading
+    : PROGRAM^ identifier (LPAREN! identifierList RPAREN!)? SEMI!
+    ;
+
+initializationPart
+    : INITIALIZATION^
+      statement ( SEMI! statement )*
+    ;
+
+finalizationPart
+    : FINALIZATION^
+      statement ( SEMI! statement )*
+    ;
+
+block
+    : declarationPart statementPart
+    ;
+
+declarationPart
+    : (labelDeclarationPart
+    | constantDeclarationPart
+    | resourcestringDeclarationPart
+    | typeDeclarationPart
+    | variableDeclarationPart
+    | procedureAndFunctionDeclarationPart
+      )*
+    ;
+
+labelDeclarationPart
+    : LABEL^ label ( COMMA! label )* SEMI!
+    ;
+
+constantDeclarationPart
+    : CONST^ ( constantDeclaration | typedConstantDeclaration )+
+    ;
+
+resourcestringDeclarationPart
+    : RESOURCESTRING^ ( stringConstantDeclaration )*
+    ;
+
+stringConstantDeclaration
+    : identifier EQUAL! string
+    ;
+
+typeDeclarationPart
+    : TYPE^ ( typeDeclaration )+
+    ;
+
+variableDeclarationPart
+    : VAR^ variableDeclaration ( SEMI! variableDeclaration )* SEMI!
+    ;
+
+variableDeclaration
+    : identifierList c:COLON^ {#c->setType(VARDECL);} type
+    ;
+
+procedureAndFunctionDeclarationPart
+    : procedureAndFunctionDeclaration
+    ;
+
+procedureAndFunctionDeclaration
+    : procedureDeclaration
+    | functionDeclaration
+    | constructorDeclaration
+    | destructorDeclaration
+    ;
+
+statementPart
+    : compoundStatement
+    ;
+
+procedureDeclaration
+    : procedureHeader subroutineBlock SEMI!
+    ;
+
+procedureHeadersPart
+    : procedureHeader | functionHeader // ) SEMI! ( callModifiers SEMI! )
+    ;
+
+procedureHeader
+    : PROCEDURE^ ( identifier | qualifiedMethodIdentifier )
+      (formalParameterList)? SEMI! (modifiers SEMI!)*
+    ;
+
+qualifiedMethodIdentifier
+    : identifier COLON! COLON! identifier
+    ;
+
+subroutineBlock
+    : block
+    | externalDirective
+//    | asmBlock
+    | FORWARD!
+    ;
+
+functionDeclaration
+    : functionHeader subroutineBlock SEMI!
+    ;
+
+functionHeader
+    : (FUNCTION^ identifier COLON! type SEMI!)=> FUNCTION^ identifier COLON! type SEMI! (modifiers SEMI!)*
+    | (FUNCTION^ identifier COLON! COLON! identifier COLON! type SEMI!)=> FUNCTION^ qualifiedMethodIdentifier COLON! type SEMI! (modifiers SEMI!)*
+    | (FUNCTION^ identifier COLON! COLON! identifier LPAREN!)=> FUNCTION^ qualifiedMethodIdentifier formalParameterList COLON! type SEMI! (modifiers SEMI!)*
+    | FUNCTION^ identifier formalParameterList COLON! type SEMI! (modifiers SEMI!)*
+    ;
+
+functionHeaderEnding
+    : (COLON! type SEMI!)=> COLON! type SEMI! (modifiers SEMI!)*
+    | formalParameterList COLON! type SEMI! (modifiers SEMI!)*
+    ;
+
+formalParameterList
+    : LPAREN! parameterDeclaration ( SEMI! parameterDeclaration )* RPAREN!
+    ;
+
+parameterDeclaration
+    : valueParameter
+    | variableParameter
+    | constantParameter
+    ;
+
+valueParameter
+    : (identifierList COLON! ARRAY! OF!)=> identifierList COLON! ARRAY! OF! type
+    | identifierList COLON! type
+    ;
+
+variableParameter
+    : VAR identifierList ( untypedParameterPart )?
+    ;
+
+untypedParameterPart
+    : (COLON! ARRAY! OF! type)=> COLON! ARRAY! OF! type
+    | COLON! type
+    ;
+
+constantParameter
+    : CONST identifierList ( untypedParameterPart )?
+    ;
+
+externalDirective
+    : EXTERNAL^ ( stringConstant ( ("name" stringConstant) | ("index" integerConstant) )? )?
+    ;
+
+/*asmBlock
+    : ASSEMBLER^ SEMI! declarationPart asmStatement
+    ;
+*/
+modifiers
+    : PUBLIC! | (ALIAS! stringConstant) | INTERRUPT! | callModifiers | EXPORT!
+    ;
+
+callModifiers
+    : REGISTER! | PASCAL! | CDECL! | STDCALL! | POPSTACK! | SAVEREGISTERS! | INLINE! | SAFECALL! | NEAR! | FAR!
+    ;
+
+constantDeclaration
+//    : ( identifier EQUAL! expression SEMI! ) ( identifier EQUAL! expression SEMI! )*
+    :  identifier EQUAL! expression SEMI!
+    ;
+
+typedConstantDeclaration
+//    : ( identifier COLON! type EQUAL! typedConstant SEMI! )+
+    : identifier COLON! type EQUAL! typedConstant SEMI!
+    ;
+
+//FIXME: is there a better way to handle this instead of simply forcing the rules
+typedConstant
+    : (constant)=> constant
+//    | addressConstant
+    | (LPAREN! identifier COLON!)=> recordConstant
+    | (arrayConstant)=> arrayConstant
+    | proceduralConstant
+    ;
+
+arrayConstant
+    : LPAREN! ( constant | arrayConstant ) ( COMMA! ( constant | arrayConstant ) )* RPAREN!
+    ;
+
+recordConstant
+    : LPAREN! ( identifier COLON! constant ) ( SEMI! ( identifier COLON! constant ) )* RPAREN!
+    ;
+
+addressConstant
+    : NUM_INT
+    ;
+
+proceduralConstant
+    : expression
+    ;
+
+typeDeclaration
+    : identifier EQUAL! type SEMI!
+    ;
+
+type
+//    : simpleType | subrangeType | enumeratedType | stringType | structuredType | pointerType | proceduralType | typeIdentifier
+    : simpleType | subrangeTypeOrTypeIdentifier | enumeratedType | stringType | structuredType | pointerType | proceduralType
+    ;
+
+simpleType
+    : ordinalType | realType
+    ;
+
+ordinalType
+    : INTEGER! | SHORTINT! | SMALLINT! | LONGINT! | INT64! | BYTE! | WORD! | CARDINAL! | QWORD!
+    | BOOLEAN! | BYTEBOOL! | LONGBOOL! | CHAR!
+    ;
+
+subrangeTypeOrTypeIdentifier
+    : constant (DOTDOT! constant)?
+    ;
+
+typeIdentifier
+    : identifier
+    ;
+
+subrangeType
+    : constant DOTDOT! constant
+    ;
+
+enumeratedType
+    : (LPAREN! identifier ASSIGN!)=> LPAREN! assignedEnumList RPAREN!
+    | LPAREN! identifierList RPAREN!
+    ;
+
+assignedEnumList
+    : (identifier ASSIGN! expression) ( COMMA! (identifier ASSIGN! expression) )*
+    ;
+
+realType
+    : REAL! | SINGLE! | DOUBLE! | EXTENDED! | COMP!
+    ;
+
+stringType
+    : STRING^ ( LBRACK! unsignedInteger RBRACK! )?
+    ;
+
+structuredType
+    : (PACKED!)? ( arrayType | recordType | objectType | classType | setType | fileType )
+    ;
+
+arrayType
+    : ARRAY^ LBRACK! arrayIndexType ( COMMA! arrayIndexType )* RBRACK! OF! type
+    ;
+
+arrayIndexType
+    : ordinalType
+    | (expression DOTDOT!)=> arraySubrangeType
+    | enumeratedType
+    ;
+
+arraySubrangeType
+    : expression DOTDOT! expression
+    ;
+
+recordType
+    : RECORD^ (fieldList)* END!
+    ;
+
+fieldList
+    : fixedField | variantPart
+    ;
+
+fixedField
+    : identifierList COLON! type SEMI!
+    ;
+
+variantPart
+    : CASE^ (identifier COLON!)? identifier OF! variant ( SEMI! variant )*
+    ;
+
+variant
+    : (constant COMMA!)+ COLON! LPAREN! (fieldList)* RPAREN!
+    ;
+
+setType
+    : SET^ OF! ordinalType
+    ;
+
+fileType
+    : FILE^ OF! type
+    ;
+
+pointerType
+    : POINTER^ typeIdentifier
+    ;
+
+proceduralType
+    : (proceduralTypePart1 SEMI!)=> proceduralTypePart1 SEMI! callModifiers
+    | proceduralTypePart1
+    ;
+
+proceduralTypePart1
+    : ( functionHeader | procedureHeader ) (OF! OBJECT!)?
+    ;
+
+objectType
+    : OBJECT^ (heritage)? (componentList | objectVisibilitySpecifier ) END!
+    ;
+
+heritage
+    : LPAREN! identifier RPAREN!
+    ;
+
+componentList
+    : ( (fieldDefinition)+ )? ( (methodDefinition)+ )?
+    ;
+
+fieldDefinition
+    : identifierList COLON! type SEMI!
+    ;
+
+methodDefinition
+    : ( functionHeader | procedureHeader | constructorHeader | destructorHeader ) SEMI! methodDirectives
+    ;
+
+methodDirectives
+    : ( VIRTUAL! SEMI! (ABSTRACT! SEMI!)? )? (callModifiers SEMI!)?
+    ;
+
+objectVisibilitySpecifier
+    : PRIVATE! | PROTECTED! | PUBLIC!
+    ;
+
+constructorDeclaration
+    : constructorHeader SEMI! subroutineBlock
+    ;
+
+destructorDeclaration
+    : destructorHeader SEMI! subroutineBlock
+    ;
+
+constructorHeader
+    : CONSTRUCTOR^ ( identifier | qualifiedMethodIdentifier ) formalParameterList
+    ;
+
+destructorHeader
+    : DESTRUCTOR^ ( identifier | qualifiedMethodIdentifier ) formalParameterList
+    ;
+
+classType
+    : CLASS^ (heritage)? (classComponentList | classVisibilitySpecifier ) END!
+    ;
+
+classComponentList
+    : ( (fieldDefinition)+ )? ( ( (classMethodDefinition | propertyDefinition) )+ )?
+    ;
+
+classMethodDefinition
+    : ( ( (CLASS!)? (functionHeader | procedureHeader) ) | constructorHeader | destructorHeader ) SEMI! classMethodDirectives
+    ;
+
+classMethodDirectives
+    : ( directiveVariants SEMI! )? (callModifiers SEMI!)?
+    ;
+
+directiveVariants
+    : ( VIRTUAL! (ABSTRACT! SEMI!)? )
+    | OVERRIDE!
+    | (MESSAGE! (integerConstant | stringConstant))
+    ;
+
+classVisibilitySpecifier
+    : PRIVATE! | PROTECTED! | PUBLIC! | PUBLISHED!
+    ;
+
+propertyDefinition
+    : PROPERTY^ identifier (propertyInterface)? propertySpecifiers
+    ;
+
+propertyInterface
+    : (propertyParameterList)? COLON! typeIdentifier ("index" integerConstant)?
+    ;
+
+propertyParameterList
+    : LBRACK! parameterDeclaration (SEMI! parameterDeclaration)* RBRACK!
+    ;
+
+propertySpecifiers
+    : (readSpecifier)? (writeSpecifier)? (defaultSpecifier)?
+    ;
+
+readSpecifier
+    : "read" fieldOrMethod
+    ;
+
+writeSpecifier
+    : "write" fieldOrMethod
+    ;
+
+defaultSpecifier
+    : ( DEFAULT (constant)? )
+    | "nodefault"
+    ;
+
+fieldOrMethod
+    : identifier
+    ;
+
+expression
+    : simpleExpression ( expressionSign simpleExpression )?
+    ;
+
+expressionSign
+//    : STAR! | LE! | GE! | LTH! | GT! | NOT_EQUAL! | IN! | IS!
+    : LE! | GE! | LTH! | GT! | NOT_EQUAL! | IN! | IS! | EQUAL!
+    ;
+
+simpleExpression
+    : term ( ( PLUS! | MINUS! | OR! | XOR! ) term )*
+    ;
+
+term
+    : factor ( (STAR! | SLASH! | DIV! | MOD! | AND! | SHL! | SHR!) factor )*
+    ;
+
+//TODO: distinguish between identifiers, typecasts and function calls -> semantic predicate
+factor
+    : ( LPAREN! expression RPAREN! )
+//    | (qualifiedMethodIdentifier2 LBRACK!)=> qualifiedMethodIdentifier2 LBRACK! arrayIndexType ( COMMA! arrayIndexType )* RBRACK!
+    | identifierOrValueTypecastOrFunctionCall
+//    | identifier
+//    | functionCall
+    | unsignedConstant
+    | ( NOT! factor )
+    | ( (PLUS! | MINUS!) factor )
+    | setConstructor
+//    | valueTypecast
+    | addressFactor
+    | TRUE
+    | FALSE
+    | identifier LBRACK! expression ( COMMA! expression )* RBRACK!
+    ;
+
+//FIXME: is this correct?
+identifierOrValueTypecastOrFunctionCall
+    : (identifier LPAREN! expression COMMA!)=> identifier LPAREN! expressions RPAREN!
+    | (identifier LPAREN! expression RPAREN!)=> identifier LPAREN! expression RPAREN!
+//    | (qualifiedMethodIdentifier2 LPAREN! expression COMMA!)=> qualifiedMethodIdentifier2 LPAREN! expressions RPAREN!
+//    | (identifier DOT)=> qualifiedMethodIdentifier2
+    | identifier
+    ;
+
+/*qualifiedMethodIdentifier2
+    : identifier DOT identifier
+    ;
+*/
+//( functionIdentifier | methodDesignator | qualifiedMethodDesignator | variableReference )
+functionCall
+    : identifier (actualParameterList)?
+    ;
+
+actualParameterList
+    : LPAREN! ( expressions )? RPAREN!
+    ;
+
+expressions
+    : expression ( COMMA! expression )*
+    ;
+
+setConstructor
+    : LBRACK! ( setGroup ( COMMA! setGroup )* )? RBRACK!
+    ;
+
+setGroup
+    : expression ( DOT! DOT! expression )?
+    ;
+
+valueTypecast
+    : typeIdentifier LPAREN! expression RPAREN!
+    ;
+
+//( variableReference | procedureIdentifier | functionIdentifier | qualifiedMethodIdentifier )
+addressFactor
+    : AT! identifier
+    ;
+
+statement
+//    : (label COLON!)? (simpleStatement | structuredStatement | asmStatement)
+    : (label COLON!)? (simpleStatement | structuredStatement)
+    ;
+
+simpleStatement
+    : assignmentStatement | procedureStatement | gotoStatement | raiseStatement
+    ;
+
+assignmentStatement
+    : identifierOrArrayIdentifier assignmentOperator expression
+    ;
+
+identifierOrArrayIdentifier
+    : identifier
+//    | (qualifiedMethodIdentifier LBRACK!)=> qualifiedMethodIdentifier LBRACK! arrayIndexType ( COMMA! arrayIndexType )* RBRACK!
+//    | qualifiedMethodIdentifier
+    | identifier LBRACK! expression ( COMMA! expression )* RBRACK!
+    ;
+
+assignmentOperator
+    : ASSIGN! | PLUSEQ | MINUSEQ | STAREQ | SLASHQE
+    ;
+
+procedureStatement
+    : identifier (actualParameterList)?
+    ;
+
+gotoStatement
+    : GOTO! label
+    ;
+
+structuredStatement
+    : compoundStatement | repetitiveStatement | conditionalStatement | exceptionStatement | withStatement
+    ;
+
+conditionalStatement
+    : ifStatement | caseStatement
+    ;
+
+repetitiveStatement
+    : forStatement | repeatStatement | whileStatement
+    ;
+
+compoundStatement
+    : BEGIN! END!
+    | BEGIN! (SEMI!)+ END!
+    | BEGIN! statement (SEMI! (statement)?)* END!
+    ;
+
+ifStatement
+    : IF^ expression THEN! statement
+      (
+        // CONFLICT: the old "dangling-else" problem...
+        //           ANTLR generates proper code matching
+        //           as soon as possible.  Hush warning.
+        options {
+            generateAmbigWarnings=false;
+        }
+        : ELSE! statement
+      )?
+    ;
+
+caseStatement
+    : CASE^ expression OF!
+        caseListElement ( SEMI! caseListElement )*
+      ( SEMI! ELSE! statement ( SEMI! statement )* )?
+      END!
+    ;
+
+caseListElement
+    : constList COLON^ statement
+    ;
+
+constList
+    : constant ( COMMA! constant )*
+      {#constList = #([CONSTLIST],#constList);}
+    ;
+
+whileStatement
+    : WHILE^ expression DO! statement
+    ;
+
+repeatStatement
+    : REPEAT^ statement ( SEMI! (statement)? )* UNTIL! expression
+    ;
+
+forStatement
+    : FOR^ identifier ASSIGN! forList DO! statement
+    ;
+
+forList
+    : initialValue (TO^ | DOWNTO^) finalValue
+    ;
+
+initialValue
+    : expression
+    ;
+
+finalValue
+    : expression
+    ;
+
+withStatement
+    : WITH^ recordVariableList DO! statement
+    ;
+
+recordVariableList
+    : variable ( COMMA! variable )*
+    ;
+
+/** 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.
+ */
+variable
+    : ( AT^ identifier // AT is root of identifier; then other op becomes root
+      | identifier
+      )
+      ( LBRACK^ expression ( COMMA! expression)* RBRACK!
+      | LBRACK2^ expression ( COMMA! expression)* RBRACK2!
+      | DOT^ identifier
+      | POINTER^
+      )*
+    ;
+
+/*asmStatement
+    : ASM^ assemblerCode END! (registerList)?
+    ;
+
+registerList
+    : LBRACK! stringConstant ( COMMA! stringConstant )*
+    ;
+
+assemblerCode
+    : (.)*
+    ;
+*/
+operatorDefinition
+    : OPERATOR^ ( assignmentOperatorDefinition | arithmeticOperatorDefinition | comparisonOperatorDefinition )
+      identifier COLON! type SEMI! subroutineBlock
+    ;
+
+assignmentOperatorDefinition
+    : ASSIGN! LPAREN! valueParameter RPAREN!
+    ;
+
+arithmeticOperatorDefinition
+    : ( PLUS! | MINUS! | STAR! | SLASH! | (STAR! STAR!) ) LPAREN! formalParameterList RPAREN!
+    ;
+
+comparisonOperatorDefinition
+    : ( EQUAL! | LE! | GE! | GT! | LTH! ) LPAREN! formalParameterList RPAREN!
+    ;
+
+raiseStatement
+    : RAISE^ ( functionCall (AT! addressConstant)? )?
+    ;
+
+exceptionStatement
+    : tryStatement
+    ;
+
+tryStatement
+    : TRY^ (statements)? exceptOrFinallyPart END!
+    ;
+
+exceptOrFinallyPart
+    : EXCEPT! (exceptionHandlers)?
+    | FINALLY! (statements)?
+    ;
+
+statements
+    : statement ( SEMI! statement )*
+    ;
+
+exceptionHandlers
+    : statements | exceptionHandler ( SEMI! exceptionHandler )* ( ELSE! statements )?
+    ;
+
+exceptionHandler
+    : ON! (identifier COLON!)? identifier DO! statement
+    ;
+
+identifierList
+    : identifier ( COMMA! identifier )*
+      {#identifierList = #(#[IDLIST],#identifierList);}
+    ;
+
+label
+    : unsignedInteger
+    ;
+
+unsignedInteger
+    : NUM_INT
+    ;
+
+integerConstant
+    : unsignedInteger
+    |! s:sign n:unsignedInteger { #integerConstant=#(s,n); }
+    ;
+
+stringConstant
+    : string | constantChr
+    ;
+
+sign
+    : PLUS | MINUS
+    ;
+
+string
+    : STRING_LITERAL
+    ;
+
+constantChr
+    : CHR^ LPAREN! unsignedInteger RPAREN!
+    ;
+
+constant
+    : unsignedNumber
+    |! s:sign n:unsignedNumber { #constant=#(s,n); }
+    | identifier
+    |! s2:sign id:identifier { #constant=#(s2,id); }
+    | string
+    | constantChr
+    ;
+
+unsignedConstant
+    : unsignedNumber | constantChr | string | NIL!
+    ;
+
+unsignedNumber
+    : unsignedInteger
+    | unsignedReal
+    ;
+
+unsignedReal
+    : NUM_REAL
+    ;
+
+identifier
+    : IDENT
+    ;
+
+
+//----------------------------------------------------------------------------
+// The Pascal scanner
+//----------------------------------------------------------------------------
+class PascalLexer extends Lexer;
+
+options {
+  charVocabulary = '\0'..'\377';
+  exportVocab = Pascal;   // call the vocabulary "Pascal"
+  testLiterals = false;   // don't automatically test for literals
+  k = 4;                  // four characters of lookahead
+  caseSensitive = false;
+  caseSensitiveLiterals = false;
+  defaultErrorHandler=false;
+}
+
+tokens {
+  ABSOLUTE         = "absolute"        ;
+  ABSTRACT         = "abstract"        ;
+  ALIAS            = "alias"           ;
+  AND              = "and"             ;
+  ARRAY            = "array"           ;
+  AS               = "as"              ;
+  ASM              = "asm"             ;
+  ASSEMBLER        = "assembler"       ;
+  BEGIN            = "begin"           ;
+  BREAK            = "break"           ;
+  BOOLEAN          = "boolean"         ;
+  BYTE             = "byte"            ;
+  CARDINAL         = "cardinal"        ;
+  CASE             = "case"            ;
+  CDECL            = "cdecl"           ;
+  CHAR             = "char"            ;
+  CHR              = "chr"             ;
+  CLASS            = "class"           ;
+  COMP             = "comp"            ;
+  CONST            = "const"           ;
+  CONSTRUCTOR      = "constructor"     ;
+  CONTINUE         = "continue"        ;
+  DEFAULT          = "default"         ;
+  DESTRUCTOR       = "destructor"      ;
+  DISPOSE          = "dispose"         ;
+  DIV              = "div"             ;
+  DO               = "do"              ;
+  DOUBLE           = "double"          ;
+  DOWNTO           = "downto"          ;
+  ELSE             = "else"            ;
+  END              = "end"             ;
+  EXCEPT           = "except"          ;
+  EXPORT           = "export"          ;
+  EXPORTS          = "exports"         ;
+  EXTENDED         = "extended"        ;
+  EXTERNAL         = "external"        ;
+  EXIT             = "exit"            ;
+  FALSE            = "false"           ;
+  FILE             = "file"            ;
+  FINALLY          = "finally"         ;
+  FAR              = "far"             ;
+  FOR              = "for"             ;
+  FORWARD          = "forward"         ;
+  FUNCTION         = "function"        ;
+  GOTO             = "goto"            ;
+  IF               = "if"              ;
+  IN               = "in"              ;
+//  INDEX            = "index"           ;
+  IS               = "is"              ;
+  INHERITED        = "inherited"       ;
+  INLINE           = "inline"          ;
+  INT64            = "int64"           ;
+  INTEGER          = "integer"         ;
+  LABEL            = "label"           ;
+  LIBRARY          = "library"         ;
+  LONGINT          = "longint"         ;
+  MOD              = "mod"             ;
+//  NAME             = "name"            ;
+  NEAR             = "near"            ;
+  NEW              = "new"             ;
+  NIL              = "nil"             ;
+  NOT              = "not"             ;
+  OBJECT           = "object"          ;
+  OF               = "of"              ;
+  ON               = "on"              ;
+  OPERATOR         = "operator"        ;
+  OR               = "or"              ;
+  OVERRIDE         = "override"        ;
+  PACKED           = "packed"          ;
+  PASCAL           = "pascal"          ;
+  POPSTACK         = "popstack"        ;
+  PRIVATE          = "private"         ;
+  PROCEDURE        = "procedure"       ;
+  PROTECTED        = "protected"       ;
+  PROGRAM          = "program"         ;
+  PROPERTY         = "property"        ;
+  PUBLIC           = "public"          ;
+  PUBLISHED        = "published"       ;
+  QWORD            = "qword"           ;
+  RAISE            = "raise"           ;
+  REAL             = "real"            ;
+  RECORD           = "record"          ;
+  REGISTER         = "register"        ;
+  REPEAT           = "repeat"          ;
+  SAFECALL         = "safecall"        ;
+  SAVEREGISTERS    = "saveregisters"   ;
+  SELF             = "self"            ;
+  SET              = "set"             ;
+  SHORTINT         = "shortint"        ;
+  SHR              = "shr"             ;
+  SHL              = "shl"             ;
+  SINGLE           = "single"          ;
+  SMALLINT         = "smallint"        ;
+  STDCALL          = "stdcall"         ;
+  THEN             = "then"            ;
+  TO               = "to"              ;
+  TRUE             = "true"            ;
+  TRY              = "try"             ;
+  TYPE             = "type"            ;
+  UNTIL            = "until"           ;
+  VAR              = "var"             ;
+  VIRTUAL          = "virtual"         ;
+  WHILE            = "while"           ;
+  WITH             = "with"            ;
+  WORD             = "word"            ;
+  XOR              = "xor"             ;
+  METHOD                               ;
+  ADDSUBOR                             ;
+  ASSIGNEQUAL                          ;
+  SIGN                                 ;
+  FUNC                                 ;
+  NODE_NOT_EMIT                        ;
+  MYASTVAR                             ;
+  LF                                   ;
+  UNIT             = "unit"            ;
+  INTERFACE        = "interface"       ;
+  USES             = "uses"            ;
+  STRING           = "string"          ;
+  IMPLEMENTATION   = "implementation"  ;
+  FINALIZATION     = "finalization"    ;
+  INITIALIZATION   = "initialization"  ;
+  RESOURCESTRING   = "resourcestring"  ;
+//pspsps ???
+}
+
+{
+private:
+        ProblemReporter* m_problemReporter;
+        unsigned int m_numberOfErrors;
+
+public:
+        void resetErrors()                              { m_numberOfErrors = 0; }
+        unsigned int numberOfErrors() const             { return m_numberOfErrors; }
+        void setProblemReporter( ProblemReporter* r )   { m_problemReporter = r; }
+
+        virtual void reportError( const ANTLR_USE_NAMESPACE(antlr)RecognitionException& ex ){
+                m_problemReporter->reportError( ex.getMessage().c_str(),
+                                                ex.getFilename().c_str(),
+                                                ex.getLine(),
+                                                ex.getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        virtual void reportError( const ANTLR_USE_NAMESPACE(std)string& errorMessage ){
+                m_problemReporter->reportError( errorMessage.c_str(),
+                                                getFilename().c_str(),
+                                                getLine(), getColumn() );
+                ++m_numberOfErrors;
+        }
+
+        virtual void reportWarning( const ANTLR_USE_NAMESPACE(std)string& warnMessage ){
+                m_problemReporter->reportWarning( warnMessage.c_str(),
+                                                getFilename().c_str(),
+                                                getLine(), getColumn() );
+        }
+}
+
+//----------------------------------------------------------------------------
+// OPERATORS
+//----------------------------------------------------------------------------
+PLUS            : '+'   ;
+MINUS           : '-'   ;
+STAR            : '*'   ;
+SLASH           : '/'   ;
+ASSIGN          : ":="  ;
+COMMA           : ','   ;
+SEMI            : ';'   ;
+COLON           : ':'   ;
+EQUAL           : '='   ;
+NOT_EQUAL       : "<>"  ;
+LTH             : '<'   ;
+LE              : "<="  ;
+GE              : ">="  ;
+GT              : '>'   ;
+LPAREN          : '('   ;
+RPAREN          : ')'   ;
+LBRACK          : '['   ; // line_tab[line]
+LBRACK2         : "(."  ; // line_tab(.line.)
+RBRACK          : ']'   ;
+RBRACK2         : ".)"  ;
+POINTER         : '^'   ;
+AT              : '@'   ;
+DOT             : '.' ('.' {$setType(DOTDOT);})?  ;
+LCURLY          : "{" ;
+RCURLY          : "}" ;
+PLUSEQ          : "+=" ;
+MINUSEQ         : "-=" ;
+STAREQ          : "*=" ;
+SLASHQE         : "/=" ;
+
+
+// Whitespace -- ignored
+WS      : ( ' '
+		|	'\t'
+		|	'\f'
+		// handle newlines
+		|	(	"\r\n"  // Evil DOS
+			|	'\r'    // Macintosh
+			|	'\n'    // Unix (the right way)
+			)
+			{ newline(); }
+		)
+		  { _ttype = ANTLR_USE_NAMESPACE(antlr)Token::SKIP; }
+	;
+
+
+COMMENT_1
+        : "(*"
+		   ( options { generateAmbigWarnings=false; }
+		   :	{ LA(2) != ')' }? '*'
+		   |	'\r' '\n'		{newline();}
+		   |	'\r'			{newline();}
+		   |	'\n'			{newline();}
+           |   ~('*' | '\n' | '\r')
+		   )*
+          "*)"
+		{$setType(ANTLR_USE_NAMESPACE(antlr)Token::SKIP);}
+	;
+
+COMMENT_2
+        :  '{'
+		    ( options {generateAmbigWarnings=false;}
+            :   '\r' '\n'       {newline();}
+		    |	'\r'			{newline();}
+		    |	'\n'			{newline();}
+            |   ~('}' | '\n' | '\r')
+		    )*
+           '}'
+		{$setType(ANTLR_USE_NAMESPACE(antlr)Token::SKIP);}
+	;
+
+COMMENT_3
+    : "//" (~'\n')* '\n'
+    {$setType(ANTLR_USE_NAMESPACE(antlr)Token::SKIP);}
+    ;
+
+// an identifier.  Note that testLiterals is set to true!  This means
+// that after we match the rule, we look in the literals table to see
+// if it's a literal or really an identifer
+IDENT
+	options {testLiterals=true;}
+	:	('a'..'z') ('a'..'z'|'0'..'9'|'_')*   //pspsps
+	;
+
+// string literals
+STRING_LITERAL
+	: '\'' ("\'\'" | ~('\''))* '\''   //pspsps   * in stead of + because of e.g. ''
+	;
+
+/** a numeric literal.  Form is (from Wirth)
+ *  digits
+ *  digits . digits
+ *  digits . digits exponent
+ *  digits exponent
+ */
+NUM_INT
+	:	('0'..'9')+ // everything starts with a digit sequence
+		(	(	{(LA(2)!='.')&&(LA(2)!=')')}?				// force k=2; avoid ".."
+//PSPSPS example ARRAY (.1..99.) OF char; // after .. thinks it's a NUM_REAL
+				'.' {$setType(NUM_REAL);}	// dot means we are float
+				('0'..'9')+ (EXPONENT)?
+			)?
+		|	EXPONENT {$setType(NUM_REAL);}	// 'E' means we are float
+		)
+	;
+
+// a couple protected methods to assist in matching floating point numbers
+protected
+EXPONENT
+	:	('e') ('+'|'-')? ('0'..'9')+
+	;
diff --git a/languages/pascal/pascal.tree.g b/languages/pascal/pascal.tree.g
new file mode 100644
index 00000000..c597afb8
--- /dev/null
+++ b/languages/pascal/pascal.tree.g
@@ -0,0 +1,468 @@
+//
+// Pascal Tree Super Grammar (symtab.g derives from this)
+//
+// Adapted from,
+// Pascal User Manual And Report (Second Edition-1978)
+// Kathleen Jensen - Niklaus Wirth
+//
+// By
+//
+// Hakki Dogusan dogusanh@tr-net.net.tr
+//
+// Then significantly enhanced by Piet Schoutteten
+// with some guidance by Terence Parr.  Piet added tree
+// construction, and some tree walkers.
+//
+//
+// Adopted to KDevelop by Alexander Dymo <cloudtemple@mksat.net>
+//
+
+header "pre_include_hpp" {
+	#include <codemodel.h>
+        #include "PascalAST.hpp"
+
+        #include <qstring.h>
+        #include <qstringlist.h>
+        #include <qfileinfo.h>
+}
+
+header "post_include_hpp" {
+	#include <codemodel.h>
+        #include <kdebug.h>
+}
+
+options {
+        language="Cpp";
+}
+
+
+class PascalStoreWalker extends TreeParser;
+
+options {
+	importVocab = Pascal;
+	defaultErrorHandler = true;
+        ASTLabelType = "RefPascalAST";
+}
+
+{
+private:
+        QString m_fileName;
+        QStringList m_currentScope;
+        int m_currentAccess;
+        int m_anon;
+	CodeModel* m_model;
+
+public:
+        void setCodeModel( CodeModel* model )			{ m_model = model; }
+        CodeModel* codeModel()					{ return m_model; }
+        const CodeModel* codeModel() const			{ return m_model; }
+
+        QString fileName() const				{ return m_fileName; }
+        void setFileName( const QString& fileName )		{ m_fileName = fileName; }
+
+        void init(){
+                m_currentScope.clear();
+                m_currentAccess = CodeModelItem::Public;
+                m_anon = 0;
+        }
+
+        void wipeout()						{ m_model->wipeout(); }
+}
+
+program
+    : programHeading
+      block
+    ;
+
+programHeading
+    : #(PROGRAM IDENT identifierList)
+    | #(UNIT IDENT)
+    ;
+
+identifier
+    : IDENT
+    ;
+
+block
+    : ( labelDeclarationPart
+      | constantDefinitionPart
+      | typeDefinitionPart
+      | variableDeclarationPart
+      | procedureAndFunctionDeclarationPart
+      | usesUnitsPart
+      | IMPLEMENTATION
+      )*
+      compoundStatement
+    ;
+
+usesUnitsPart
+    : #(USES identifierList)
+    ;
+
+labelDeclarationPart
+    : #(LABEL ( label )+)
+    ;
+
+label
+    : NUM_INT
+    ;
+
+constantDefinitionPart
+    : #(CONST ( constantDefinition )+ )
+    ;
+
+constantDefinition
+    : #(EQUAL IDENT constant)
+    ;
+
+constant
+    : NUM_INT
+    | NUM_REAL
+    | #( PLUS
+         ( NUM_INT
+         | NUM_REAL
+         | IDENT
+         )
+       )
+    | #( MINUS
+         ( NUM_INT
+         | NUM_REAL
+         | IDENT
+         )
+       )
+    | IDENT
+    | STRING_LITERAL
+    | #(CHR (NUM_INT|NUM_REAL))
+    ;
+
+string
+    : STRING_LITERAL
+    ;
+
+typeDefinitionPart
+    : #(TYPE ( typeDefinition )+)
+    ;
+
+typeDefinition
+    : #(TYPEDECL IDENT
+      ( type
+      | #(FUNCTION (formalParameterList)? resultType)
+      | #(PROCEDURE (formalParameterList)?)
+      )
+      )
+    ;
+
+type
+    : #(SCALARTYPE identifierList)
+    | #(DOTDOT constant constant)
+    | typeIdentifier
+    | structuredType
+    | #(POINTER typeIdentifier)
+    ;
+
+typeIdentifier
+    : IDENT
+    | CHAR
+    | BOOLEAN
+    | INTEGER
+    | REAL
+    | #( STRING
+         ( IDENT
+         | NUM_INT
+         | NUM_REAL
+         |
+         )
+       )
+    ;
+
+structuredType
+    : #(PACKED unpackedStructuredType)
+    | unpackedStructuredType
+    ;
+
+unpackedStructuredType
+    : arrayType
+    | recordType
+    | setType
+    | fileType
+    ;
+
+/** Note here that the syntactic diff between brackets disappears.
+ *  If the brackets mean different things semantically, we need
+ *  two different alternatives here.
+ */
+arrayType
+    : #(ARRAY typeList type)
+    ;
+
+typeList
+    : #( TYPELIST ( type )+ )
+    ;
+
+recordType
+    : #(RECORD fieldList)
+    ;
+
+fieldList
+    : #( FIELDLIST
+         ( fixedPart ( variantPart )?
+         | variantPart
+         )
+       )
+    ;
+
+fixedPart
+    : ( recordSection )+
+    ;
+
+recordSection
+    : #(FIELD identifierList type)
+    ;
+
+variantPart
+    : #( CASE tag ( variant )+ )
+    ;
+
+tag
+    : #(VARIANT_TAG identifier typeIdentifier)
+    | #(VARIANT_TAG_NO_ID typeIdentifier)
+    ;
+
+variant
+    : #(VARIANT_CASE constList fieldList)
+    ;
+
+setType
+    : #(SET type)
+    ;
+
+fileType
+    : #(FILE (type)?)
+    ;
+
+/** Yields a list of VARDECL-rooted subtrees with VAR at the overall root */
+variableDeclarationPart
+    : #( VAR ( variableDeclaration )+ )
+    ;
+
+variableDeclaration
+    : #(VARDECL identifierList type)
+    ;
+
+procedureAndFunctionDeclarationPart
+    : procedureOrFunctionDeclaration
+    ;
+
+procedureOrFunctionDeclaration
+    : procedureDeclaration
+    | functionDeclaration
+    ;
+
+procedureDeclaration
+    : #(PROCEDURE IDENT (formalParameterList)? block )
+    ;
+
+formalParameterList
+    : #(ARGDECLS ( formalParameterSection )+)
+    ;
+
+formalParameterSection
+    : parameterGroup
+    | #(VAR parameterGroup)
+    | #(FUNCTION parameterGroup)
+    | #(PROCEDURE parameterGroup)
+    ;
+
+parameterGroup
+    : #(ARGDECL identifierList typeIdentifier)
+    ;
+
+identifierList
+    : #(IDLIST (IDENT)+)
+    ;
+
+constList
+    : #(CONSTLIST ( constant )+)
+    ;
+
+functionDeclaration
+    : #(FUNCTION IDENT (formalParameterList)? resultType block)
+    ;
+
+resultType
+    : typeIdentifier
+    ;
+
+statement
+    : #(COLON label unlabelledStatement)
+    | unlabelledStatement
+    ;
+
+unlabelledStatement
+    : simpleStatement
+    | structuredStatement
+    ;
+
+simpleStatement
+    : assignmentStatement
+    | procedureStatement
+    | gotoStatement
+    ;
+
+assignmentStatement
+    : #(ASSIGN variable expression)
+    ;
+
+/** 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.
+ */
+variable
+    : #(LBRACK variable (expression)+)
+    | #(LBRACK2 variable (expression)+)
+    | #(DOT variable IDENT)
+    | #(POINTER variable)
+    | #(AT IDENT)
+    | IDENT
+    ;
+
+expression
+    : #(EQUAL expression expression)
+    | #(NOT_EQUAL expression expression)
+    | #(LTH expression expression)
+    | #(LE expression expression)
+    | #(GE expression expression)
+    | #(GT expression expression)
+    | #(IN expression expression)
+    | #(PLUS expression (expression)?)
+    | #(MINUS expression (expression)?)
+    | #(OR expression expression)
+    | #(STAR expression expression)
+    | #(SLASH expression expression)
+    | #(DIV expression expression)
+    | #(MOD expression expression)
+    | #(AND expression expression)
+    | #(NOT expression)
+    | variable
+    | functionDesignator
+    | set
+    | NUM_INT
+    | NUM_REAL
+    | #(CHR (NUM_INT|NUM_REAL))
+    | string
+    | NIL
+    ;
+
+functionDesignator
+    : #(FUNC_CALL IDENT (parameterList)?)
+    ;
+
+parameterList
+    : #( ARGLIST (actualParameter)+ )
+    ;
+
+set
+    : #(SET (element)*)
+    ;
+
+element
+    : #(DOTDOT expression expression)
+    | expression
+    ;
+
+procedureStatement
+    : #(PROC_CALL IDENT ( parameterList )?)
+    ;
+
+actualParameter
+    : expression
+    ;
+
+gotoStatement
+    : #(GOTO label)
+    ;
+
+structuredStatement
+    : compoundStatement
+    | conditionalStatement
+    | repetetiveStatement
+    | withStatement
+    ;
+
+compoundStatement
+    : statements
+    ;
+
+statements
+    : #(BLOCK (statement)*)
+    ;
+
+conditionalStatement
+    : ifStatement
+    | caseStatement
+    ;
+
+ifStatement
+    : #(IF expression statement (statement)?)
+    ;
+
+caseStatement //pspsps ???
+    : #(CASE expression
+        ( caseListElement )+
+        ( statements )?
+       )
+    ;
+
+caseListElement
+    : #(COLON constList statement)
+    ;
+
+repetetiveStatement
+    : whileStatement
+    | repeatStatement
+    | forStatement
+    ;
+
+whileStatement
+    : #(WHILE expression statement)
+    ;
+
+repeatStatement
+    : #(REPEAT statements expression)
+    ;
+
+forStatement
+    : #(FOR IDENT forList statement)
+    ;
+
+forList
+    : #(TO initialValue finalValue)
+    | #(DOWNTO initialValue finalValue)
+    ;
+
+initialValue
+    : expression
+    ;
+
+finalValue
+    : expression
+    ;
+
+withStatement
+    : #(WITH recordVariableList statement)
+    ;
+
+recordVariableList
+    : ( variable )+
+    ;
diff --git a/languages/pascal/pascalsupport_part.cpp b/languages/pascal/pascalsupport_part.cpp
new file mode 100644
index 00000000..0c5f96f2
--- /dev/null
+++ b/languages/pascal/pascalsupport_part.cpp
@@ -0,0 +1,323 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ ***************************************************************************/
+#include <fstream>
+
+#include <qdir.h>
+#include <qtimer.h>
+#include <qwhatsthis.h>
+
+#include <kiconloader.h>
+#include <klocale.h>
+#include <kdevgenericfactory.h>
+#include <kdebug.h>
+#include <kapplication.h>
+#include <kstatusbar.h>
+
+#include <antlr/ASTFactory.hpp>
+
+#include "catalog.h"
+#include <kdevcore.h>
+#include <kdevmainwindow.h>
+#include <kdevpartcontroller.h>
+#include <kdevproject.h>
+#include <kdevplugininfo.h>
+
+#include "pascalsupport_part.h"
+#include "problemreporter.h"
+#include "PascalLexer.hpp"
+#include "PascalParser.hpp"
+#include "PascalStoreWalker.hpp"
+
+struct PascalSupportPartData{
+    ProblemReporter* problemReporter;
+
+    PascalSupportPartData()
+        : problemReporter( 0 )
+        {}
+};
+
+typedef KDevGenericFactory<PascalSupportPart> PascalSupportFactory;
+static const KDevPluginInfo data("kdevpascalsupport");
+K_EXPORT_COMPONENT_FACTORY( libkdevpascalsupport, PascalSupportFactory( data ) )
+
+PascalSupportPart::PascalSupportPart(QObject *parent, const char *name, const QStringList &)
+  : KDevLanguageSupport(&data, parent, name ? name : "KDevPascalSupport" ),
+    d( new PascalSupportPartData() )
+{
+    setInstance(PascalSupportFactory::instance());
+    setXMLFile("kdevpascalsupport.rc");
+
+    d->problemReporter = new ProblemReporter( this );
+    connect( core(), SIGNAL(configWidget(KDialogBase*)),
+             d->problemReporter, SLOT(configWidget(KDialogBase*)) );
+
+    connect( core(), SIGNAL(projectOpened()), this, SLOT(projectOpened()) );
+    connect( core(), SIGNAL(projectClosed()), this, SLOT(projectClosed()) );
+    connect( partController(), SIGNAL(savedFile(const KURL&)),
+             this, SLOT(savedFile(const KURL&)) );
+    connect( core(), SIGNAL(contextMenu(QPopupMenu *, const Context *)),
+             this, SLOT(contextMenu(QPopupMenu *, const Context *)) );
+    connect( core(), SIGNAL(configWidget(KDialogBase*)),
+             this, SLOT(configWidget(KDialogBase*)) );
+    connect( core( ), SIGNAL( projectConfigWidget( KDialogBase* ) ), this,
+             SLOT( projectConfigWidget( KDialogBase* ) ) );
+
+    mainWindow()->embedOutputView( d->problemReporter, i18n("Problems"), i18n("problem reporter") );
+    QWhatsThis::add(d->problemReporter, i18n("<b>Problem reporter</b><p>This window shows various \"problems\" in your project. "
+        "It displays errors reported by a language parser."));
+}
+
+PascalSupportPart::~PascalSupportPart()
+{
+    mainWindow()->removeView( d->problemReporter );
+    delete( d->problemReporter );
+
+    delete( d );
+}
+
+PascalSupportPart::Features PascalSupportPart::features()
+{
+    return Features(Classes | Structs | Functions | Variables | Declarations);
+}
+
+void PascalSupportPart::projectOpened()
+{
+    connect(project(), SIGNAL(addedFilesToProject(const QStringList &)),
+        this, SLOT(addedFilesToProject(const QStringList &)));
+    connect(project(), SIGNAL(removedFilesFromProject(const QStringList &)),
+        this, SLOT(removedFilesFromProject(const QStringList &)));
+    connect(project(), SIGNAL(projectCompiled()),
+        this, SLOT(slotProjectCompiled()) );
+
+    m_projectFileList = project()->allFiles();
+    m_projectClosed = false;
+
+    QTimer::singleShot(0, this, SLOT(initialParse()));
+}
+
+void PascalSupportPart::projectClosed()
+{
+    m_projectClosed = true;
+}
+
+void PascalSupportPart::configWidget(KDialogBase *dlg)
+{
+    Q_UNUSED( dlg );
+    return;
+}
+
+void PascalSupportPart::projectConfigWidget(KDialogBase *dlg)
+{
+    Q_UNUSED( dlg );
+    return;
+}
+
+void PascalSupportPart::contextMenu(QPopupMenu *popup, const Context *context)
+{
+    Q_UNUSED( popup );
+    Q_UNUSED( context );
+    return;
+}
+
+void PascalSupportPart::savedFile(const KURL &fileName)
+{
+    maybeParse(fileName.path());
+    emit updatedSourceInfo();
+}
+
+void PascalSupportPart::addedFilesToProject(const QStringList &fileList)
+{
+    for (QStringList::ConstIterator it = fileList.begin(); it != fileList.end() ;++it)
+    {
+        QString fn = project()->projectDirectory() + "/" + *it;
+        maybeParse( fn );
+        kapp->processEvents( 500 );
+        emit addedSourceInfo(fn);
+    }
+}
+
+void PascalSupportPart::removedFilesFromProject(const QStringList &fileList)
+{
+    for (QStringList::ConstIterator it = fileList.begin(); it != fileList.end() ;++it)
+    {
+        QString fn = project()->projectDirectory() + "/" + *it;
+
+        emit aboutToRemoveSourceInfo(fn);
+        codeModel()->removeFile( codeModel()->fileByName(fn) );
+    }
+}
+
+void PascalSupportPart::slotProjectCompiled()
+{
+    return;
+}
+
+void PascalSupportPart::initialParse( )
+{
+    kdDebug(9013) << "------------------------------------------> initialParse()" << endl;
+
+    if (project())
+    {
+        kapp->setOverrideCursor(waitCursor);
+
+        /// @todo Progress indicator!
+
+        QStringList files = project()->allFiles();
+        for (QStringList::Iterator it = files.begin(); it != files.end() ;++it){
+            QString fn = project()->projectDirectory() + "/" + *it;
+            maybeParse( fn );
+            kapp->processEvents( 500 );
+        }
+
+        emit updatedSourceInfo();
+
+        kapp->restoreOverrideCursor();
+        mainWindow()->statusBar()->message( i18n("Found 1 problem", "Found %n problems", d->problemReporter->childCount()) );
+    }
+}
+
+void PascalSupportPart::maybeParse( const QString & fileName )
+{
+    kdDebug(9013) << "Maybe parse: " << fileName << endl;
+
+    KMimeType::Ptr mime = KMimeType::findByURL( KURL( fileName ) );
+    if( !mime || mime->name() != "text/x-pascal" )
+	return;
+
+    mainWindow()->statusBar()->message( i18n("Parsing file: %1").arg(fileName) );
+    parse( fileName );
+}
+
+void PascalSupportPart::parse( const QString & fileName )
+{
+    kdDebug(9013) << "PascalSupportPart::parse() -- " << fileName << endl;
+
+    std::ifstream stream( QFile::encodeName( fileName ).data() );
+    QCString _fn = fileName.utf8();
+    std::string fn( _fn.data() );
+
+    PascalLexer lexer( stream );
+    lexer.setFilename( fn );
+    lexer.setProblemReporter( d->problemReporter );
+
+    PascalParser parser( lexer );
+    parser.setFilename( fn );
+    parser.setProblemReporter( d->problemReporter );
+
+    try{
+        antlr::ASTFactory my_factory( "PascalAST", PascalAST::factory );
+        parser.initializeASTFactory(my_factory);
+        parser.setASTFactory( &my_factory );
+
+        lexer.resetErrors();
+        parser.resetErrors();
+
+        parser.compilationUnit();
+        int errors = lexer.numberOfErrors() + parser.numberOfErrors();
+        RefPascalAST ast = RefPascalAST( parser.getAST() );
+
+        if( errors == 0 && ast != antlr::nullAST ){
+            kdDebug(9013) << "-------------------> start StoreWalker" << endl;
+/*            PascalStoreWalker walker;
+            walker.setFileName( fileName );
+            walker.setCodeModel( codeModel() );
+            walker.compilationUnit( ast );*/
+        }
+
+    } catch( antlr::ANTLRException& ex ){
+        kdDebug() << "*exception*: " << ex.toString().c_str() << endl;
+        d->problemReporter->reportError( ex.getMessage().c_str(),
+                                         fileName,
+                                         lexer.getLine(),
+                                         lexer.getColumn() );
+    }
+}
+
+KMimeType::List PascalSupportPart::mimeTypes( )
+{
+    KMimeType::List list;
+    KMimeType::Ptr mime = KMimeType::mimeType( "text/x-pascal" );
+    if( mime )
+	list << mime;
+    return list;
+}
+
+QString PascalSupportPart::formatTag( const Tag & inputTag )
+{
+    Tag tag = inputTag;
+
+    switch( tag.kind() )
+    {
+        case Tag::Kind_Namespace:
+            return QString::fromLatin1("unit ") + tag.name();
+
+        case Tag::Kind_Class:
+            return QString::fromLatin1("class ") + tag.name();
+
+        case Tag::Kind_Function:
+        case Tag::Kind_FunctionDeclaration:
+        {
+            return tag.name() + "()";
+        }
+        break;
+
+        case Tag::Kind_Variable:
+        case Tag::Kind_VariableDeclaration:
+        {
+            return QString::fromLatin1("var ") + tag.name();
+        }
+        break;
+    }
+    return tag.name();
+}
+
+QString PascalSupportPart::formatModelItem( const CodeModelItem * item, bool shortDescription )
+{
+    if (item->isFunction() || item->isFunctionDefinition() )
+    {
+        const FunctionModel *model = static_cast<const FunctionModel*>(item);
+        QString function;
+        QString args;
+        ArgumentList argumentList = model->argumentList();
+        for (ArgumentList::const_iterator it = argumentList.begin(); it != argumentList.end(); ++it)
+        {
+            args.isEmpty() ? args += "" : args += ", " ;
+            args += formatModelItem((*it).data());
+        }
+
+        function += model->name() + "(" + args + ")";
+
+        if( !shortDescription )
+            function += (model->isVirtual() ? QString("virtual; ") : QString("") ) + model->resultType() + " ";
+
+        return function;
+    }
+    else if (item->isVariable())
+    {
+        const VariableModel *model = static_cast<const VariableModel*>(item);
+        if( shortDescription )
+            return model->name();
+        return model->name() + ": " + model->type();
+    }
+    else if (item->isArgument())
+    {
+        const ArgumentModel *model = static_cast<const ArgumentModel*>(item);
+        QString arg;
+        arg += model->name();
+        arg += ": " + model->type();
+        if( !shortDescription )
+            arg += model->defaultValue().isEmpty() ? QString("") : QString(" = ") + model->defaultValue();
+        return arg.stripWhiteSpace();
+    }
+    else
+        return KDevLanguageSupport::formatModelItem( item, shortDescription );
+}
+
+#include "pascalsupport_part.moc"
diff --git a/languages/pascal/pascalsupport_part.h b/languages/pascal/pascalsupport_part.h
new file mode 100644
index 00000000..4319d1f9
--- /dev/null
+++ b/languages/pascal/pascalsupport_part.h
@@ -0,0 +1,62 @@
+/***************************************************************************
+ *   Copyright (C) 2003 Alexander Dymo                                     *
+ *   cloudtemple@mksat.net                                                 *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ ***************************************************************************/
+#ifndef __KDEVPART_PASCALSUPPORT_H__
+#define __KDEVPART_PASCALSUPPORT_H__
+
+#include <qguardedptr.h>
+#include "kdevlanguagesupport.h"
+
+class PascalSupportWidget;
+class KDialogBase;
+class QPopupMenu;
+class Context;
+class PascalSupportPartData;
+
+class PascalSupportPart : public KDevLanguageSupport
+{
+    Q_OBJECT
+public:
+    PascalSupportPart(QObject *parent, const char *name, const QStringList &);
+    ~PascalSupportPart();
+
+    virtual Features features();
+    virtual KMimeType::List mimeTypes();
+
+    virtual QString formatTag( const Tag& tag );
+    virtual QString formatModelItem( const CodeModelItem *item, bool shortDescription=false );
+    
+private slots:
+    void projectOpened();
+    void projectClosed();
+    void savedFile(const KURL &fileName);
+    void configWidget(KDialogBase *dlg);
+    void projectConfigWidget(KDialogBase *dlg);
+    void contextMenu(QPopupMenu *popup, const Context *context);
+
+    void addedFilesToProject(const QStringList &fileList);
+    void removedFilesFromProject(const QStringList &fileList);
+    void slotProjectCompiled();
+
+    void initialParse();
+
+private:
+    void maybeParse(const QString &fileName);
+    void parse(const QString &fileName);
+
+    QGuardedPtr<PascalSupportWidget> m_widget;
+
+    bool m_projectClosed;
+    QStringList m_projectFileList;
+
+    PascalSupportPartData* d;
+
+};
+
+#endif
diff --git a/languages/pascal/pascaltemplates b/languages/pascal/pascaltemplates
new file mode 100644
index 00000000..771f7cca
--- /dev/null
+++ b/languages/pascal/pascaltemplates
@@ -0,0 +1,30 @@
+<!DOCTYPE Templates>
+<Templates>
+ <Template code="if ( | ) then
+begin
+end
+else
+begin
+end;" name="ife" description="if else" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="while ( | ) do
+begin
+end;" name="whileb" description="while statement" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="private|" name="pr" description="private" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="public|" name="pu" description="public"  suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="case ( | ) of
+end;" name="caseb" description="case statement" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="protected|" name="pro" description="protected" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="for | :=  to  do
+begin
+end;" name="forb" description="for statement" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="|= class()
+public
+private
+protected
+end;" name="classd" description="class declaration" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="|= record
+end;" name="recordd" description="record declaration" suffixes="Pascal (p,pp,pas,dpr)"/>
+ <Template code="if ( | ) then
+begin
+end;" name="ifb" description="if statement" suffixes="Pascal (p,pp,pas,dpr)"/>
+</Templates>
diff --git a/languages/pascal/problemreporter.cpp b/languages/pascal/problemreporter.cpp
new file mode 100644
index 00000000..7a0a6d0d
--- /dev/null
+++ b/languages/pascal/problemreporter.cpp
@@ -0,0 +1,289 @@
+/*
+   Copyright (C) 2002 by Roberto Raggi <roberto@kdevelop.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   version 2, License as published by the Free Software Foundation.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+*/
+
+#include "problemreporter.h"
+#include "pascalsupport_part.h"
+#include "kdevpartcontroller.h"
+#include "kdevmainwindow.h"
+#include "configproblemreporter.h"
+#include "backgroundparser.h"
+
+#include <kdeversion.h>
+#include <kparts/part.h>
+#include <ktexteditor/editinterface.h>
+#include <ktexteditor/document.h>
+#include <ktexteditor/markinterface.h>
+
+#include <ktexteditor/markinterfaceextension.h>
+
+#include <kdebug.h>
+#include <klocale.h>
+#include <kstatusbar.h>
+#include <kurl.h>
+#include <kapplication.h>
+#include <kiconloader.h>
+
+#include <kconfig.h>
+
+#include <qtimer.h>
+#include <qregexp.h>
+#include <qvbox.h>
+#include <kdialogbase.h>
+
+
+class ProblemItem: public QListViewItem{
+public:
+	ProblemItem( QListView* parent, const QString& level, const QString& problem,
+				 const QString& file, const QString& line, const QString& column  )
+		: QListViewItem( parent, level, problem, file, line, column ) {}
+
+	ProblemItem( QListViewItem* parent, const QString& level, const QString& problem,
+				 const QString& file, const QString& line, const QString& column  )
+		: QListViewItem( parent, level, problem, file, line, column ) {}
+
+	int compare( QListViewItem* item, int column, bool ascending ) const {
+		if( column == 3 || column == 4 ){
+			int a = text( column ).toInt();
+			int b = item->text( column ).toInt();
+			if( a == b )
+				return 0;
+			return( a > b ? -1 : 1 );
+		}
+		return QListViewItem::compare( item, column, ascending );
+	}
+
+};
+
+ProblemReporter::ProblemReporter( PascalSupportPart* part, QWidget* parent, const char* name )
+    : QListView( parent, name ),
+      m_pascalSupport( part ),
+      m_editor( 0 ),
+      m_document( 0 ),
+	  m_markIface( 0 ),
+      m_bgParser( 0 )
+{
+    addColumn( i18n("Level") );
+    addColumn( i18n("Problem") );
+    addColumn( i18n("File") );
+    addColumn( i18n("Line") );
+    //addColumn( i18n("Column") );
+    setAllColumnsShowFocus( TRUE );
+
+    m_timer = new QTimer( this );
+
+    connect( part->partController(), SIGNAL(activePartChanged(KParts::Part*)),
+             this, SLOT(slotActivePartChanged(KParts::Part*)) );
+    connect( part->partController(), SIGNAL(partAdded(KParts::Part*)),
+             this, SLOT(slotPartAdded(KParts::Part*)) );
+    connect( part->partController(), SIGNAL(partRemoved(KParts::Part*)),
+             this, SLOT(slotPartRemoved(KParts::Part*)) );
+
+    connect( m_timer, SIGNAL(timeout()), this, SLOT(reparse()) );
+
+    connect( this, SIGNAL(doubleClicked(QListViewItem*)),
+             this, SLOT(slotSelected(QListViewItem*)) );
+    connect( this, SIGNAL(returnPressed(QListViewItem*)),
+             this, SLOT(slotSelected(QListViewItem*)) );
+
+    configure();
+}
+
+ProblemReporter::~ProblemReporter()
+{
+    if( m_bgParser ) {
+        m_bgParser->wait();
+    }
+
+    delete( m_bgParser );
+    m_bgParser = 0;
+}
+
+void ProblemReporter::slotActivePartChanged( KParts::Part* part )
+{
+    if( !part )
+        return;
+    
+    if( m_editor )
+	reparse();
+		
+    m_document = dynamic_cast<KTextEditor::Document*>( part );
+    if( m_document ){
+        m_filename = m_document->url().path();
+    }
+
+    m_editor = dynamic_cast<KTextEditor::EditInterface*>( part );
+    if( m_editor )
+        connect( m_document, SIGNAL(textChanged()), this, SLOT(slotTextChanged()) );
+
+	m_markIface = dynamic_cast<KTextEditor::MarkInterface*>( part );
+
+	m_timer->changeInterval( m_delay );
+}
+
+void ProblemReporter::slotTextChanged()
+{
+    if( m_active )
+        m_timer->changeInterval( m_delay );
+}
+
+void ProblemReporter::reparse()
+{
+    kdDebug(9007) << "ProblemReporter::reparse()" << endl;
+
+    kdDebug() << "1" << endl;
+
+    if( !m_editor )
+        return;
+
+    kdDebug() << "2" << endl;
+
+    m_timer->stop();
+
+    kdDebug() << "3" << endl;
+
+    if( m_bgParser ) {
+        if( m_bgParser->running() ) {
+            m_timer->changeInterval( m_delay );
+            return;
+        }
+
+        delete( m_bgParser );
+        m_bgParser = 0;
+    }
+
+    kdDebug() << "4" << endl;
+
+    QListViewItem* current = firstChild();
+    while( current ){
+        QListViewItem* i = current;
+        current = current->nextSibling();
+
+        if( i->text(2) == m_filename )
+            delete( i );
+    }
+
+    kdDebug() << "5" << endl;
+
+	if( m_markIface ){
+		QPtrList<KTextEditor::Mark> marks = m_markIface->marks();
+		QPtrListIterator<KTextEditor::Mark> it( marks );
+		while( it.current() ){
+			m_markIface->removeMark( it.current()->line, KTextEditor::MarkInterface::markType07 );
+			++it;
+		}
+	}
+
+    kdDebug() << "6" << endl;
+
+    m_bgParser = new BackgroundParser( this, m_editor->text(), m_filename );
+
+    kdDebug() << "7" << endl;
+
+    m_bgParser->start();
+
+    kdDebug() << "8" << endl;
+}
+
+void ProblemReporter::slotSelected( QListViewItem* item )
+{
+    KURL url( item->text(2) );
+    int line = item->text( 3 ).toInt();
+    // int column = item->text( 4 ).toInt();
+    m_pascalSupport->partController()->editDocument( url, line-1 );
+}
+
+void ProblemReporter::reportError( QString message,
+                                   QString filename,
+                                   int line, int column )
+{
+	if( m_markIface ){
+		m_markIface->addMark( line-1, KTextEditor::MarkInterface::markType07 );
+	}
+	
+    new ProblemItem( this,
+                       "error",
+                       message.replace( QRegExp("\n"), "" ),
+                       filename,
+                       QString::number( line ),
+                       QString::number( column ) );
+}
+
+void ProblemReporter::reportWarning( QString message,
+                                     QString filename,
+                                     int line, int column )
+{
+    new ProblemItem( this,
+                       "warning",
+                       message.replace( QRegExp("\n"), "" ),
+                       filename,
+                       QString::number( line ),
+                       QString::number( column ) );
+}
+
+void ProblemReporter::reportMessage( QString message,
+                                     QString filename,
+                                     int line, int column )
+{
+    new QListViewItem( this,
+                       "message",
+                       message.replace( QRegExp("\n"), "" ),
+                       filename,
+                       QString::number( line ),
+                       QString::number( column ) );
+}
+
+void ProblemReporter::configure()
+{
+    kdDebug(9007) << "ProblemReporter::configure()" << endl;
+    KConfig* config = kapp->config();
+    config->setGroup( "General Options" );
+    m_active = config->readBoolEntry( "EnablePascalBgParser", TRUE );
+    m_delay = config->readNumEntry( "BgParserDelay", 500 );
+}
+
+void ProblemReporter::configWidget( KDialogBase* dlg )
+{
+    /// \FIXME adymo: use problem reporter configuration
+    Q_UNUSED(dlg);
+/*    QVBox *vbox = dlg->addVBoxPage(i18n("Pascal Parsing"));
+    ConfigureProblemReporter* w = new ConfigureProblemReporter( vbox );
+    connect(dlg, SIGNAL(okClicked()), w, SLOT(accept()));
+    connect(dlg, SIGNAL(okClicked()), this, SLOT(configure()));*/
+}
+
+void ProblemReporter::slotPartAdded( KParts::Part* part )
+{
+	KTextEditor::MarkInterfaceExtension* iface = dynamic_cast<KTextEditor::MarkInterfaceExtension*>( part );
+	
+	if( !iface )
+		return;
+		
+	iface->setPixmap( KTextEditor::MarkInterface::markType07, SmallIcon("stop") );
+}
+
+void ProblemReporter::slotPartRemoved( KParts::Part* part )
+{
+    kdDebug(9007) << "ProblemReporter::slotPartRemoved()" << endl;
+    if( part == m_document ){
+        m_document = 0;
+        m_editor = 0;
+        m_timer->stop();
+    }
+}
+
+#include "problemreporter.moc"
diff --git a/languages/pascal/problemreporter.h b/languages/pascal/problemreporter.h
new file mode 100644
index 00000000..3fa3ee28
--- /dev/null
+++ b/languages/pascal/problemreporter.h
@@ -0,0 +1,78 @@
+/*
+   Copyright (C) 2002 by Roberto Raggi <roberto@kdevelop.org>
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public
+   version 2, License as published by the Free Software Foundation.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public License
+   along with this library; see the file COPYING.LIB.  If not, write to
+   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+*/
+
+#ifndef PROBLEMSREPORTER_H
+#define PROBLEMSREPORTER_H
+
+#include <qlistview.h>
+
+class PascalSupportPart;
+class QTimer;
+class KDialogBase;
+class BackgroundParser;
+
+namespace KParts{
+    class Part;
+}
+
+namespace KTextEditor{
+    class EditInterface;
+	class MarkInterface;
+    class Document;
+}
+
+class ProblemReporter: public QListView{
+    Q_OBJECT
+public:
+    ProblemReporter( PascalSupportPart* part, QWidget* parent=0, const char* name=0 );
+    virtual ~ProblemReporter();
+
+    virtual void reportError( QString message, QString filename,
+                              int line, int column );
+
+    virtual void reportWarning( QString message, QString filename,
+                                int line, int column );
+
+    virtual void reportMessage( QString message, QString filename,
+                                int line, int column );
+
+public slots:
+    void reparse();
+    void configure();
+    void configWidget( KDialogBase* );
+
+private slots:
+    void slotPartAdded( KParts::Part* );
+    void slotPartRemoved( KParts::Part* );
+    void slotActivePartChanged( KParts::Part* );
+    void slotTextChanged();
+    void slotSelected( QListViewItem* );
+
+private:
+    PascalSupportPart* m_pascalSupport;
+    KTextEditor::EditInterface* m_editor;
+    KTextEditor::Document* m_document;
+    KTextEditor::MarkInterface* m_markIface;
+    QTimer* m_timer;
+    QString m_filename;
+    int m_active;
+    int m_delay;
+    BackgroundParser* m_bgParser;
+};
+
+#endif